LeetCode第二关：Add Two Numbers --> Difficulty: Medium

继续我们的LeetCode升级之路。直接进入正题，LeetCode算法部分第二道问题如下：

--------------------------------------------------------------------我是问题描述开始标记----------------------------------------------------------------------

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

--------------------------------------------------------------------我是问题描述结束标记----------------------------------------------------------------------

可知这是一道单向链表相关的问题。单向链表相关的问题一向也是面试官的最爱，通过对单向链表的操作，可以考察对相关联的非连续内存的处理能力。当然这道问题与单向链表的处理操作关联并不大。

最初拿到这道问题时，我想到了两种解决方法，一种是直接对单向链表的每一位元素进行加法操作，手动维护进位，而且问题中给出数字是以相反的顺序保存在单向链表中的，正好可以从链表头开始对单向链表进行操作；第二种方法是将单向链表中保存的数字复原为原本的十进制数字，然后将两个数字进行相加，再转化为单向链表返回。

接下来，我的选择彻底地体现了我的图样图森破。考虑到第一种方法需要手动维护进位，我觉得这不够智能，结果果断放弃了第一种方法，选择了第二种方法。那么选择第二种方法的问题在哪里呢？在此先卖个关子，有经验的老鸟应该已经知道答案了。

关于第二种方法，我的实现代码如下：

struct ListNode {
      int val;
      ListNode *next;
      ListNode(int x) : val(x), next(NULL) {}
};

ListNode *addTwoNumbers(ListNode *l1, ListNode *l2)
{
	if (l1 == NULL || l2 == NULL)
	{
		return NULL;
	}

	ListNode *result = NULL;
	ListNode *p_result = NULL;
	ListNode *p_l1 = l1;
	ListNode *p_l2 = l2;
	int num1 = 0, num2 = 0;
	int sum_num = 0;

	for(int i = 0; p_l1 != NULL || p_l2 != NULL; ++i)
	{
		num1 = num1 + ((p_l1 != NULL)?(p_l1->val * (int)std::pow((double)10, (double)i)):0);
		num2 = num2 + ((p_l2 != NULL)?(p_l2->val * (int)std::pow((double)10, (double)i)):0);

		if (p_l1 != NULL)
		{
		    p_l1 = p_l1->next;
		}

		if (p_l2 != NULL)
		{
		    p_l2 = p_l2->next;
		}
	}

	sum_num = num1 + num2;

	while(sum_num / 10 != 0)
	{
		if(result == NULL)
		{
			p_result = new ListNode(sum_num % 10);
			result = p_result;
		}

		else
		{
			p_result->next = new ListNode(sum_num % 10);
			p_result = p_result->next;
		}

		sum_num = sum_num / 10;
	}

	if (sum_num != 0)
	{
		p_result->next = new ListNode(sum_num);
	}

	return result;
}

上面的代码看似没问题，但当我信心满满的提交到LeetCode上，却发现有测试用例跑不过，仔细看了下结果对比，发现是在l1和l2代表的两个数很大时，输出结果与期望的不一样。这时，我才恍然意识到，第二种方法存在整数越界的风险，我现在使用的是int型来保存该整数，但即使我使用long long型的，也依然存在越界的风险，因为通过使用单向链表来表示整数，可以表示任意大小的整数，完全没有限制。意识到这点之后，其实解决方案已经出来了，我们只能使用第一种方法来解决该问题了。

细想一下，l1和l2中的每一个元素实际上就是保存的某两个整数的每一位，因此，每一个元素的val值一定在0~9范围内，那么相加的和最大为18，所以进位标志只能为0或1。再者，要注意两点：

1、若两个链表的长度不一致，当短链表遍历结束之后，对于长链表剩下的元素，也要添加到结果链表中，这里面需要注意边界处理，即当短链表最后一个元素与长链表中相应位置的元素相加后有进位，则此时，长链表的下一个元素要加上该进位，并继续做好进位处理，最极端的例子：l1 = 9->9->9->9->9->9，l2 = 1。

2、若两个链表的长度一致，这里面也需要注意边界处理，当对最后一对元素进行处理后，若是有进位，则需要对该进位值进行处理，例如：l1 = 2->3->6，l2 = 4->5->4。

有了上面的想法之后，具体的实现代码为：

ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        
    if (l1 == NULL || l2 == NULL)
    {
        return NULL;
    }
        
    ListNode* result = NULL;
    ListNode* p_result = NULL;
    ListNode* p_l1 = l1;
    ListNode* p_l2 = l2;
    int carry_num = 0;
    int sum_num = 0;
        
    while(p_l1 != NULL && p_l2 != NULL)
    {
        sum_num = p_l1->val + p_l2->val + carry_num;
        carry_num = sum_num / 10;
            
        if (result == NULL)
        {
            p_result = new ListNode(sum_num % 10);
            result = p_result;
        }
            
        else
        {
            p_result->next = new ListNode(sum_num % 10);
            p_result = p_result->next;
        }
            
        p_l1 = p_l1->next;
        p_l2 = p_l2->next;
    }
        
    while(p_l1 != NULL)
    {
        sum_num = p_l1->val + carry_num;
        carry_num = sum_num / 10;
            
        if (result == NULL)
        {
            p_result = new ListNode(sum_num % 10);
            result = p_result;
        }
            
        else
        {
            p_result->next = new ListNode(sum_num % 10);
            p_result = p_result->next;
        }
        p_l1 = p_l1->next;
    }
        
    while(p_l2 != NULL)
    {
        sum_num = p_l2->val + carry_num;
        carry_num = sum_num / 10;
            
        if (result == NULL)
        {
            p_result = new ListNode(sum_num % 10);
            result = p_result;
        }
            
        else
        {
            p_result->next = new ListNode(sum_num % 10);
            p_result = p_result->next;
        }
        p_l2 = p_l2->next;
    }
        
    if (carry_num != 0)
    {
        p_result->next = new ListNode(carry_num);
    }
        
    return result;
}

将上面的代码提交，这次测试用例全部跑过了。

上面的代码写的还是不够简洁，LeetCode上给出了更简洁的实现方式，但解决问题的思路是一致的。

经验总结：在使用整型时，尤其是涉及到运算或是从其他形式转到整型变量，脑袋里要时刻有一根弦，就是，越界风险。