编程练习:两数相加

题目-LeetCode

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，而且它们的每一个节点只能存储 一位 数字。若是，咱们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您能够假设除了数字 0 以外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
缘由：342 + 465 = 807

分析

• 这实际上是链表的操做，在以前数据结构中很常见，对两个链表进行操做；
• 另外这里两数被表示成链表形式，好比2->4->3 个位是2，十位是4，百位是3；其实能够按照算术中的加法，个位与个位相加、、、，因此这样就比较简单了；

链表长度

• 两个链表长度相同比较好处理，可是还要注意链表长度不同带来的问题；详细见代码分析！

实现（java）

节点表示

/**
 * 列表节点定义
 */
class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x;}
}

处理函数

/**
     * 两个数相加
     * @param l1
     * @param l2
     * @return
     */
    public static  ListNode addTwoNumbers(ListNode l1, ListNode l2) {

        // 以l1为返回列表
        ListNode moveNode = l1; // 移动节点
        ListNode tempNode = null;
        int outNum = 0;
        // 1. 处理前面两个节点相加部分
        while (l2 != null && moveNode != null) {
            int value = l2.val + moveNode.val + outNum;
            moveNode.val = value % 10;
            outNum = value / 10;
            if (moveNode.next == null){
                tempNode = moveNode; // 最后一个节点记录下来
            }
            moveNode = moveNode.next;
            l2 = l2.next;
        }
        // 2. 处理列表超长
        if (l2 == null && moveNode != null){
            if (outNum != 0){ // moveNode != null
                while (moveNode != null) {
                    int value = moveNode.val + outNum;
                    moveNode.val = value % 10;
                    outNum = value / 10;
                    if (moveNode.next == null){
                        break;
                    }
                    moveNode = moveNode.next;
                }
            }

        }else if( moveNode == null && l2 != null){
            tempNode.next = l2;
            tempNode = l2;
            if (outNum != 0){ // l2 != null
                while (tempNode != null) {
                    int value = tempNode.val + outNum;
                    tempNode.val = value % 10;
                    outNum = value / 10;
                    if (tempNode.next == null){
                        break;
                    }
                    tempNode = tempNode.next;
                }
            }

        }else{
            if (outNum != 0){ // 两个长度同样
                ListNode node = new ListNode(outNum);
                tempNode.next = node;
            }
        }
        // 若是上面一直相加超过10，则最后溢出位处理之
        if (outNum != 0) {
            ListNode node = new ListNode(outNum);
            if (moveNode != null){
                moveNode.next = node;
            }else {
                tempNode.next = node;
            }
        }
        return  l1;
    }

这段代码中还能够优化，当时在提交到LeetCode不正确后，变只图经过测试，没有考虑到性能！

主函数调用

public static void main(String[] args) {

        ListNode l1 = new ListNode(9);
        ListNode node1 = new ListNode(8);
        ListNode node2 = new ListNode(3);
        l1.next = node1;
        node1.next = node2;
        ListNode l2 = new ListNode(9);
        ListNode node3 = new ListNode(9);
        ListNode node4 = new ListNode(4);
        l2.next = node3;
        node3.next = node4;

        ListNode nodes = addTwoNumbers(l1, l2);

        while (nodes != null) {
            if (nodes.next != null){
                System.out.print(nodes.val + "->");
            }else {
                System.out.print(nodes.val);
            }
            nodes = nodes.next;
        }
    }

结果

8->8->8

最后

此致，敬礼！