Chapter 2 | Linked Lists--实现两个单链表数据的和

2.4     You have two numbers represented by a linked list, where each node contains a single digit.  The digits are stored in reverse order,such that the 1’s digit is at the head of the list. Write a function that adds the two numbers and returns the sum as a linked list.

EXAMPLE：

input：(3 -> 1 -> 5), (5 -> 9 -> 2)

output：(8 -> 0 -> 8)

译文： 你有两个由单链表组成的数，单链表中每个节点包含一个数字，数字是逆序存储的，也就是说个位数放在链表头结点处。写一个函数使这两个数相加并返回结果，结果也由链表表示。

例如：

输入：(3 -> 1 -> 5), (5 -> 9 -> 2)

输出：(8 -> 0 -> 8)

这道题目涉及到链表的基本操作以及异常场景用例分析。这里的异常场景主要包括：1.链表为空；2.最高位有进位；3.两个链表长度不一。

我们注意到单链表中数字是逆序存储的，所以我们在进行相加运算时，只能将低位结果对应一次地添加到新链表尾。对于场景2，我们需要在最后判断是否最高位有进位，如果有，则需要添加进位，反之，就不需要。场景3，需要判断哪个链表长，然后将长链表多余的那部分添加在新链表后面，当然在多余部分的最低位也需要考虑进位。

为此，我们首先要初始化一个单链表，将待相加数据写进去，然后编写一个链表添加函数。由于思路比较简单，直接贴代码(本系列基本上是C++编写)。

typedef struct NODE
{
	int data;
	struct NODE *pnext;
}Node;

void create(Node **pHead, int x)
{
	Node *q;

	q = new Node;
	assert(NULL != q);

	q->data = x;
	q->pnext = NULL;

	*pHead = q;

	return;
}

/*添加元素到链表尾*/
void addList(Node **pHead, int x)
{
	if (NULL == *pHead)
	{
		create(pHead, x);
		return;
	}

	Node *p, *q;
	p = *pHead;
	
	while (p->pnext)   p = p->pnext;

	q = new Node;
	assert(NULL != q);
	q->data = x;
	q->pnext = NULL;

	p->pnext = q;
	return;
}

上面针对本题可能显得比较冗杂，考虑到创建链表，添加链表属于常用，所以就都用上了。下面部分代码的功能是将数组写入链表中，链表中的数据的先后顺序和数组中的先后顺序保持一致，单独将各个功能函数分离处理，有利于程序的“高内聚，低耦合”。

void readToNode(Node **pHead, int a[], int size)
{
	if ((NULL == *pHead) || (NULL == a))
		return;

	Node *p = *pHead;
	p->data = a[0];

	for (int i = 1; i < size; ++i)
	{
		addList(&p, a[i]);
	}
	return;
}

最后是运算部分代码

Node* bignumberplus(Node *p, Node *q)
{
	if (NULL == p)  return q;
	if (NULL == q)  return p;

	Node *result = NULL;

	int data, carry;
	carry = 0;

	for (; ((p != NULL) && (q != NULL)); p = p->pnext, q = q->pnext)
	{
		data = (p->data + q->data + carry) % 10;
		addList(&result, data);
		carry = (p->data + q->data + carry) / 10;
	}

	if (p != NULL)
	{
		/*data = (p->data + carry) % 10;
		addList(&result, data);
		carry = (p->data + carry) / 10;
		p = p->pnext;*/      //998+2=1000 这种情况下测试出错
		while (p)  //只有p则直接添加到result后
		{
			data = (p->data + carry) % 10;
		        addList(&result, data);
		        carry = (p->data + carry) / 10;
		        p = p->pnext;
		}
		if (carry)   //最高位进位的情况
			addList(&result, carry);
		return result;
	}
	else if (q != NULL)
	{
		/*data = (q->data + carry) % 10;
		addList(&result, data);
		carry = (q->data + carry) / 10;
		q = q->pnext;*/
		while (q)
		{
		        data = (q->data + carry) % 10;
		        addList(&result, data);
		        carry = (q->data + carry) / 10;
		        q = q->pnext;*/
		}
		if (carry)
			addList(&result, carry);
		return result;
	}
	if (carry)
		addList(&result, carry);
	return result;
}

主要是长度不一和进位的处理上注意一下，程序看上去不够优化，直接贴出来了。测试代码

int main()
{
	Node *p, *q, *result;
	create(&p, 0);
	create(&q, 0);

	int a[] = { 9, 9, 9 };
	int b[] = { 1, 1, 1, 9 };
	int size_a = sizeof(a) / sizeof(a[0]);
	int size_b = sizeof(b) / sizeof(b[0]);
	readToNode(&p, a, size_a);
	readToNode(&q, b, size_b);

	result = bignumberplus(p, q);
	print(result);

	return 0;
}

结果为0,1,1,0,1，反过来就是999+9111=10110。

如果按照标准排序，即数字顺序存储，最低位在链表尾，那么我们就采用指定位置插入链表函数，每次在0位置插入即可。