记录-23.7.10

时隔N天…
记录一下几个类似的题目

LC 两数相加

链表逆序存储，所以直接按照顺序进行计算就好了，就是在相加过程中要注意进位的问题。
然后在head前面可以用一个虚拟头节点，这样可以避免一些边界问题。

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* dummyHead = new ListNode();
        ListNode* cur = dummyHead;
        int carry = 0;
        while(l1 || l2){
            int val = carry;
            if(l1){
                val += l1->val;
                l1 = l1->next;
            }
            if(l2){
                val += l2->val;
                l2 = l2->next;
            }
            carry = val>9 ? 1:0;
            val = val%10;
            ListNode* temp = new ListNode(val);
            cur->next = temp;
            cur = cur->next;
        }
        if(carry>0){
            ListNode* temp = new ListNode(carry);
            cur->next = temp;
            cur = cur->next;
        }
        return dummyHead->next;
    }
};

LC445 两数相加2

这里的数字是顺序存储的，所以需要做一个逆序的过程。因为加法运算是从个位开始计算的，但是链表顺序存储的话在表头的部分是高位，如果从高位开始进行加法运算就会不好计算进位。
进行逆序计算有两种方法：

1. 链表反转
2. 通过stack等其他数据结构进行结果的存储，然后进行加法运算

这题和剑指 Offer II 025. 链表中的两数相加是相同的题目。

链表反转

这里就是单纯得先对链表进行反转，然后使用上面两数相加的方法。

class Solution {
public:
   ListNode* reverse(ListNode* head){
       ListNode* pre = NULL;
       ListNode* cur = head;
       ListNode* temp;
       while(cur){
           temp = cur->next;
           cur->next = pre;
           pre = cur;
           cur = temp;
       }
       return pre;
   }
   ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
       l1 = reverse(l1);
       l2 = reverse(l2);
       ListNode* dummyHead = new ListNode();
       ListNode* cur = dummyHead;
       int carry = 0;
       while(l1 || l2){
           int val = carry;
           if(l1){
               val += l1->val;
               l1 = l1->next;
           }
           if(l2){
               val += l2->val;
               l2 = l2->next;
           }
           carry = val/10;
           val = val%10;
           cur->next = new ListNode(val);
           cur = cur->next;
       }
       if(carry>0){
           cur->next = new ListNode(carry);
           cur = cur->next;
       }
       dummyHead->next = reverse(dummyHead->next);
       return dummyHead->next;
   }
};

使用stack

用两个栈将两个链表的内容存入，然后加法计算后再输出到链表节点。因为栈就是一个先进后出的过程，相当于逆序了。

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        stack<int> stk1;
        stack<int> stk2;
        while(l1){
            stk1.push(l1->val);
            l1 = l1->next;
        }
        while(l2){
            stk2.push(l2->val);
            l2 = l2->next;
        }
        ListNode* dummyHead = new ListNode();
        int carry = 0;
        while(!stk1.empty() || !stk2.empty()){
            int val = carry;
            if(!stk1.empty()){
                val += stk1.top();
                stk1.pop();
            }
            if(!stk2.empty()){
                val += stk2.top();
                stk2.pop();
            }
            carry = val/10;
            val = val%10;
            ListNode* cur = new ListNode(val);
            cur->next = dummyHead->next;
            dummyHead->next = cur;
        }
        if(carry>0){
            ListNode* cur = new ListNode(carry);
            cur->next = dummyHead->next;
            dummyHead->next = cur;
        }
        return dummyHead->next;
    }
};