LintCode 链表求和 问题解答

 链表求和

•  描述
• 你有两个用链表代表的整数，其中每个节点包含一个数字。数字存储按照在原来整数中相反的顺序，使得第一个数字位于链表的开头。写出一个函数将两个整数相加，用链表形式返回和。

样例

给出两个链表 3->1->5->null 和 5->9->2->null，返回 8->0->8->null




通过做这个题，总结出大数相加减的一般方法：

1：将两个数据以字符串的形式进行读取到变量中

2：将两个字符串的每一个字符转换成相对应的int值分别存放到对应的vector集合中

3：将两个vector都通过reverse函数进行倒序

4：设置一个进位变量，将两个vector中的数加起来再加上进位 %10 后存入到一个新的vector中，同时更新进位的值

5：当一个vector已经遍历完了之后，剩下的那个vector依次加上进位的值，并更新每次的进位

6：第二个数组也遍历完了之后，最后判断进位是否为1，是的话在结果vector中在插入一个1，否则不插入。

7：将结果vector进行倒序，并生成字符串，输出

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 
class Solution {
public:
    /**
     * @param l1: the first list
     * @param l2: the second list
     * @return: the sum list of l1 and l2 
     */
     
     ListNode* generate(vector<int> in)
{
	if (in.size() == 0)
		return NULL;
	ListNode * rt = (ListNode*)malloc(sizeof(ListNode));
	ListNode* p = rt;
	for (int i = 0; i < in.size(); i++)
	{
		ListNode* tem = (ListNode*)malloc(sizeof(ListNode));
		tem->val = in[i];
		tem->next = NULL;
		p -> next = tem;
		p = p->next;
		
	}
	return rt->next;
	
}
ListNode *addLists(ListNode *l1, ListNode *l2) {
	// write your code here
	vector<int> A;
	vector<int> B;
	while (l1 != NULL)
	{
		A.push_back(l1->val) ;
		l1 = l1->next;
	}

	while (l2 != NULL)
	{
	    B.push_back(l2->val);
		l2 = l2->next;
	}
   
     
     vector<int> G;
     int i=0;
     int minsize;
     int maxsize;
     
     if(A.size()<=B.size())
    {
        minsize=A.size();
        maxsize=B.size();
    }
    else
    {
        minsize=B.size();
        maxsize=A.size();
    }
     
     int jinwei=0;//进位
     for(i=0;i<minsize;i++)
     {
         int tem=A[i]+B[i]+jinwei;
         if(tem>=10)
         {
             jinwei=1;
             tem=tem%10;
             G.push_back(tem);
         }
         else
         {
             jinwei=0;
             G.push_back(tem);
         }
     }
     
     if(maxsize==A.size())
     {
        for(;i<A.size();i++)
        {
            int tem=jinwei+A[i];
            if(tem>=10)
            {
                tem%=10;
                jinwei=1;
                G.push_back(tem);
            }
            else
            {
                jinwei=0;
                G.push_back(tem);
            }
        }
     
     
     }
     else
     {
         for(;i<B.size();i++)
         {
             int tem=jinwei+B[i];
             if(tem>=10)
             {
                 tem%=10;
                 jinwei=1;
                 G.push_back(tem);
             }
             else
             {
                 jinwei=0;
                 G.push_back(tem);
             }
         }
     }
     if(jinwei!=0)//如果最后还有进位
     G.push_back(jinwei);
     
	return generate(G);
}
};