这道题逻辑不难,但是对于指针和链表都搞不定的我感觉要死了.....
先说几件事,int *p=&i,这个意思就是p指向i了,p存的是i的地址,int *p; p=&i;这个和前面的意思一样.....
链表的操作,恩不说了随便找套路都一样,这道题用了在尾结点后插入,套路就是现定义一个头结点,然后定义一个指向头结点的指针,之后的操作用这个指针,返回的时候返回头结点相关的。
但遇到了一个不懂的问题,ListNode y(temp%10);p->next=&y就不对,但是用p->next=new ListNode(temp%10)就对,不理解.....求好心人指导.....
理解了!这样子的,如果是直接定义不new,如果脱离作用于,这个内存就被释放了,这里面每进一次while,都会被自动释放一次,所以最后没报错,但是返回空。但是如果你用new的话,就不会被释放,所以就可以存下来了。tips:new是在堆上,可以自己分配释放,直接定义是在栈上,无法自己分配,而且超了作用域,就被自动释放了。
最慢的:
/**
* 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(0);
ListNode *p=&Head;
int temp=0;
int carry=0;
while(l1!=NULL||l2!=NULL)
{
if(l1==NULL)
{
temp=l2->val+carry;
l2=l2->next;
}
else if(l2==NULL)
{
temp=l1->val+carry;
l1=l1->next;
}
else
{
temp=l1->val+l2->val+carry;
l1=l1->next;
l2=l2->next;
}
carry=temp/10;
p->next=new ListNode(temp%10);
p=p->next;
}
if(carry!=0)
{
p->next=new ListNode(carry);
p=p->next;
}
return Head.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 Head(0);
ListNode *p=&Head;
int temp=0;
int carry=0;
while(l1!=NULL||l2!=NULL||carry!=0)
{
temp=(l1?l1->val:0)+(l2?l2->val:0)+carry;
l1=l1?l1->next:NULL;
l2=l2?l2->next:NULL;
carry=temp/10;
p->next=new ListNode(temp%10);
p=p->next;
}
return Head.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 Head(0);
ListNode *p=&Head;
int temp=0;
int carry=0;
while(l1||l2||carry)
{
temp=(l1?l1->val:0)+(l2?l2->val:0)+carry;
l1=l1?l1->next:NULL;
l2=l2?l2->next:NULL;
carry=temp/10;
p->next=new ListNode(temp%10);
p=p->next;
}
return Head.next;
}
};