leetcode 第二题 两数求和

题目：

 

 

我的第一种解法：

企图： 写一个把链表中的值转换成 整型的方法，再写一个把整型转换成链表形式的方法，以此得到结果返回

#include<iostream>
using namespace std;
struct ListNode {
     int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        if(l1 == nullptr || l2 == nullptr)
        	return nullptr;
        long num1 = getNum(l1);
        long num2 = getNum(l2);
        long sum = num1 + num2;
        return getList(sum);
    }
    long getNum(ListNode* l){
    	long sum = 0;
    	long i = 1;
    	while(l != nullptr){
    		sum = sum + (l->val)*i;
    		i = i*10;
    		l = l->next;
    	}
    	return sum;
    }
    ListNode* getList(int sum){
    	int value;
    	ListNode* p = new ListNode(sum %10);
    	ListNode* head = p;
    	sum = sum / 10;
    	while(sum){
    		ListNode* node = new ListNode(sum% 10);
    		sum = sum /10;
    		p->next = node;
    		p = p->next;
    	}
    	return head;
    }
};

BUT，失败了啊，为什么，让我们来看看为什么：

一开始，如果用int存东西，那么当链表一长就放不下了，改成long型也是不够用的，且，内部的方法里有一个i，它用来控制累加的值是在什么位上的（十百千万位。。。），这个i也有其上限，不好。

 

失败了嘛，那就换一种方法继续搞。

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        if(l1 == nullptr || l2 == nullptr)
        	return nullptr;
        ListNode* head = l1;
        int jin =0;
        ListNode* l1_q = l1;
        int value = (l1->val + l2->val + jin) % 10;
        jin = (l1->val + l2->val + jin) / 10;
        l1->val = value;
        l1 = l1->next;
        l2 = l2->next;
        while(l1 != nullptr && l2!= nullptr){
            int value = (l1->val + l2->val + jin) % 10;
            jin = (l1->val + l2->val + jin) / 10;
            l1->val = value;
            l1 = l1->next;
            l2 = l2->next;
            l1_q = l1_q->next;
        }
        
        if(l1 != nullptr){  
            while(l1!=nullptr){
                int value = (l1->val + jin) %10;
                jin = (l1->val + jin) /10;
                l1->val = value;
                l1 = l1 ->next;
                l1_q = l1_q->next;
                if(jin == 0)
                    break;
            }
        }
        if(l2 != nullptr){
            l1_q->next = l2;
            while(l2!= nullptr){
                int value = (l2->val + jin) % 10;
                jin = (l2->val + jin) / 10;
                l2->val = value;
                l2 = l2->next;
                l1_q = l1_q->next;
                if(jin == 0)
                    break;
            }
        }
        if(l1 == nullptr && l2 == nullptr && jin ==1){
            ListNode* newNode = new ListNode(jin);
            l1_q->next = newNode;
        }
        return head;
    }
};

·上面方法的时间复杂度 O（MAX（M，N）） 空间复杂度O（1）（复用l1 l2链表的节点）

这个方法的思想是：

两个指针同时指着遍历，分别讨论两个链表长度同样长，l1链表比l2长，l2链表比l1长的情况。

同时，注意好进位项。

 

我犯的错误：对于进位项，我有了一个失误：

eg：循环中，对于v1  . v2 值 和进位项 jin， 本应该先求得 (v1 + v2 + jin) % 10  的答案 ，先存起来，然后在用

(v1 + v2 + jin) / 10 得到新的进位项的，

但是我怎么做了呢 ？

v 1 = (v1 + v2 + jin) % 10

jin = (v1 + v2 + jin) / 10

此时由于V1已经被修正了， 所以我就sb了。。。。。。。。。。。不甘心～～～～～～～～

 

 

补一个时间复杂度，空间复杂度都是O（N）的方法，  这歌看起来简单一些

#include<iostream>
using namespace std;
struct ListNode {
     int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        if(l1 == nullptr || l2 == nullptr)
        	return nullptr;
        ListNode* dummies = new ListNode(0);
        ListNode* p = l1;
        ListNode* q = l2;
        ListNode* current = dummies;
        int jin = 0;
        while(p!= nullptr || q != nullptr){
            int v1 = (p != nullptr)? p->val : 0;
            int v2 = (q != nullptr)? q->val : 0;
            int sum = v1 + v2 + jin;
            current->next = new ListNode(sum%10);
            jin = sum/10;
            if(p != nullptr)
                p = p->next;
            if(q != nullptr)
                q = q->next;
            current = current->next;
        }
        if(jin != 0){
            current->next = new ListNode(jin);
        }
        return dummies->next;
    }
};

思想：有一个不作为输出的头节点，在这头节点之后串上一个个新的节点，最后输出头节点后一个节点的指针。

生成新节点的方法还以一样的，就不说了。看看结构就好。

 

结构：简洁，思维清晰，学习榜样！！！！！ok。不夸别人了。