题目:
我的第一种解法:
企图: 写一个把链表中的值转换成 整型的方法,再写一个把整型转换成链表形式的方法,以此得到结果返回
#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。不夸别人了。