两个链表生成相加链表

题目描述

假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。

给定两个这种链表，请生成代表两个整数相加值的结果链表。

例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。

示例

输入：[9,3,7],[6,3]

返回值：{1,0,0,0}

解题思路

小编看这道题看两两遍没懂啥意思，后来在草稿纸上写了这俩数字，才明白这道题是要我们把两个数字利用加法加起来，然后利用链表输出这个相加的数。

从小学开始就知道，加法应该是从个位开始计算，依次将计算位数递增，因此我们需要从个位开始对链表进行遍历——即反转输入的两个链表。

遍历的过程中需要考虑进位，这里我们考虑引入一个tag，用来标志是否需要进位补1。

遍历过程中需要考虑一个节点为空，而另一个节点不为空的情况。

如果原始链表遍历完成了，而tag没有归0，则表示还需要加一位，在栈中将1进位即可。

用一个栈储存加法计算的储存的节点，遍历结束后将栈中储存的节点反序连接，即可以获得相加的结果链表。

代码如下：

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

#
# 
# @param head1 ListNode类 
# @param head2 ListNode类 
# @return ListNode类
#
class Solution:
    def addInList(self , head1 , head2 ):
        # 将两个链表反转并返回链表头
        nHead1,nHead2=self.ReverseList(head1),self.ReverseList(head2)
        # 定义遍历节点，tag进位标志，stack储存相加的结果
        p1,p2,tag,stack=nHead1,nHead2,0,[]
        while p1 or p2:
            # p1为空且p2不为空
            if not p1 and p2:
                num = p2.val+tag
                # 和大于等于10，进位，且储存个位数
                if num>=10:
                    stack.append(ListNode(num%10))
                    tag=1
                # 和小于0，不进位，且储存个位数
                else:
                    stack.append(ListNode(num))
                    tag=0
                # p2向后遍历
                p2 = p2.next
            if not p2 and p1:
                num = p1.val+tag
                # 和大于等于10，进位，且储存个位数
                if num>=10:
                    stack.append(ListNode(num%10))
                    tag=1
                # 和小于0，不进位，且储存个位数
                else:
                    stack.append(ListNode(num))
                    tag=0
                # p1向后遍历
                p1 = p1.next
            if p1 and p2:
                num = p2.val+p1.val+tag
                # 和大于等于10，进位，且储存个位数
                if num>=10:
                    stack.append(ListNode(num%10))
                    tag=1
                # 和小于0，不进位，且储存个位数
                else:
                    stack.append(ListNode(num))
                    tag=0
                # p2，p1都向后遍历
                p2 = p2.next
                p1 = p1.next
        if tag==1:
            stack.append(ListNode(1))
        stack = stack[::-1]
        for i in range(len(stack)-1):
            stack[i].next=stack[i+1]
        return stack[0]
    def ReverseList(self, pHead):
        Now = pHead
        if not pHead:
            return 
        Next = Now.next
        if not Next:
            return pHead
        pre = Now
        pre.next = None
        while Next.next:
            pre = Now
            Now = Next
            Next = Next.next
            Now.next =pre
        Next.next = Now
        pHead = Next
        return pHead