LeetCode No.2 Add Two Numbers

You are given two non-empty linked lists representing two non-negative integers. 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.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Example

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8
Explanation: 342 + 465 = 807.

*******************************************************************************************************

昨天写这题时，最原始的反应是对链表的处理云云，尾插法，头插法建立链表，链表的原地转置等等，写完志得意满，恩，这题很轻松嘛，然而一提交，卡在了 input 9 & 199999999 output 0000000001 这里，然后果断在取数的时候将int型改成long型，心想这次应该没问题了吧，然后继续卡，而且卡在了很奇怪的地方，最终output的数可以说是一堆乱数了，虽然配合自己的main函数输出是没有问题的，但是怎么就oj不了，好吧，你大爷终究是你大爷，题目可能就不想你这么去做，硬来是没有用的，好吧，此处先贴上原始脑残解法的代码，再来说说正常的解法是怎样。

对了，此处加一个小注，在Linux下gcc编译时，对于pow函数无法识别在标准库中，需要在语句后加 -lm 才可以通过编译。

#include<stdio.h>
#include<math.h>
#include<stdlib.h>

typedef struct ListNode
{
	int val;
	struct ListNode *next;
}ListNode;

struct ListNode* addTwoNumbers(ListNode *l1, ListNode *l2);
int GetLength(ListNode *s);
ListNode * CreateList(ListNode *head);
long FetchNum(ListNode *s);
ListNode* Reverse(ListNode *s);
void PrintList(ListNode *head);

int main()
{
	ListNode *l1,*l2;
	ListNode *p,*r,*q, *ans;
	int temp = 0;
	l1 = (ListNode*)malloc(sizeof(ListNode));
	l2 = (ListNode*)malloc(sizeof(ListNode));
	printf("请输入第一组数（以-1结束输入）：\n");
	l1 = CreateList(l1);	
	printf("请输入第二组数，以 -1 结束输入 \n");
	l2 = CreateList(l2);
	ans = addTwoNumbers(l1,l2);
	PrintList(ans);
	return 0;
}

ListNode * CreateList(ListNode *head)
{
	int num;
	ListNode *p,*r = head;
	while(scanf("%d",&num)!=EOF)
	{
		if(num == -1)
		  break;
		p = (ListNode*)malloc(sizeof(ListNode));
		p->val = num;
		r->next = p;
		r = p;
	}
	r->next = NULL;
	return head;	
}

void PrintList(ListNode *head)
{
	ListNode *p;
	p = head->next;
	while(p)
	{
		printf("%d\n",p->val);
		p = p->next;
	}
}



int GetLength(ListNode *s)
{
	int count = 0;
	s = s->next;
	while(s)
	{
		count++;
		s = s->next;
	}
	return count;
}

long FetchNum(ListNode *s)
{
	long length;
	long ans = 0;
	length = GetLength(s);
	s = s->next;
	while(length)
	{
		ans += pow(10.0,length-1)*s->val;
		length--;
		s = s->next;
	}
	return ans;
}

ListNode* Reverse(ListNode *s)
{
	ListNode *head,*p;
	head = (ListNode*)malloc(sizeof(ListNode));
	head->next = NULL;
	if(s==NULL||s->next == NULL)
		return s;
	s = s->next;
	while(s)
	{
		p = s;
		s = s->next;
		p->next = head->next;
		head->next = p;
	}
	return head;
}


ListNode* addTwoNumbers(ListNode *l1, ListNode *l2)
{
	//fetch the num in the list and then put it back to the new list
	long I_sum,I_add1,I_add2;
	long I_value;
	ListNode *head,*p,*r;
	head = (ListNode*)malloc(sizeof(ListNode));
	r = head;
	//l1 = l1->next;
	I_add1 = FetchNum(Reverse(l1));
	I_add2 = FetchNum(Reverse(l2));
	
	I_sum = I_add1 + I_add2;
	
	while(I_sum)
	{	
		I_value = I_sum % 10 ;
                p = (ListNode*)malloc(sizeof(ListNode));
                p->val = I_value;
                r->next = p;
                r = p;
		I_sum = I_sum / 10 ;	
	}
	r->next = NULL;
	return head;
}

好吧 现在来讲常规解法。首先，我上来可能忽视掉了一个重要条件，emmm，也不能说忽视，没有利用好吧，即所有的input数据皆是逆序存放在链表中的。所以也就无所谓考虑对齐不对齐的事情了，直接可以从头部开始加起，即最末尾加起，通过对10取模，再除以十控制进位，两个链表同时依次向下处理，最后将结果用尾插法存入新；链表中即结束。

ListNode* NewAdd(ListNode *l1, ListNode *l2)
{
	ListNode*head,*p,*r;
	int extra = 0;
	head = (ListNode*)malloc(sizeof(ListNode));
	r = head;
	while(l1 || l2 || extra)
	{
		if(l1)
		{
		   extra += l1->val;
		   l1 = l1->next;
		}
		if(l2)
		{
		    extra += l2->val;
		    l2 = l2->next;
		}
		p = (ListNode*)malloc(sizeof(ListNode));
		p->val = extra % 10 ;
		extra = extra/10;
		r->next = p;
		r = p;
	}
	r->next = NULL;
	return head->next;
}