两个链表生成相加链表

题目

描述
假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。
给定两个这种链表，请生成代表两个整数相加值的结果链表。
数据范围：0≤n,m≤1000000，链表任意值 0≤val≤9
要求：空间复杂度 O(n)，时间复杂度 O(n)
例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。

思路

按照小学学的两个数相加的运算方法，一位对应一位相加然后进到高位。所以我们将链表反转，然后对应位置相加的值存起来。如果一个链表更长，那么将剩下的和之前进的数相加继续传递下去，最后storage里面存的就是结果，然后根据这个结果创建新的链表。

代码

python版本：

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param head1 ListNode类 
# @param head2 ListNode类 
# @return ListNode类
#
class Solution:
    def addInList(self , head1: ListNode, head2: ListNode) -> ListNode:
        # write code here
        reverse_head1, num1 = self.reverse(head1)
        reverse_head2, num2 = self.reverse(head2)
        carry = 0
        storage = []
        while(reverse_head1 != None and reverse_head2 != None):
            per_node_val = reverse_head1.val + reverse_head2.val + carry
            storage.append(per_node_val%10)
            carry = 1 if per_node_val>= 10 else 0
            reverse_head1 = reverse_head1.next
            reverse_head2 = reverse_head2.next
        rest = reverse_head1 if num1>num2 else reverse_head2
        while(rest != None):
            rest_val = rest.val+carry
            storage.append(rest_val%10)
            carry = 1 if rest_val>= 10 else 0
            rest = rest.next
            
        if carry != 0:
            storage.append(carry)
        new_node = ListNode(-1)
        sg = new_node
        while(storage):
            new_node.next = ListNode(storage.pop())
            new_node = new_node.next
        return sg.next
    
    def reverse(self, head: ListNode)-> ListNode: 
        pre = None
        cur = head
        num = 0
        while(cur):
            num+=1
            tmp = cur.next
            cur.next = pre
            pre = cur
            cur = tmp
        return pre, num

c++版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head1 ListNode类 
     * @param head2 ListNode类 
     * @return ListNode类
     */
    ListNode* addInList(ListNode* head1, ListNode* head2) {
        // write code here
        ListNode *last1;
        ListNode *last2;
        ListNode *pre1 = NULL;
        ListNode *cur1 = head1;
        int num1 = 0;
        int num2 = 0;
        while(cur1){
            num1++;
            ListNode *tmp1 = cur1->next;
            cur1->next = pre1;
            pre1 = cur1;
            cur1 = tmp1;
        }
        last1 = pre1;
        
        ListNode *pre2 = NULL;
        ListNode *cur2 = head2;
        while(cur2){
            ListNode *tmp2 = cur2->next;
            cur2->next = pre2;
            pre2 = cur2;
            cur2 = tmp2;
        }
        last2 = pre2;
        int carry=0;
        stack<int> storage;
        while(last1 && last2){
            num2++;
            int per_val = last1->val+last2->val+carry;
            carry = per_val>=10 ? 1 : 0;
            storage.push(per_val%10);
            last1 = last1->next;
            last2 = last2->next;
            }
        ListNode *rest = num1 > num2 ? last1 : last2;
        while(rest){
            int rest_val = rest->val+carry;
            carry = rest_val>=10 ? 1 : 0;
            storage.push(rest_val%10);
            rest = rest->next;
        }
        if(carry != 0){
            storage.push(carry);
        }
        
        ListNode *res = new ListNode(-1);
        ListNode *sg;
        sg = res;
        while(storage.size()){
            int val = storage.top();
            res->next = new ListNode(val);
            res = res->next;
            storage.pop();
        }
        return sg->next;
        }
};