数据结构与算法 —— 链表linked list(02)

我们继续来看链表的第二道题，来自于leetcode:

两数相加

给定两个非空链表来代表两个非负整数，位数按照逆序方式存储，它们的每个节点只存储单个数字。将这两数相加会返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

分析：

　　因为是位数按照逆序方式存储，所以链表的前置节点是地位，直接循环链表相加，生成新的链表即可。这里要注意，链表1和链表2长度不一样的情况。

代码：

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

def addTwoNumbers(l1, l2):
    """
    :type l1: ListNode
    :type l2: ListNode
    :rtype: ListNode
    """
    pre_node = ListNode(0)
    cur = pre_node
    n = 0
    while l1 or l2:
        n1 = n2 = 0
        if l1:
            n1 = l1.val
            l1 = l1.next
        if l2:
            n2 = l2.val
            l2 = l2.next
        sumnum = n1 + n2 + n
        n = sumnum / 10
        cur.next = ListNode(sumnum % 10)
        cur = cur.next
        if l1:
            l1 = l1.next
        if l2:
            l2 = l2.next
    if n > 0:
        cur.next = ListNode(n)
    return pre_node.next

进阶版的两数相加，来自于leetcode:

两数相加II

给定两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储单个数字。将这两数相加会返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

进阶:

如果输入链表不能修改该如何处理？换句话说，你不能对列表中的节点进行翻转。

示例:

输入: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
输出: 7 -> 8 -> 0 -> 7

分析：

　　因为数字最高位位于链表的开始，而加减法我们不倾向于从高位做加减，但是又不允许对列表做翻转，那我们想到一个数据结构，栈。栈是先进后出，可以把列表压进一个栈中，再循环出栈的时间先出的就是低位，后出的就是高位，我们再按照上一个demo的方法做加减就好了。代码如下：

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

class Stack:
    """模拟栈"""

    def __init__(self):
        self.items = []

    def isEmpty(self):
        return len(self.items) == 0

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def peek(self):
        if not self.isEmpty():
            return self.items[len(self.items) - 1]

    def size(self):
        return len(self.items)

class Solution(object):
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        s1 = Stack()
        s2 = Stack()
        n = 0
        cur_node = ListNode(-1)
        while l1:
            s1.push(l1.val)
            l1 = l1.next
        while l2:
            s2.push(l2.val)
            l2 = l2.next
        while (not s1.isEmpty()) or (not s2.isEmpty()) or n:
            num1 = s1.pop() if not s1.isEmpty() else 0
            num2 = s2.pop() if not s2.isEmpty() else 0
            sumnum = num1 + num2 + n
            n = sumnum / 10
            cur_node.val = sumnum % 10
            pre_node = ListNode(-1)
            pre_node.next = cur_node
            cur_node = pre_node

        return cur_node.next

　　学习技术交流群：226704167，愿和各位一起进步！

原文地址：https://www.cnblogs.com/lip0121/p/8721267.html