2. Add Two Numbers
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.
Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8
题目的意思是将两个非负数放到两个链表list1和list2，链表的存储方式是高位在右低位在左（类似小端模式存储，这样的效果是往右边进位），而且每个节点都只能饿保存一位数。然后需要设计一个算法将两个非负数相加，将结果以之前规则的链表形式返回。题目很直接，没有啥让人疑惑的地方，下面开始第一次尝试：
为了减少内存的分配次数，最开始的想法是先求出两个链表的长度，使用长的来保存计算出来的结果，如果最后有进位的话只需要重新分配一个节点的内存。代码如下：
1 struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) { 2 struct ListNode *head, *p, *res = l1; 3 struct ListNode *q, *tmp = l2; 4 5 int l1Length = 0; 6 int l2Length = 0; 7 p = l1; 8 q = l2; 9 while(1) 10 { 11 if(l1) 12 { 13 l1 = l1->next; 14 l1Length++; 15 } 16 if(l2) 17 { 18 l2 = l2->next; 19 l2Length++; 20 } 21 if(!(l1 || l2)) 22 break; 23 if( !(l1Length == l2Length)) 24 break; 25 } 26 if(l2Length > l1Length) 27 { 28 res = q; 29 tmp = p; 30 } 31 32 head = res; 33 34 int carry = 0; 35 p = res; 36 while(1) 37 { 38 if(tmp) 39 { 40 res->val += tmp->val + carry; 41 carry = res->val / 10; 42 res->val = res->val % 10; 43 44 p = res; 45 res = res->next; 46 tmp = tmp->next; 47 } 48 else 49 { 50 if(res) 51 { 52 res->val += carry; 53 carry = res->val / 10; 54 res->val = res->val % 10; 55 p = res; 56 res = res->next; 57 } 58 else if(carry) 59 { 60 struct ListNode *cur = (struct ListNode*)malloc(sizeof(struct ListNode)); 61 cur->val = carry; 62 cur->next = NULL; 63 p->next = cur; 64 return head; 65 } 66 else 67 return head; 68 } 69 } 70 return NULL; 71 }
代码中用res指针来指向长的那个链表，作为保存结果的链表，用carry来记录是否进位，运行的结果是：
Runtime: 20 ms 这个与最快的16ms还有差距的，于是开始了第二次尝试
第二次尝试的方向删除比较两个链表长度的部分，因为两个链表节点都是相同类型，所以我们可以任意拼接。 代码如下：
1 struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) { 2 struct ListNode head, *p; 3 p = &head; 4 5 int carry = 0; 6 7 while(1) 8 { 9 if(l1 && l2) 10 { 11 l1->val += (l2->val + carry); 12 carry = l1->val / 10; 13 l1->val = l1->val % 10; 14 15 p->next = l1; 16 p = l1; 17 18 l1 = l1->next; 19 l2 = l2->next; 20 } 21 else if(l1) 22 { 23 l1->val += carry; 24 carry = l1->val / 10; 25 l1->val = l1->val % 10; 26 27 p->next = l1; 28 p = l1; 29 30 l1 = l1->next; 31 } 32 else if(l2) 33 { 34 l2->val += carry; 35 carry = l2->val / 10; 36 l2->val = l2->val % 10; 37 38 p->next = l2; 39 p = l2; 40 41 l2 = l2->next; 42 } 43 else if(carry) 44 { 45 struct ListNode *cur = (struct ListNode*)malloc(sizeof(struct ListNode)); 46 cur->val = 1; 47 cur->next = NULL; 48 p->next = cur; 49 return head.next; 50 } 51 else 52 return head.next; 53 } 54 return NULL; 55 }
需要注意的是因为我们并不知道哪一个该作为保存结果的list，为了保证wihle循环里的一致性，这个地方的我们先定义一个ListNode的实例head，然后定义一个指向head的指针p，这样while循环里每次得到一个节点都放到p节点后面，然后将该节点的地址赋值给p就行了，使用p来记录result链表的走向，最后返回的head.next就能返回正确结果，运行的结果是：
Runtime: 20 ms 速度竟然没有任何改变！！！ 看来比较两个链表长度的操作并没有怎麽耗时，好吧，只能再从别的角度突破了
第三次的尝试方向是再次是否还能继续较少内存，因为list2链表里的内存是等着释放的，所以完全可以使用来存储进位，也就是最后将list1和list2合并成了一个链表，用list2的头结点来保存进位，这样完全可以不用分配内存。代码如下
1 struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) { 2 struct ListNode head, *p, *end; 3 p = &head; 4 end = NULL; 5 6 int carry = 0; 7 8 while(1) 9 { 10 if(l1 && l2) 11 { 12 l1->val += (l2->val + carry); 13 carry = l1->val / 10; 14 l1->val = l1->val % 10; 15 16 p->next = l1; 17 p = p->next; 18 l1 = l1->next; 19 !end && (end = l2); 20 l2 = l2->next; 21 } 22 else if(l1) 23 { 24 l1->val += carry; 25 carry = l1->val / 10; 26 l1->val = l1->val % 10; 27 28 p->next = l1; 29 p = p->next; 30 l1 = l1->next; 31 } 32 else if(l2) 33 { 34 l2->val += carry; 35 carry = l2->val / 10; 36 l2->val = l2->val % 10; 37 38 p->next = l2; 39 p = l2; 40 41 l2 = l2->next; 42 } 43 else if(carry) 44 { 45 if( !end ) 46 { 47 end = (struct ListNode*)malloc(sizeof(struct ListNode)); 48 } 49 end->val = 1; 50 end->next = NULL; 51 p->next = end; 52 return head.next; 53 } 54 else 55 return head.next; 56 } 57 return NULL; 58 }
代码中定义了一个指向end的指针，在代码19行将链表2的头结点地址赋值给了end，48~51行表示如果有进位，那麽使用end所指向的list2头结点来保存进位，并加在result结点后面，这样不用分配内存了，运行结果是：
Runtime: 16 ms 终于达到了最快的速度 ！！！有图有真相，You are here !