NC40 两个链表生成相加链表

描述

 

假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。

给定两个这种链表，请生成代表两个整数相加值的结果链表。

数据范围：0≤n,m≤1000000，链表任意值0≤val≤9
要求：空间复杂度 O(n)，时间复杂度 O(n)

例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。

示例1

输入：[9,3,7],[6,3]

返回值：{1,0,0,0}

说明：

如题面解释  

示例2

输入：[0],[6,3]

返回值：{6,3}

备注：

1≤n,m≤106
0≤ai​,bi​≤9

 ======================================

解题思路：

一.反转链表，然后相加

通过反转链表来实现右对齐，相加的结果如果有进位，把进位留给下次继续相加，没有进位就添加到新链表节点。没生成一个新节点都把已经生成好的挂在新节点上，并且把链表头移动向最新节点。2个链表都走完就是相加后的结果。更简单一点的实现：反转之后直接依次相加，然后依次挂在新链表上，都遍历之后，再次反转链表就是所求结果。

时间复杂度O（N）空间复杂度O（N）

public ListNode addInList (ListNode head1, ListNode head2) {
        if(head1==null&&head2==null)return null;
        // write code here
        ListNode revNode1 = reverseNode(head1);
        ListNode revNode2 = reverseNode(head2);
        /**
         * 9->3->7
         *    6->3
         * 7->3->9
         * 3->6
         * 10 10 10
         * 0 0 0 0 1
         */
        int temp = 0;
        ListNode listNode = null;
        ListNode pre = null;
        while (revNode1!=null&&revNode2!=null){
            int sum = revNode1.val + revNode2.val + temp;
            // 有进位
            if (sum>=10){
                listNode = new ListNode(sum%10); 
                listNode.next = pre;
                pre = listNode;
                temp = 1;
            } else {
                listNode = new ListNode(sum); 
                listNode.next = pre;
                pre = listNode;
                temp = 0;
            }
            revNode1 = revNode1.next;
            revNode2 = revNode2.next;
        }
        while(revNode1!=null){
            int sum = revNode1.val + temp;
            int val = 0;
            if(sum>=10){
                val = sum%10;
                temp = 1;
            } else {
                val = sum;
                temp = 0;
            }
            listNode = new ListNode(val);
            listNode.next = pre;
             pre = listNode;
            revNode1 = revNode1.next;
        }
        while(revNode2!=null){
            int sum = revNode2.val + temp;
            int val = 0;
            if(sum>=10){
                val = sum%10;
                temp = 1;
            } else {
                val = sum;
                temp = 0;
            }
           listNode = new ListNode(val);
            listNode.next = pre;
            pre = listNode;
            revNode2 = revNode2.next;
        }
        if(temp == 1) {
            listNode = new ListNode(temp);
            listNode.next = pre;
            pre = listNode;
        }
        
        return pre;
    }
    
        public ListNode reverseNode(ListNode node){
        if(node == null) return null;
        ListNode pre = null;
        while (node!=null){
            ListNode temp = node.next;
            node.next = pre;
            pre = node;
            node = temp;
        }
        return pre;
    }

二、将链表数据存栈，然后弹栈运算

将链表数据入栈，根据栈特性，弹出时会倒序，一次相加计算，大于10取余，进位，将计算结果依次挂载到最新节点，然后得到最终结果。