Question

class Node:
    def __init__(self, data, next=None):
        self.data = data
        self.next = next

class LinkedList:
    def __init__(self, input=None):
        self.first = None
        self.last = None
        self.index = None
        if input is not None:
            for p in input:
                new = Node(p)
                if self.first is None:
                    self.first = new
                else:
                    self.last.next = new
                self.last= new

此代码从参数创建链接列表。

t = LinkedList([1,2,[3,4],5])

将存储为：1-2- [3,4] -5其中 - 符号是data.next参考。我需要反向这个列表，我的想法是交换元素[0] - [n]，[1] - [n-1] ..

def reverse(self):
    temp = self.first
    self.first = self.last
    self.last = temp
    temp = self.first.next

它交换第一个和最后一个元素并从开始时将temp作为下一个节点，但我不知道如何继续，如何使这个代码工作？

Answer 1

一般算法如下：

保持指向两个列表开头的指针，旧列表和新列表。最初，旧列表包含所有节点，新列表为空。
反复删除旧列表的第一个节点并将其添加到新列表的前面，直到旧列表为空并且新列表包含所有节点。

生成的新列表将与旧列表相反。

Answer 2

以下是工作Node类和LinkedList类以及reverse函数的示例，该函数可以反转单个链接列表。我们的想法是更改每个节点的内存引用。

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None


class LinkedList:
    def __init__(self):
        self.head = None

    def reverse(self):
        current = self.head
        previous = None
        while current:
            next_node = current.next
            current.next = previous
            previous = current
            current = next_node
        self.head = previous

在链表的一次传递中，我们通过跟踪current和previous节点来交换每个节点的指针。此算法不需要创建新的链接列表来存储反转列表，并且将以线性时间运行。我希望通过提供替代链表反向实现来提供帮助。

Answer 3

通过使用递归而不是迭代来修改@andrew 的解决方案：

def reverse(self):
    def recursive(curr, prev):
        if not curr:  # curr is None
            return prev
        temp = curr.next
        curr.next = prev
        prev = curr
        curr = temp

        return recursive(curr, prev)

    self.head = recursive(curr=self.head, prev=None)

反向链表python

3 个答案: