python链表——两个单链表的数之和

输入：

3->4->5->6->7->9

9->8->2->6->5

输出：

2->3->8->2->3->0->1

 

思路：

1. 对链表直接相加操作

2. 引入外部链表resultList用来存放相加后的结果，tmp用来表示对应节点值相加后的个位数，c表示进位（相加后的十位数），sums表示节点相加与进位的和，cur1, cur2表示操作两个链表的指针

3. 要注意，如果一个链表更长，需要将剩余的节点，添加到resultLink中，同时要注意，加上之前的进位c

4. 最后要判断下，进位c是否还大于零，如果大于零，说明还有进位，需要加入的resultLink中

5. 特殊情况：如果有一个链表为空，直接返回另外一个链表

 

代码：

def doubleLinkAdd(head1, head2):
    # 如果有一个链表为空，直接返回另外一个链表
    if head1 is None:
        return head2
    if head2 is None:
        return head1
    # 引入变量及初始化，c表示进位，resultLink存储相加后的节点，cur1, cur2为操作的指针
    c = 0
    resultLink = LinkedList()
    cur1 = head1
    cur2 = head2
    # 循环依次相加对应节点的值，结果添加到resultLink
    while cur1 is not None and cur2 is not None:
        sums = cur1.data + cur2.data + c
        c = sums // 10  # 整除，例：27//10=2, 表示进位
        tmp = sums % 10  # 取余，例：27%10=7，表示相加结果的个位数的值
        resultLink.add(tmp)
        cur1 = cur1.next
        cur2 = cur2.next

    # 如果链表1更长，将剩余节点加入到结果链表中
    if cur1 is not None:
        while cur1:
            sums = cur1.data + c
            c = sums // 10
            tmp = sums % 10
            resultLink.add(tmp)
            cur1 = cur1.next

    # 如果链表2更长，将剩余节点加入到结果链表中
    if cur2 is not None:
        while cur2:
            sums = cur2.data + c
            c = sums // 10
            tmp = sums % 10
            resultLink.add(tmp)
            cur2 = cur2.next

    # 判断是否还有进位，有进位则加入链表
    if c > 0:
        resultLink.add(c)
    return resultLink

# 测试
if __name__ == "__main__":
    print("============link1===========")
    link1 = LinkedList()
    link1.add(3)
    link1.add(4)
    link1.add(5)
    link1.add(6)
    link1.add(7)
    link1.add(9)
    link1.print_link()
    print("============link2===========")
    link2 = LinkedList()
    link2.add(9)
    link2.add(8)
    link2.add(2)
    link2.add(6)
    link2.add(5)
    link2.print_link()
    print("============resultLink===========")
    doubleLinkAdd(link1.head, link2.head).print_link()

# 结果
============link1===========
3
4
5
6
7
9
============link2===========
9
8
2
6
5
============resultLink===========
2
3
8
2
3
0
1

评论：对两个链表进行遍历，时间复杂度为O(N)，N为更长链表的长度，计算结果保存到了一个新的链表中，故空间复杂度为O(N)