Leetcode的链表两数相加

关于Leetcode链表两数相加的问题

做到这一道题，想到了前一道题的递归想法，先转载下leetcode的题解
 [leetcode题目链接](https://leetcode-cn.com/problems/add-two-numbers-ii/)

	 void addLinkList(struct ListNode* l1, struct ListNode* l2,int *cout)
{       
        if(l1==NULL||l2==NULL)
            return;
        if(l1->next!=NULL&&l2->next!=NULL)
            addLinkList(l1->next,l2->next,cout);
        int Sum=l1->val+l2->val+*cout;
        if(Sum>=10)
        {
            *cout=1;
            l1->val=Sum%10;
        }
        else
        {
            *cout=0;
            l1->val=Sum;
        }
        return;
}

该解法转载自leetcode的评论题解

感觉这个回溯这个方法真的好奇妙,之前没注意到那个cout,
我一直很好奇是怎么传值回来的，刚刚仔细看到那边采用的是指针的，所以那个cout值在下一次调用自己的时候，里面的cout的值是会传回来的，这边解释节没毛病了，可是我在想一个问题，我们对于一个递归的问题，我们应该如何去解决，在leetcode的刷题过程中，发现了许多的leetcode递归算法的奇妙，可是还是不知道该怎么理解。
首先吧，拆分递归这个小东西吗？递归是自己调用自己，所以拆分的时候，拆分出来是一个个的函数：
比如：

 int f(n){
 	if(n==0||n==1){
 	return n;
 	return f(n-1)+f(n-2);
 }

这个问题留着后面再解决一下，这里面的拆分关系有点不太适用，小白先溜了，以后回来补这个坑，现在还是不太明白

单纯当成一个笔记

先把链表长度补整齐，然后用递归算法。

递归函数：

void addLinkList(struct ListNode* l1, struct ListNode* l2,int *cout)
{       
        if(l1==NULL||l2==NULL)
            return;
        if(l1->next!=NULL&&l2->next!=NULL)
            addLinkList(l1->next,l2->next,cout);
        int Sum=l1->val+l2->val+*cout;
        if(Sum>=10)
        {
            *cout=1;
            l1->val=Sum%10;
        }
        else
        {
            *cout=0;
            l1->val=Sum;
        }
        return;
}

然后再补上非递归的算法，也就是使用栈

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        stack<int> a;
        stack<int> b;
        ListNode * p =l1;
        while(p){
            a.push(p->val);
            p=p->next;
        }
        p =l2;
        while(p){
            b.push(p->val);
            p=p->next;
        }
        ListNode * dummy=new ListNode(0);
        p =dummy;
        int sum;
        int cout=0;
        while(!a.empty()&&!b.empty()){
            sum=a.top()+b.top()+cout;
            a.pop();
            b.pop();
            if(sum>=10){
                sum%=10;
                cout=1;
            }else{
                cout=0;
            }
            ListNode * temp =new ListNode();
            temp->val = sum;
            temp->next = p->next;
            p->next =temp;
        }
        while(!a.empty()){
            sum = a.top()+cout;
            if(sum>=10){
                sum%=10;
                cout=1;
            }else{
                cout=0;
            }
            ListNode * temp =new ListNode();
            temp->val = sum;
            a.pop();
            temp->next = p->next;
            p->next =temp;
        }
        while(!b.empty()){
            sum = b.top()+cout;
            if(sum>=10){
                sum%=10;
                cout=1;
            }else{
                cout=0;
            }
            ListNode * temp =new ListNode();
            temp->val = sum;
            b.pop();
            temp->next = p->next;
            p->next =temp;
        }
        if(cout==1){
            ListNode * temp =new ListNode();
            temp->val = cout;
            temp->next = p->next;
            p->next =temp;
        }
        return p->next;
    }
};

先记录一下，这边为啥使用栈，因为我们每次将链表的每个值相加的时候，可能会产生进位，然后这个进位的话，如果是从低位开始往高位运算的话，只需要高位加上1就可以了，但是链表的访问顺序在这边是从前面到后面的，所以我们将每一个值直接扔进去栈里面，再出来，整个读取的顺序就没啥问题，就转化成为了低位到高位。

这边是是自己的想法，希望不要被这边耽误住了，现在其实我还没办法理清楚递归的思想，哈哈哈哈，多做点题，然后把这一块的思想慢慢地补上

然后第一种的递归思想，就是去补全了两个链表，让链表的节点数相同，也就是让他们每次的位数是一样的，然后递归其实在这边是从高位开始进行计算的，所以导致的一个状况就是，比如我们现在是n个结点，然后对第一个结点进行相加的时候，是需要考虑到后面的n-1个结点相加的进位的，然后第二个结点是需要考虑到后面n-2结点的进位的，所以我在第一个结点的时候，就直接去判断后面有没有结点，如果有结点，直接去算后面第一个结点的进位，所以先跑到后面的第一个结点，然后跑到这边的时候，发现后面还有结点，所以我得再判断后面那个结点相加是不是会产生进位，然后这样子走下去，就会走到我们的最后一个结点，最后一个结点判断出来有没有进位之后，会将哪一个进位的值往前面传，这边利用的是指针进行传值，最后一个结点处理好了，我们就直接继续往前面回退了，回到倒数第二个，将我们得到的进位和自己本身进行相加，判断是否产生进位，如果是产生了进位，那我们就继续地往上一位进行进位的传递，也就是继续改变cout的值，并且回退到上面那一个结点。