LeetCode - 2 - 两数相加 （C++）

题目

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

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

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

示例：

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

第一次

第一次想用栈读出两链表的数字，然后加和在存入链表，但是产生了错误，做加法时数字过大。。。

/**
 * 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 add1;
        stack add2;
        stack add;
        int num1 = 0,num2 = 0;
        ListNode* p;
        p = l1;
        while(p != NULL){
            add1.push(p->val);
            p = p->next;
        }     
        p = l2;
        while(p != NULL){
            add2.push(p->val);
            p = p->next;
        }
        while(add1.size() != 0){
            num1 *= 10;
            num1 += add1.top();
            add1.pop();
        }
        while(add2.size() != 0){
            num2 *= 10;
            num2 += add2.top();
            add2.pop();
        }
        int num = num1 + num2;
        while(num != 0){
            add.push(num%10);
            num = num/10;
        }
        p = NULL;
        while(add.size() != 0){
            ListNode* n;
            n = (ListNode*)malloc(sizeof(ListNode));
            n->val = add.top();
            add.pop();
            n->next = p;
            p = n;
        }
        return p; 
    }
};

第二次

第二次直接跟踪两个链表，将结点值得和加上进位标志存入返回链表的结点，如果结果大于9，则加一个进位标志，最后将剩余较长的链表存入，最后将进位符存入。
但是结果还是很垃圾…

/**
 * 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* r = new ListNode(0); //返回链表
        ListNode* p = r; //跟踪结点
        int temp;
        int flag = 0;  //进位标志
        while((l1 != NULL) && (l2 != NULL)){
            temp = l1->val + l2->val + flag;
            if(temp >= 10){
                temp -= 10;
                flag = 1;
            }else
                flag = 0;
            ListNode* n = new ListNode(temp);
            p->next = n;
            p = n;
            l1 = l1->next;
            l2 = l2->next; 
        }
        while(l1 != NULL){
            temp = l1->val + flag;
            if(temp >= 10){
                temp -= 10;
                flag = 1;
            }else
                flag = 0;
            ListNode* n = new ListNode(temp);
            p->next = n;
            p = n;
            l1 = l1->next;
        }
        while(l2 != NULL){
            temp = l2->val + flag;
            if(temp >= 10){
                temp -= 10;
                flag = 1;
            }else
                flag = 0;
            ListNode* n = new ListNode(temp);
            p->next = n;
            p = n;
            l2 = l2->next;
        }
        if(flag != 0){
            ListNode* n = new ListNode(1);
            p->next = n;
        }
        return r->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) {
        ListNode* l3 = new ListNode(-1);
		ListNode* hl3 = l3;
		int c = 0, end1 = 0, end2 = 0;
		while (end1 == 0 || end2 == 0 || c == 1)
		{
			l3->val = (l1->val + l2->val + c) % 10;
			c = (l1->val + l2->val + c) / 10;
			if (l1->next == NULL) l1->val = 0,end1=1; else l1 = l1->next;
			if (l2->next == NULL) l2->val = 0,end2=1; else l2 = l2->next;
			if (end1 == 0 || end2 == 0 || c == 1)
			{ 
				l3->next = new ListNode(-1);
				l3 = l3->next;
			}
		}
		return hl3;
    }
};