Python反转链表

我正在做一个Python程序，它实现了链表以支持一些函数，我需要做的函数之一是反转堆栈。我已经创建了一个节点、LinkedList和Stack类，以下是我迄今为止的代码：

class ListNode:

    def __init__(self, Object):
        self.Object = Object
        self.next = None

class LinkedList:

    def __init__(self):
        self.head = None # first node
        self.tail = None # last node

    def addLast(self, Object):
        newNode = ListNode(Object)
        if self.head == None:
            self.head = newNode
            self.tail = newNode
        else:
           self.tail.next = newNode
           self.tail = newNode

    def removeFirst(self):
        if self.head == None:
            return

        self.head = self.head.next
        if self.head == None:
            self.tail = None

    def removeLast(self, Object):
        if self.head == None:
            return

        current = self.head
        prev = None
        while current.next != None:
            prev = current
            current = current.next

        if prev == None:
            self.head = None
            self.tail = None
        else:
            prev.next = None
            self.tail = prev

    def get(self, index):
        current = self.head
        i = 0
        while i < index and current != None:
            current = current.next
            i = i + 1
        if current != None and index >= 0:
            return current.Object
        else:
            return None

    def size(self):
        current = self.head
        count = 0
        while current != None:
            count = count + 1
            current = current.next
        return count

    def isEmpty(self):
        return self.head == None

    def printList(self):
        if self.head != None:
            current = self.head
            while current != None:
                print(current.Object, end = ' ')
                current = current.next
        print()

# -------------------- STACK ---------------------------------------------------
class Stack:
    # constructor implementation
    def __init__(self):
        self.llist = LinkedList()

    def front(self):
        return self.llist.get(0)

    def dequeue(self):
        self.llist.removeFirst()

    def queue(self, Object):
        self.llist(Object)

    def push(self, Object):
        self.llist.addLast(Object)

    def pop(self, Object):
        self.llist.removeLast(Object)

    def printStack(self):
        self.llist.printList()

    def size(self):
        return self.llist.size()

    def isEmpty(self):
        return self.llist.isEmpty()

# ----------------------- Reverse LIST ------------------------------
def Reverse(S):
    # S is a Stack Object

如果这是一个普通的列表，我可以使用[：-1]轻松地反转它，但我不能，因为linkedlist是一个对象。我在想也许我可以使用临时值，这样我就可以有人将堆栈的开头附加到列表中，然后以某种方式将其转换回堆栈对象

编辑以进行复制：我的程序的目标是使用现有堆栈并将其反转。链接帖子处理的是一个已经采用列表格式的链接列表

def get(self, index):
        current = self.head
        i = 0
        while i < index and current != None:
            current = current.next
            i = i + 1
        if current != None and index >= 0:
            return current.Object
        else:
            return None

---

编辑3：添加了对我的代码的返工，它会一次又一次地返回错误的第一个元素的反转。

你不应该在反转函数中摆弄链接指针。我假设您的堆栈中有一个pop（）方法和其他基础知识；如果没有，则克隆removeFirst函数以返回已删除的节点

现在，递归函数很简单：弹出列表的开头，反转剩余的堆栈（如果有），然后将弹出的节点添加到末尾。这能解决你的问题吗

def reverseStack(self):
    move_me = self.pop()
    if not self.isEmpty():
        return (self.reverseStack()).addLast(move_me)
    else:
        new_stack = Stack()
        return new_stack.addLast(move_me)

---

您不应该在反转函数中摆弄链接指针。我假设您的堆栈中有一个pop（）方法和其他基础知识；如果没有，则克隆removeFirst函数以返回已删除的节点

现在，递归函数很简单：弹出列表的开头，反转剩余的堆栈（如果有），然后将弹出的节点添加到末尾。这能解决你的问题吗

def reverseStack(self):
    move_me = self.pop()
    if not self.isEmpty():
        return (self.reverseStack()).addLast(move_me)
    else:
        new_stack = Stack()
        return new_stack.addLast(move_me)

---

使用基本堆栈操作很容易反转堆栈。将每个项目从旧的堆栈中弹出，并将其推到新的堆栈上

def reverse(stack):
    new_stack = Stack()
    while not stack.isEmpty():
        new_stack.push(stack.front())
        stack.pop()
    return new_stack

您可以执行类似的操作，在

堆栈中以破坏性方式反转
链接列表
，同时重用堆栈对象本身，您只需要使用列表操作，而不是别名为它们的堆栈操作

说到堆栈操作，您可能会发现，如果从前面而不是后面推动并弹出堆栈，那么堆栈的性能会更好。从链表末尾删除一个项目需要迭代整个列表（以查找倒数第二个节点）。相反，从前面添加和删除都很快。
使用基本堆栈操作反转堆栈非常容易。将每个项目从旧的堆栈中弹出，并将其推到新的堆栈上

def reverse(stack):
    new_stack = Stack()
    while not stack.isEmpty():
        new_stack.push(stack.front())
        stack.pop()
    return new_stack

您可以执行类似的操作，在
堆栈中以破坏性方式反转
链接列表
，同时重用堆栈对象本身，您只需要使用列表操作，而不是别名为它们的堆栈操作

说到堆栈操作，您可能会发现，如果从前面而不是后面推动并弹出堆栈，那么堆栈的性能会更好。从链表末尾删除一个项目需要迭代整个列表（以查找倒数第二个节点）。相比之下，从前面添加和删除都很快。
使用基本数据结构进行反转的常用算法是使用堆栈是先进先出的数据结构这一事实。这意味着，如果
pop
直到堆栈为空，您将以与
push
相反的顺序获取项目

但是看起来您希望通过递归函数而不是显式堆栈来实现这一点——在这种情况下，您的函数通常会获取前端元素，然后在数据结构的其余部分上递归，然后处理第一个元素。这会使所有元素按顺序排列，但在每次递归调用完成并以自己的方式备份调用堆栈时，会以相反的顺序处理它们。如果您需要将元素添加到反向数据结构中（而不仅仅是打印它们），您可以通过返回值来构建它，注意一旦您有了反向，如果当前元素之后的所有内容，您只需将该元素附加到前面，就可以得到与您所获得的所有内容相反的内容。
使用基本数据结构反转内容的常用算法是使用堆栈是先进先出的数据结构这一事实。这意味着，如果
pop
直到堆栈为空，您将以与
push
相反的顺序获取项目

但是看起来您希望通过递归函数而不是显式堆栈来实现这一点——在这种情况下，您的函数通常会获取前端元素，然后在数据结构的其余部分上递归，然后处理第一个元素。这会使所有元素按顺序排列，但在每次递归调用完成并以自己的方式备份调用堆栈时，会以相反的顺序处理它们。如果您需要将元素添加到反向数据结构中（而不仅仅是打印它们），您可以通过返回值来构建它，注意一旦您有了反向，如果当前元素之后的所有内容，您只需将该元素附加到前面，就可以得到与您所获得的所有内容相反的内容。
解决此问题的其他方法：作弊

定义一个
\uuuuuuuuuu iter\uuuuuuu
方法（这在任何情况下都是有意义的；迭代是Python的核心行为）以使您的类型可移植。简单的例子：

def __iter__(self):
    cur = self.head
    while cur is not None:
        yield cur.Object
        cur = cur.next

那么就做：

values = list(self)  # Creates a list containing the current set of values
self.head = self.tail = None  # Clear existing linked list
# Add back all the values in reverse order
for value in reversed(values):
    self.addLast(value)

当然，它在内存分配/释放开销方面的效率可能比正确地进行内存分配/释放开销要低。但是这种效果可能是微不足道的，它极大地简化了实现代码

当然，正确地操作并不是那么难，只是稍微有点混乱（完全未经测试，但应该接近正确）：

解决这个问题的其他方法：欺骗

定义一个
\uuuuuuuuuu iter\uuuuuuu
方法（这在任何情况下都是有意义的；迭代是Python的核心行为）以使您的类型可移植。简单的例子：

def __iter__(self):
    cur = self.head
    while cur is not None:
        yield cur.Object
        cur = cur.next

那么就做：

values = list(self)  # Creates a list containing the current set of values
self.head = self.tail = None  # Clear existing linked list
# Add back all the values in reverse order
for value in reversed(values):
    self.addLast(value)

当然，它的内存分配效率可能会降低