两数相加（链表的简单应用）

两数相加

题目描述：

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

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

样例：

输入：

​ L1=2->4->3

​ L2=5->6->4

输出：

​ 7->0->8

解释：

​ 342+465=807

自己想的解法

​ 因为函数的输入是以链表的形式，因此根据题目给的描述是要使用尾插法来新建链表。首先先遍历链表，利用尾结点是否为空和while循环，将链表中的结点值取出来，并构建为一个整数。进行简单的相加运算，然后再逐个取出相加的结果，利用尾插法重建链表。由于leetcode里面的测试函数是要把头结点也要输出来，为了避免这个错误，因此需要将链表的头结点删掉。输出的结果对大部分样例都满足要求，但是当数据长度过大，则容易数值溢出。话不多说，上代码和截图。

listLink addTwoNumbers(listLink l1, listLink l2)
{
        long int num1, num2, sum;
        int i = 0;
        int j = 0;
        vector<int>num;
        num1 = 0;
        num2 = 0;

        ListNode* numList = new ListNode();
        //不能跳过头结点
        ListNode* listtemp1 = l1;

        //将链表中的数值取出来，注意取出来的顺序
        while (listtemp1)
        {

            num1 = num1 + listtemp1->val * pow(10, i);
            listtemp1 = listtemp1->next;
            i++;
        }
        cout << num1 << endl;

        ListNode* listtemp2 = l2;
        while (listtemp2)
        {
            num2 = num2 + listtemp2->val * pow(10, j);
            listtemp2 = listtemp2->next;
            j++;
        }
        cout << num2 << endl;
        sum = num2 + num1;

        ListNode* listtemp;
        ListNode* listtempR;
        listtempR = numList;

        if (sum == 0)
        {
            listtemp = new ListNode;
            listtemp->val = sum % 10;
            listtemp->next = nullptr;
            listtempR->next = listtemp;
            listtempR = listtempR->next;
        }
        while (sum)
        {
            listtemp = new ListNode;
            listtemp->val = sum % 10;
            listtemp->next = nullptr;
            listtempR->next = listtemp;
            listtempR = listtempR->next;
            sum = sum / 10;
        }
        
        //删除头结点
        ListNode* listdelete;
        listdelete=numList;
        numList=listdelete->next;
        delete listdelete;
        
        return numList;
    
}

由上面的测试用例，就能很明确的发现，当输入的字符太长，则最后的执行容易出错。哪怕设置类型为long int 也不行。那么参考一下别人的代码是怎么写的呢。

Leetcode 他人的解法

补全链表相加计算

看了他人的解法才想到自己的思想出现了偏差。首先输入的链表是逆序存储的，完全可以比对链表中的单个结点位置进行相加。面对长度不一的链表，则是将其补全成两个链表相同的长度。在这个这个算法中，最最巧妙的是添加了进位这个变量。每次计算的时候都加上进位，类似数学方法的求解。并且每次循环都不断更新。看了本题，才知道链表的妙用，实在是太有意思了。自己想了半天，再回头看原来是如此简单。

listLink addTwoNumbers2(listLink l1, listLink l2)
{
    ListNode* head = nullptr;
    ListNode* point = nullptr;
    int carry = 0;//设置每次链表相加的时候的进位

    //判断l1或l2是否到末尾，即循环到最长链表的结束
    while (l1 || l2)
    {   //如果l1中存在值，则将值赋给num1，否则则赋以0
        //相当于将l1和l2的长度补为同长度
        int num1 = l1 ? l1->val : 0;
        int num2 = l2 ? l2->val : 0;

        //当前结点的加法获得的值,并且加入上一轮的进位值
        int sum = num1 + num2 + carry;

        //判断头结点是否要存在
        if (!head)
        {
            //使point指向head
            head = new ListNode(sum % 10);
            point = head;
        }
        else
        {
            point->next = new ListNode(sum % 10);
            point = point->next;
        }

        //更新进位的值
        carry = sum / 10;

        //逐步移动l1和l2的当前结点
        if (l1)
        {
            l1 = l1->next;
        }
        if (l2)
        {
            l2 = l2->next;
        }
    }

    //判断是否还有多余的进位
    if (carry > 0)
    {
        point->next = new ListNode(carry);
    }
    return head;
}

不补全直接计算

另一种方法代码没有上一种简洁，但是执行效率更高。其采用的是不补全两个链表的长度。主要是根据链表是否为空，来进行移动和求和，基本的思路与上一题相似。

//不考虑将字符串补全
listLink addTwoNumbers3(listLink l1, listLink l2)
{
    ListNode* head = new ListNode();
    ListNode* point = head;//point 指向链表head

    //保存每位相加的和值,进位的标记位
    int sum = 0;
    int carry = 0;
    while (l1 || l2)
    {
        sum = 0;
        //当l1存在时
        if (l1)
        {
            sum += l1->val;
            l1 = l1->next;
        }
        //当l2存在时
        if (l2)
        {
            sum += l2->val;
            l2 = l2->next;
        }
        //如果进位存在，sum也得继续加1
        if (carry)
        {
            sum++;
        }
        //将sum的个位数作为值添加到当前链表的下一个结点中
        point->next = new ListNode(sum % 10);
        point = point->next;
        carry = sum / 10;
    }
    if (carry)
    {
        point->next = new ListNode(carry);
    }
    //因为head 之前被构造的时候存在头结点为0,所以本次返回要返回头结点的下一个结点
    //这也是一种妙处，可以避免删除头结点
    return head->next;
}

总结

leetcode真好玩，比打游戏有意思多了。刷题让我忘记时间，就跟做数学题一样。我是小菜鸡，我要慢慢开始学。