LeetCode 445 两个数相加2

给定两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储单个数字。将这两数相加会返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

进阶:

如果输入链表不能修改该如何处理？换句话说，你不能对列表中的节点进行翻转。

示例:

输入: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
输出: 7 -> 8 -> 0 -> 7

解题思路：
方法一：双栈法
给定两个栈，遍历两个链表，分别将元素入栈；然后从栈顶开始弹出元素，一次相加，人工模拟加法运算。

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        if(!l1 || !l2)return l1 == NULL ? l2 : l1;//处理传进来有NULL的情况
        
        //根据链表构建两个栈
        stack<int> s1,s2;
        while(l1!=NULL){
            s1.push(l1->val);
            l1 = l1->next;
        }
        while(l2!= NULL){
            s2.push(l2->val);
            l2 = l2->next;
        }
        
        //根据两个栈计算数值并建表
        int carry = 0,n1 = 0,n2 = 0,sum = 0;
        ListNode* dummy = new ListNode(-1);//创建头节点
        ListNode* tmp = NULL;
        while(!s1.empty() || !s2.empty() || carry){
            
            if(s1.empty())n1 = 0;
            else {n1 = s1.top();s1.pop();}
            
            if(s2.empty())n2 = 0;
            else{n2 = s2.top();s2.pop();}
            
            sum = (n1 + n2 + carry);
            
            //头插法建表
            tmp = new ListNode(sum%10);
            tmp->next = dummy->next;
            dummy->next = tmp;
            
            //处理进位，给下一次迭代用
            carry = sum/10; 
        }
        
        return dummy->next;//注意别把头节点也一起返回了
    }
};

方法二：递归

class Solution {
public:
    pair<ListNode*, int> dfs(ListNode* l1, ListNode* l2, int d1, int d2) {
        if (l1 == NULL || l2 == NULL) {
            return {NULL, 0};
        }
        pair<ListNode*, int> p;
        int val = 0;
        if (d1 == d2) {
            p = dfs(l1->next, l2->next, d1 - 1, d2 - 1);
            val = p.second + l1->val + l2->val;
        } else if (d1 > d2) {
            p = dfs(l1->next, l2, d1 - 1, d2);
            val = p.second + l1->val;
        } else {
            p = dfs(l1, l2->next, d1, d2 - 1);
            val = p.second + l2->val;
        }
        auto node = new ListNode(val % 10);
        node->next = p.first;
        return {node, val / 10};
    }
    int depth(ListNode* l) {
        int d = 0;
        while (l != NULL) {
            ++d;
            l = l->next;
        }
        return d;
    }
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        if (l1 == NULL) return l2;
        if (l2 == NULL) return l1;
        int d1 = depth(l1);
        int d2 = depth(l2);
        auto p = dfs(l1, l2, d1, d2);
        if (p.second > 0) {
            auto node = new ListNode(p.second);
            node->next = p.first;
            return node;
        }
        return p.first;
    }
};