再从萌新开始-Leetcode每日题解-445. Add Two Numbers II

445. Add Two Numbers II（Medium）

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

------------------------------------分割线-------------------------------------------------

终于拿了一道Medium，不过也算是比较简单的题目了。

题目给两个非空链表分别代表两个整数，每个结点只储存一位10进制数字，链表头代表整数的高位。要求做加法，并且不改变输入的内容（比如说做recverse）。简单来说就是让你用链表做一个高精度的加法…

分析：

我觉得最直接的做法就是遍历链表，转成数组/字符串储存，直接套一个高精度的模板，复杂度O(n)应该可以水过去。笔主虽然很懒惰但是也不想这样敷衍了第一道拿起的medium…决定就直接用链表来做就行了。

我的思路是分成三部分来进行：因为链表头代表是的数字的高位，要想做对位的加法，那就要把链表的长度和长度差计算出来，用第一次遍历来做这个事情；第二次遍历就进行计算了，由于是从高位开始的计算，进位不好处理（自行想象手动做大数加法的过程，一般都是从低位做起，才好处理进位），就仅仅做计算而不进位。第三次遍历再处理进位的问题，分成几种情况：

1.无进位；

2当前位大于10，往前进位；（简单处理，前面一位收到这个进位的1是否会进位在另外一种情况）

3.当前位为9，往后遍历，直到确定是否会有进位发生。（举个例子来说明，比如说是9->9->9->12这种情况，当读取到第一个9的时候，就一直往后遍历，直到到12这个位置，才确定有进位发生，回来发生进位，并且对中间的9也做进位操作；如果是9->9->9->1，那遍历到1发现没有进位，那这些9就都是“安全”的，都不进位；具体的实现还是可以看代码和细节讲解部分，我尽量写一写注释）。

细节部分：

1.在最前面留一个空的位置（0），来防止最高位需要进位。返回的时候，如果这个位置为1就返回，如果为0就返回下一位。相当于给结果预先加了一个前导0来防止最高位的进位，返回时在判断去掉前导0。

2.在处理进位时，遇到9的时候操作比较麻烦，需要往后遍历好几位，但是这些操作不是无用的，遍历过的位置在最终都可以确定是否需要进位而直接处理（相当于做了一个预处理），代码中我使用carry来记录最终是否进位，如果进位，那中间的9都可以改成0，如果不进位，这些9也不用再去处理，直接标成不进位就行了。用accum来记录预处理的数字位数。

代码：

class Solution{
    public:
        ListNode* addTwoNumbers(ListNode* l1, ListNode* l2){
            int count1 = 0, count2 = 0;
            ListNode* tmp1 = l1, *tmp2 = l2;
            
            //第一次遍历，确定长度
            while (1){
                if (!tmp1 && !tmp2) break;
            
                if (!tmp1){
                    count2++;
                    tmp2 = tmp2->next;
                }else if(!tmp2){
                    count1++;
                    tmp1 = tmp1->next;
                }else{
                    count1++;
                    count2++;
                    tmp1 = tmp1->next;
                    tmp2 = tmp2->next;
                }
            }
            bool flag = count1>=count2?1:0;
            int dif = abs(count1-count2); //长度差
            
            //第二次遍历，做加法计算（不处理进位）
            int num = 0;
            ListNode* ans = new ListNode(0);
            ListNode* p = ans;
            while (dif){
                if (flag){
                    num = l1->val;
                    l1 = l1 ->next;
                }else {
                    num = l2->val;
                    l2 = l2 -> next;
                }
                dif--;
                ListNode* tmp = new ListNode(num); 
                p->next = tmp;
                p = p->next;
            }
            while (l1){
                num = l1->val + l2->val;
                ListNode* tmp = new ListNode(num);
                p->next = tmp;
                p = p->next;
                l1 = l1 -> next;
                l2 = l2 -> next;
            }
            
            //第三次遍历，处理进位
            ListNode* pre = ans;
            p = ans -> next;
            int accum = 0;
            bool carry = 0;
            while (p){
                if (accum){
                    if (carry) p->val = max(0,p->val-10);
                    accum--;
                    pre = p;
                    p = p->next;
                    continue;
                }
               if (p->val >= 10){
                   pre->val++;
                   p->val -= 10;
               }else if(p->val == 9){
                   accum = 0;
                   carry = 0;
                   ListNode* tmp = p -> next;
                   while (1){
                       if (!tmp || tmp->val < 9) break;
                       else if (tmp->val == 9){
                           accum++;
                           tmp = tmp->next;
                       }else{
                           carry = 1;
                           accum++;
                           break;
                       }
                   }
                   if (carry){
                       pre->val++;
                       p->val = 0;
                   } 
               }
               pre = p;
               p = p->next;
           }
           if (ans->val) return ans;
           else return ans->next;
       }
};

---------------------------------分割线----------------------------------------

这部分是其他人的题解，晚点再看。