2. 两数相加

题目

给定两个非空链表来表示两个非负整数。位数按照逆序方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。

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

示例：

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

方法一

思路

两个指针，分别指向两个链表，当一个指针到尾的时候，结束掉
计算结果的时候，用一个变量保存进位，开辟一个新链表保存返回结果

注意点

1. 结束的时候，可能还有进位数据，需要开辟一个结果保存进位数据
2. 计算的时候，注意可能会存在空指针，空指针无法使用next

代码

/**
 * 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) {
        // l1为空
        if (NULL == l1) {
            return l2;
        }
        // l2为空
        else if (NULL == l2) {
            return l1;
        }
        else {
            ListNode* head = NULL;
            ListNode* head_cur = head;
            ListNode* cur1 = l1;
            ListNode* cur2 = l2;
            int num = 0;
            int push_num = 0;
            int plus_num = 0;
            while (cur1->next && cur2->next)
            {
                num = cur1->val + cur2->val + plus_num;
                if (num > 9) {
                    push_num = num % 10;
                    plus_num = num / 10;
                } else {
                    push_num = num;
                    plus_num = 0;
                }
                if (NULL == head) {
                    head = new ListNode(push_num);
                    head_cur = head;
                } else {
                    head_cur->next = new ListNode(push_num);
                    head_cur = head_cur->next;
                }

                cur1 = cur1->next;
                cur2 = cur2->next;
            }
            if (NULL == cur1->next) {
                num = cur1->val + cur2->val + plus_num;
                if (num > 9) {
                    push_num = num % 10;
                    plus_num = num / 10;
                } else {
                    push_num = num;
                    plus_num = 0;
                }
                if (NULL == head) {
                    head = new ListNode(push_num);
                    head_cur = head;
                } else {
                    head_cur->next = new ListNode(push_num);
                    head_cur = head_cur->next;
                }

                cur2 = cur2->next;
                while (cur2)
                {
                    num = cur2->val + plus_num;
                    if (num > 9) {
                        push_num = num % 10;
                        plus_num = num / 10;
                    } else {
                        push_num = num;
                        plus_num = 0;
                    }
                    head_cur->next = new ListNode(push_num);
                    head_cur = head_cur->next;
                    cur2 = cur2->next;
                }
            } else {
                num = cur1->val + cur2->val + plus_num;
                if (num > 9) {
                    push_num = num % 10;
                    plus_num = num / 10;
                } else {
                    push_num = num;
                    plus_num = 0;
                }
                if (NULL == head) {
                    head = new ListNode(push_num);
                    head_cur = head;
                } else {
                    head_cur->next = new ListNode(push_num);
                    head_cur = head_cur->next;
                }
                cur1 = cur1->next;

                while (cur1)
                {
                    num = cur1->val + plus_num;
                    if (num > 9) {
                        push_num = num % 10;
                        plus_num = num / 10;
                    } else {
                        push_num = num;
                        plus_num = 0;
                    }
                    head_cur->next = new ListNode(push_num);
                    head_cur = head_cur->next;
                    cur1 = cur1->next;
                }
            }
            if (plus_num > 0) {
                head_cur->next = new ListNode(plus_num);
            }
            return head;
        }
    }
};

方法二 – 将很多条件合并

思路

区别于方法二，方法二的思路的思路更加清晰，方法一中可能更加优化一些，但是有很多逻辑判断需要注意
方法二中，用x和y分别表示两个链表中需要相加的数据，即使当一个链表已经到结尾的时候，还是给这个链表加数据，只不过加的数据是0，这样子在逻辑控制上面更加简单轻松

代码

/**
 * 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) {
        ListNode* p1 = l1;
        ListNode* p2 = l2;
        ListNode* head = new ListNode(0);
        ListNode* cur = head;
        int num, push_num, plus_num = 0;
        int x = 0;
        int y = 0;
        while ( p1 || p2) 
        {
            if (!p1) {
                x = 0;
            } else {
                x = p1->val;
            }
            if (!p2) {
                y = 0;
            } else {
                y = p2->val;
            }
            num = x + y + plus_num;
            push_num = num % 10;
            plus_num = num / 10;
            cur->next = new ListNode(push_num);
            cur = cur->next;
            if (p1) {
                p1 = p1->next;
            }
            if (p2) {
                p2 = p2->next;
            }

        }
        if (plus_num > 0) {
            cur->next = new ListNode(plus_num);
        }
        return head->next;
    }
};