LeetCode(2) AddTwoNumbers

题目如下:

You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

有两个链表作为输入，它们表示逆序的两个非负数。如下面的两个链表表示的是342和465这两个数。你需要计算它们的和并且用同样的方式逆序输出。如342+465 = 807,你需要把结果表达为7 ->0 ->8
Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)

Output: 7 -> 0 -> 8

我先写了一个解答，基本思路是把链表转化为unsigend long long型数，然后把它们相加，然后把它们的和再表示为链表。然后找高手重新写了一个，模拟加法计算来完成。

解答一 老实巴交地把两个数加起来

//
//  Solution.h
//  LeetCodeOJ_004_AddTwoNumbers
//
//  Created by feliciafay on 11/22/13.
//  Copyright (c) 2013 feliciafay. All rights reserved.
//

#ifndef LeetCodeOJ_004_AddTwoNumbers_Solution_h
#define LeetCodeOJ_004_AddTwoNumbers_Solution_h
#include <iostream>
#include <cmath>

/*
*struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode(int x) : val(x), next(NULL) {}
*};
*/

class Solution {
public:
    ListNode* addTwoNumbers(ListNode *l1, ListNode *l2) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        
        if((l1==NULL)&&(l2==NULL)) {
            return NULL;
        }
        unsigned long long sum1 = 0;
        unsigned long long sum2 = 0;
        unsigned long long sum3 = 0;
        int count1=0;
        int count2=0;
        
        while(l1 != NULL)
        {
            sum1+=pow(10,count1) * (l1->val);
            count1++;
            l1=l1->next;
         }
        
        while(l2 != NULL)
        {
            sum2+=pow(10,count2) * (l2->val);
            count2++;
            l2=l2->next;
        }
        
        sum3 = sum1+sum2;
        
        unsigned long tmp_digit = sum3- (sum3/10)*10;
        ListNode* p = new ListNode((int)tmp_digit);
        ListNode* start = p;
        sum3=sum3/10;
        
        while(sum3>0) {
            tmp_digit = sum3- (sum3/10)*10;
            p->next = new ListNode((int)tmp_digit);
            p = p->next;
            sum3=sum3/10;
        }
        printList(start);
        return start;
    }
    
};

#endif

解答二 进化版思路，模拟加法运算

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

#include <iostream>
#include <cmath>

class Solution {
public:
    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        if((l1==NULL)&&(l2==NULL)) {
            return NULL;
        }
        unsigned long long sum1 = 0;
        unsigned long long sum2 = 0;
        unsigned long long sum3 = 0;
        int count1=0;
        int count2=0;
        
        while(l1 != NULL)
        {
            sum1+=pow(10,count1) * (l1->val);
            count1++;
            l1=l1->next;
         }
        //std::cout<<"sum1:"<<sum1<<std::endl;
        
        while(l2 != NULL)
        {
            sum2+=pow(10,count2) * (l2->val);
            count2++;
            l2=l2->next;
        }
        //std::cout<<"sum2:"<<sum2<<std::endl;
        
        sum3 = sum1+sum2;
        //std::cout<<"sum3:"<<sum3<<std::endl;
        
        unsigned long tmp_digit = sum3- (sum3/10)*10;
        ListNode* p = new ListNode((int)tmp_digit);
        ListNode* start = p;
        sum3=sum3/10;
        
        while(sum3>0) {
            tmp_digit = sum3- (sum3/10)*10;
            p->next = new ListNode((int)tmp_digit);
            p = p->next;
            sum3=sum3/10;
        }
        return start;
        
    }
};

解答三 更加简洁地模拟加法运算

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

#include <iostream>
#include <cmath>

class Solution {
public:
    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        if((l1==NULL)&&(l2==NULL)) {
            return NULL;
        }
        int sum = 0;
        ListNode *root = NULL;
        ListNode *tail = NULL;
        while(l1 != NULL || l2 != NULL) {
            if (l1 != NULL) {
                sum += l1->val;
                l1 = l1->next;
            }
            if (l2 != NULL) {
                sum += l2->val;
                l2 = l2->next;
            }
            ListNode *p = new ListNode(sum % 10);
            if (root == NULL) {
                root = p;
                tail = p;
            } else {
                tail->next = p;
                tail = p;
            }
            sum = sum / 10;
        }
        if (sum != 0) {
            ListNode *p = new ListNode(sum % 10);
            if (root == NULL) {
                root = p;
                tail = p;
            } else {
                tail->next = p;
                tail = p;
            }
        }
        return root;
    }
};

小结:

1 在解法一中，把链表转化为了数，一开始用unsigned long来表示这个数。后来发现自己的电脑(64bit mac)测试没问题，上OJ上提交却出了问题。后来把unsigned long改为了unsigned long long就没有这个问题了。说明之前的问题是因为OJ平台提交的时候，unsigned long这个类型出现了溢出。

short in, int，long int，的宽度都可能由于平台不一样而不一样(16位机器，32位机器，64位机器)。有几条铁定的原则（ANSI/ISO制订的）：
1 sizeof(short int)<=sizeof(int) 
2 sizeof(int)<=sizeof(long int) 
3 short int至少应为16位（2字节） 
4 long int至少应为32位（4字节）

update: 2014-12-10 

1 首先使用了sentinel head，简化代码，避免每次都要判断if (head == NULL)之后再增长链表。

2 然后使用了变量int rest, 表示每一位加法计算之后的进位。

/**
 * 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 * head = new ListNode(-1);
        ListNode * tail = head;
        int rest = 0;
        while (l1 != NULL && l2 != NULL) {
            ListNode* current = new ListNode((l1->val + l2->val + rest) % 10);
            rest = (l1->val + l2->val + rest)/10; //NOTE: 算和的时候还要加上进位rest 
            tail->next = current;
            tail = tail->next;
            l1 = l1->next;
            l2 = l2->next;
        }
        while(l1 != NULL) {
            ListNode* current = new ListNode((l1->val + rest) % 10);
            rest = (l1->val + rest )/10; //NOTE: 算的时候还要加上进位rest
            tail->next = current;
            tail = tail->next;
            l1 = l1->next;
        }
        while(l2 != NULL) {
            ListNode* current = new ListNode((l2->val + rest) % 10);
            rest = (l2->val + rest)/10; //NOTE: 算的时候还要加上进位rest
            tail->next = current;
            tail = tail->next;
            l2 = l2->next;
        }
        if (rest != 0) {
            ListNode* current = new ListNode(rest);
            tail ->next = current;
        }
        return head->next;
    }
};