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

由于正好是逆序将数位保存在链表的节点里，所以将两个链表对应节点的值相加，并用一个整型变量保存每次的进位，直到两个链表都遍历完并且进位为0的时候，退出循环。思路比较清晰，很快40分钟内便AC了这道题目。

方法一：（又创建了一条新的链表并返回）

RunTime：16ms

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
	int c;
	struct ListNode *s = NULL,*temp = NULL;

	struct ListNode *head = malloc(sizeof(struct ListNode*));
	c = (l1->val + l2->val) / 10;
	head->val = (l1->val + l2->val) % 10;
	head->next = NULL;
	l1 = l1->next;
	l2 = l2->next;
	s = head;
	
	while(c || l1 || l2)
	{
		if(l1 && l2)
		{
			temp = malloc(sizeof(struct ListNode*));
			temp->val = (l1->val + l2->val +c) % 10;
			c = (l1->val + l2->val +c) / 10;
			temp->next = NULL;
			l1 = l1->next;
			l2 = l2->next;
		}
		else if(l1 && !l2)
		{

			temp = malloc(sizeof(struct ListNode*));
			temp->val = (l1->val +c) % 10;
			c = (l1->val + c) / 10;
			temp->next = NULL;
			l1 = l1->next;
		}
		else if(!l1 && l2)
		{

			temp = malloc(sizeof(struct ListNode*));
			temp->val = (l2->val +c) % 10;
			c = (l2->val + c) / 10;
			temp->next = NULL;
			l2 = l2->next;
		}
		else
		{
			temp = malloc(sizeof(struct ListNode*));
			temp->val = 1;
			c = 0;
			temp->next = NULL;
		}
		s->next = temp;
		s = temp;
	}
	return head;
}

看了一下结果，发现这种方法并不是最快的解法，遂开始思考这个问题。先想的是是不是由于每次都要判断链表为指针是否为空，所以导致速度变慢。如果一开始求出两个链表的长度，就不用每次都判断了，是不是会快一点？但转念一想，求链表的长度同样也是一个遍历链表并且每次循环都要判断的过程，实质上是一样的。遂放弃了这个想法。后来翻了翻以前的数据结构的书，才发现了问题所在。原来这道题实质上和归并链表很像，而归并链表时，如果不要求保留初始的两个链表，是可以直接在初始链表的基础上挂接的，即不需要创建新的链表。而这题也是一样的，完全可以在l1和l2上直接保存和的值，而最多只用创建一个新的节点即可（即最高位的进位为1时）。

方法二：（采用归并链表的思想，不创建新的链表）

RunTime：12ms

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2)
{
	struct ListNode *l3,*tail;
	l3 = l1;
	int c = 0,tem;
	while( l1 && l2 )
	{
		tem = c;
		c = (l1->val + l2->val + tem) / 10;
		l1->val = (l1->val + l2->val + tem) % 10;
		tail = l1;
		l1 = l1->next;
		l2 = l2->next;
	}
	if( l1 && !l2 )
		while( l1 )
		{
			tem = c;
			c = ( l1->val + tem ) / 10;
			l1->val = ( l1->val + tem ) % 10;
			tail = l1;
			l1 = l1->next;
		}
	else if( !l1 && l2 )
	{
		tail->next = l2;
		while( l2 )
		{
			tem = c;
			c = ( l2->val +tem ) / 10;
			l2->val = ( l2->val + tem ) % 10;
			tail = l2;
			l2 = l2->next;
		}
	}
	if( c )
	{
		tail->next = (struct ListNode*)malloc(sizeof(struct ListNode));
		tail = tail->next;
		tail->val = 1;
		tail->next = NULL;
	}
	else
		tail->next = NULL;

	return l3;

}

小结：

1.以先进先出方式创建链表时，要先单独创建一个头节点，再循环创建后续节点，头指针始终指向头节点，尾指针始终指向当前的尾节点。

2.归并链表时如果不要求保留初始链表，可直接重新组织初始两个链表的节点，而不必创建新的节点或链表。