链表正向、反向相加

LeetCode - 445. Add Two Numbers II

You are given two non-empty linked lists representing two non-negative integers. The most significant digit comes first and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
You may assume the two numbers do not contain any leading zero, except the number 0 itself.
Follow up: What if you cannot modify the input lists? In other words, reversing the lists is not allowed.

Example:
Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4) Output: 7 -> 8 -> 0 -> 7

  就是链表的反向相加，题目里写了能不能不翻转链表，用正向相加的方式，那用两个stack存起来再算应该是比较简单好懂的方法了，AC代码如下：

ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
    stack<int> s1, s2;
    while(l1){
        s1.push(l1->val);
        l1 = l1->next;
    }
    while(l2){
        s2.push(l2->val);
        l2 = l2->next;
    }
    int sum = 0;
    bool carry = false;
    ListNode *head, *post = nullptr;
    while(!s1.empty() || !s2.empty()) {
        sum = carry ? 1 : 0;
        if(!s1.empty()) {
            sum += s1.top();
            s1.pop();
        }
        if(!s2.empty()) {
            sum += s2.top();
            s2.pop();
        }
        carry = sum >= 10;
        head = new ListNode(sum % 10);
        head->next = post;
        post = head;
    }
    if(carry) {
        head = new ListNode(1);
        head->next = post;
    }
    return head;
}

  学习起见，翻转再正向加的方法也记录一下，也就是 LeetCode - 2. Add Two Numbers 和 206. Reverse Linked List 两道题加起来：

ListNode* reverseList(ListNode* head) {
    if(head==NULL || head->next==NULL) return head;
    ListNode *pre = head, *p = head->next, *nxt;  
    pre->next = nullptr;   // 重要！
    while(p) {  
        nxt = p->next;  
        p->next = pre;  
        pre = p;  
        p = nxt;  
    }  
    return pre;  
}
    
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
    // 翻转链表
    l1 = reverseList(l1);
    l2 = reverseList(l2);
    
    // 正向相加
    ListNode *dummyHead = new ListNode(-1);
    ListNode *cur = dummyHead;
    bool carry = false;
    while (l1 || l2) {
        int n1 = l1 ? l1->val : 0, n2 = l2 ? l2->val : 0;
        int sum = n1 + n2 + (carry ? 1 : 0);
        carry = sum >= 10;
        cur->next = new ListNode(sum % 10);
        cur = cur->next;
        if (l1) l1 = l1->next;
        if (l2) l2 = l2->next;
    }
    if (carry)
        cur->next = new ListNode(1);
    return reverseList(dummyHead->next);    // 结果还要再反转
}