Leetcode：2. 两数相加

题目描述：

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-two-numbers

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

思路分析：

这题是链表相关的题，主要考察的其实就是链表的相关操作。解题思路是很直接，就是对于两个链表同步的去遍历，相加，判断是否有进位。同时需要注意两个待相加链表的长度可能不一致，所以需要多一个判断。最终的停止条件是两个链表都已经遍历到最后。

代码上，我首先用最简单的思路做了一遍，之后还有一个版本是更简化了一点。

代码：

 1 /**
 2  * Definition for singly-linked list.
 3  * struct ListNode {
 4  *     int val;
 5  *     ListNode *next;
 6  *     ListNode(int x) : val(x), next(NULL) {}
 7  * };
 8  */
 9 class Solution {
10 public:
11     ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
12         if(l1 == nullptr || l2 == nullptr)
13             return nullptr;
14         ListNode* head = new ListNode(0);
15         ListNode* res = head;
16         int plusone = 0;
17         while(l1!=nullptr && l2!=nullptr)
18         {
19             int sum = l1->val + l2->val + plusone;
20             plusone = 0;
21             if(sum >= 10)
22             {
23                 plusone = sum/10;
24             }
25             res->next = new ListNode(sum % 10);
26             res = res->next;
27             l1 = l1->next;
28             l2 = l2->next;
29         }
30         while(l1 != nullptr)
31         {
32             int sum = l1->val + plusone;
33             plusone = 0;
34             if(sum >= 10)
35             {
36                 plusone = sum/10;
37             }
38             res->next = new ListNode(sum % 10);
39             res = res->next;
40             l1 = l1->next;
41         }
42          while(l2 != nullptr)
43         {
44             int sum = l2->val + plusone;
45             plusone = 0;
46             if(sum >= 10)
47             {
48                 plusone = sum/10;
49             }
50             res->next = new ListNode(sum % 10);
51             res = res->next;
52             l2 = l2->next;
53         }
54         if(plusone)
55         {
56             res->next = new ListNode(plusone);
57             res = res->next;
58         }
59         return head->next;
60     }
61 };

 1 /**
 2  * Definition for singly-linked list.
 3  * struct ListNode {
 4  *     int val;
 5  *     ListNode *next;
 6  *     ListNode(int x) : val(x), next(NULL) {}
 7  * };
 8  */
 9 class Solution {
10 public:
11     ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
12         if(l1 == nullptr || l2 == nullptr)
13             return nullptr;
14         ListNode* head = new ListNode(0);
15         ListNode* res = head;
16         int plusone = 0;
17         while(l1!=nullptr || l2!=nullptr)
18         {
19             int a = (l1==nullptr ? 0 : l1->val);
20             int b = (l2==nullptr ? 0 : l2->val);
21             int sum = a + b + plusone;
22             plusone = 0;
23             if(sum >= 10)
24             {
25                 plusone = sum/10;
26             }
27             res->next = new ListNode(sum % 10);
28             res = res->next;
29             if(l1!=nullptr)
30                 l1 = l1->next;
31             if(l2!=nullptr)
32                 l2 = l2->next;
33         }
34
35         if(plusone)
36         {
37             res->next = new ListNode(plusone);
38             res = res->next;
39         }
40         return head->next;
41     }
42 };

原文地址：https://www.cnblogs.com/LJ-LJ/p/11105772.html