我正在做一个实现链表的Python程序来支持一些函数，我需要做的一个功能是反转堆栈。我已经创建了Node，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
以下是我对此问题的尝试：
def rRecursive( self ) :
self._rRecursive( self.head )
def _reverseRecursive( self, n ) :
if None != n:
right = n.next
if self.head != n:
n.next = self.head
self.head = n
else:
n.next = None
self._rRecursive( right )
def Reverse(S):
s.rRecursive()
如果这是一个普通的列表，我可以使用[:: - 1]轻松地反转它，但我不能，因为链表是一个对象。我想也许我可以使用临时值，所以我可以将堆栈的开头附加到列表然后以某种方式将其转换回堆栈对象。
编辑重复：我的程序的目标是使用现有的堆栈并将其反转。链接的帖子处理已经是列表格式的链接列表。
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
编辑2 ：添加了我的get函数。
class Stack:
# constructor implementation
def __init__(self):
self.llist = LinkedList()
def front(self):
return self.llist.get(0)
# push method implementation
def push(self, Object):
self.llist.addLast(Object)
def pop1(self):
self.llist.removeLast1()
def Reverse(S):
new_stack = Stack()
while not S.isEmpty():
new_stack.push(S.front())
S.pop1()
return new_stack
# Current Stack after Push: 12 14 40 13
# Stack after Pop: 12 14 40
# Stack after Reversal: 12 12 12
编辑3 ：添加了我的代码的返工，它反复返回第一个元素的错误反转。
答案 0 :(得分：2)
使用基本堆栈操作反转堆栈非常容易。将每个项目从旧堆栈中弹出并将其推送到新堆栈。
def reverse(stack):
new_stack = Stack()
while not stack.isEmpty():
new_stack.push(stack.front())
stack.pop()
return new_stack
你可以做类似的事情，在重用堆栈对象本身的同时破坏性地反转LinkedList中的Stack，你只需要使用列表操作而不是别名的堆栈操作它们。
说到堆栈操作，您可能会发现如果从前面而不是后面推送和弹出，堆栈的性能会更好。从链表末尾删除项目需要遍历整个列表（以查找倒数第二个节点）。相比之下，从正面添加和删除都很快。
答案 1 :(得分：1)
你不应该在你的反转功能中摆弄链接指针。我假设你有一个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)
答案 2 :(得分：1)
解决此问题的其他方法：作弊。
定义一个__iter__方法（在任何情况下都有意义;迭代是一个核心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)
当然，内存分配/释放开销的效率可能低于正确执行内存分配/解除分配开销的效率。但效果可能很小，并且它极大地简化了实现代码。
当然，正确地做到这一点并不困难，只是稍微混乱一点（完全未经测试，但应该接近正确）：
def reverse(self):
# Start at beginning, which will be new end
cur, last = self.head, None
# Reverse head and tail pointers in advance
self.head, self.tail = self.tail, self.head
# Traverse while reversing direction of each node pointer
while cur is not None:
# Tuple pack and unpack allows one-line variable swap
cur.next, cur, last = last, cur.next, cur
答案 3 :(得分：0)
使用基本数据结构反转事物的常用算法是使用堆栈是最后输出数据结构的事实。这意味着如果您pop直到堆栈为空，您将按照push编辑它们的相反顺序获取项目。
但看起来你想通过递归函数而不是显式堆栈来实现这一点 - 在这种情况下，你的函数通常会获取前面的元素，然后递归到其余的数据结构上，然后处理第一个元素。这会按顺序关闭所有元素，但是在每个递归调用完成后以相反的顺序处理它们，并且您可以回到调用堆栈。如果您需要将元素添加到反向数据结构（而不仅仅是打印它们），您可以通过返回值来构建它，通过注意一旦你有反向，如果当前元素之后的所有内容，你只需要附加该元素在前面，你所拥有的一切都是相反的。
答案 4 :(得分：0)
class Node(object):
def __init__(self, data=None, next_node=None):
self.data = data
self.next = next_node
def Reverse(head):
if head == None :
return None
elif head.next == None :
return head # returns last element from stack
else :
temp = head.next # stores next element while moving forward
head.next = None # removes the forward link
li = Reverse(temp) # returns the last element
temp.next = head # now do the reverse link here
return li
def main() :
temp4 = Node(4,None)
temp3 = Node(3,temp4)
temp2 = Node(2,temp3)
head = Node(1,temp2)
res = Reverse(head)
while res != None :
print(res.data)
res = res.next
main()