我是python的新手，我想知道如何处理逆转队列。现在，如果我理解正确，队列就是一个可以用任何语言实现的数据结构，例如使用python中的列表。
所以基本上如果一个问题要求反转堆栈或队列，但由于两者都可以使用列表来表示，它是否与反转列表内容的说法相同？我对这个主题做了一些研究，发现通过使用类和方法，你可以实现enqueue，dequeue和isEmpty操作。
class Queue:
def __init__(self):
self.items = []
def isEmpty(self):
return self.items == []
def enqueue(self, item):
self.items.insert(0,item)
def dequeue(self):
return self.items.pop()
因此，如果要求我反转队列堆栈的内容，这是否意味着我必须仅使用上述方法来反转列表的内容？ （仅删除列表前面的项目，并在列表后面添加项目）
答案 0 :(得分：5)
您可以使用辅助堆栈来反转队列中的元素。
基本上，您将堆叠队列的每个元素，直到它变空。然后弹出堆栈的每个元素并将其排队，直到堆栈为空。
# suppose your have a Queue my_queue
aux_stack = Stack()
while not my_queue.isEmpty():
aux_stack.push(my_queue.dequeue())
while not aux_stack.isEmpty():
my_queue.enqueue(aux_stack.pop())
答案 1 :(得分：3)
请注意，您需要能够找到队列的长度。我们可以使用辅助队列，弹出和计数，然后替换项目。
请注意，您可以使用重复的pop - push对轻松地轮换队列。
请注意，您可以将索引m和n切换为：
Have
[ 1 2 3 ... m-1 m m+1 ... n-1 n n+1 ... x ]
Want
[ 1 2 3 ... m-1 n m+1 ... n-1 m n+1 ... x ]
Rotate to n
[ n+1 ... x 1 2 3 ... m-1 m m+1 ... n-1 n ]
Pop into temporary storage
[ n+1 ... x 1 2 3 ... m-1 m m+1 ... n-1 ]
t = n
Rotate to m
[ m+1 ... n-1 n+1 ... x 1 2 3 ... m-1 m ]
t = n
Push from temporary storage
[ n m+1 ... n-1 n+1 ... x 1 2 3 ... m-1 m ]
Pop into temporary storage
[ n m+1 ... n-1 n+1 ... x 1 2 3 ... m-1 ]
t = m
Rotate to n-1
[ n+1 ... x 1 2 3 ... m-1 n m+1 ... n-1 ]
t = m
Push from temporary storage
[ n+1 ... x 1 2 3 ... m-1 n m+1 ... n-1 m ]
Rotate to x
[ 1 2 3 ... m-1 n m+1 ... n-1 m n+1 ... x ]
因此，我们可以在m中交换位置n和O(len(queue))。
重复交换n和len(queue)-n项，直到n ≥ len(queue)-n。
所以这是：
class Queue:
def __init__(self):
self.items = []
def isEmpty(self):
return self.items == []
def enqueue(self, item):
self.items.insert(0,item)
def dequeue(self):
return self.items.pop()
# For visualisation
def __repr__(self):
return repr(self.items)
长度寻找程序：
def queue_length(queue):
length = 0
auxillary = Queue()
while not queue.isEmpty():
length += 1
auxillary.enqueue(queue.dequeue())
while not auxillary.isEmpty():
queue.enqueue(auxillary.dequeue())
return length
轮换程序：
def rotate(queue, n):
for _ in range(n):
queue.enqueue(queue.dequeue())
交换例程：
def swap(queue, m, n):
length = queue_length(queue)
# Make sure m ≤ n
if m > n:
m, n = n, m
# Rotate to n
rotate(queue, length-n-1)
# Pop into temporary storage
temp = queue.dequeue()
# Rotate to m
rotate(queue, n-m-1)
# Swap
queue.enqueue(temp)
temp = queue.dequeue()
# Rotate to where n was
rotate(queue, m-n-1+length)
# Push back
queue.enqueue(temp)
# Rotate to start
rotate(queue, n)
扭转例程：
def reverse(queue):
left = 0
right = queue_length(queue)-1
while left < right:
swap(queue, left, right)
left += 1
right -= 1
测试：
queue = Queue()
for i in reversed(range(20)):
queue.enqueue(i)
queue
#>>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
reverse(queue)
queue
#>>> [19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
请注意，通过查找本身更简单的不同交换，可以更快地完成此操作;
[ a b c d e f g ]
→ [ b c d e f g a ]
→ [ c d e f g b a ]
→ [ d e f g c b a ]
→ [ e f g d c b a ]
→ [ f g e d c b a ]
→ [ g f e d c b a ]
所以我们有例程“推送索引0来索引n”。
这只是
def shift_head(queue, n):
length = queue_length(queue)
# Rotate head to end and pop
rotate(queue, length-1)
temp = queue.dequeue()
# Insert in position n
rotate(queue, length-n-1)
queue.enqueue(temp)
# Rotate back
rotate(queue, n)
给
def quickreverse(queue):
push_to = queue_length(queue)
while push_to:
shift_head(queue, push_to)
push_to -= 1
有效：
queue
#>>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
quickreverse(queue)
queue
#>>> [19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
答案 2 :(得分：0)
使用另一个队列的简单方法
queue = [] # queue
queue.append(1) # adding items
queue.append(2)
queue.append(3)
print(queue) #original queue
queue_2 = []
for i in range(0,len(queue)):
queue_2.append(queue.pop())
print(queue_2) # reversed queue
4。使用for循环将值从第一个队列弹出到第二个队列。
5。完成!!!