我将如何在 python 中反转任何给定队列的内容？

Question

I am relatively new to python and am wondering how one would approach reversing a queue. Now if I understand correctly, a queue is simply a data structure that can be implemented in any language, using a list in python for example.

So basically if a question asks to reverse a stack or a queue, but since both can be represented using a list, isn't it the same as saying to reverse the contents of the list? I did some research on this topic and found that through using a class and methods, you can implement enqueue, dequeue and isEmpty operations.

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()

So if I were asked to reverse the contents of a queue stack for example, does that mean I have to reverse the contents of the list by using only the above methods? (by only removing items at the front of the list, and adding items at the back of list)

Answer 1

You can use an auxiliar stack to reverse the elements of your Queue.

Basically, you will stack every element of your Queue until it becomes empty. Then you pop each element of your stack and enqueue it until your stack is empty.

# 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())

Answer 2

No stack needed!

• Note that you need to be able to find the length of the queue. We can do this with an auxiliary queue, by popping and counting, and then replacing the items.

• Note that you can rotate a queue trivially with repeated pop - push pairs.

• Note you can switch indices m and n as so:

   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 ]

  So we can swap positions m and n in O(len(queue)) .

• Repeatedly swap the n th and len(queue)-n th items until n ≥ len(queue)-n .

---

So here it is:

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)

Length-finding routine:

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

Rotating routine:

def rotate(queue, n):
    for _ in range(n):
        queue.enqueue(queue.dequeue())

Swapping routine:

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)

Reversing routine:

def reverse(queue):
    left = 0
    right = queue_length(queue)-1

    while left < right:
        swap(queue, left, right)
        left += 1
        right -= 1

To test:

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]

---

Note that this can be made faster by finding different swaps that themselves are simpler;

  [ 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 ]

so we have the routine "push index 0 to index n ".

This is just

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)

giving

def quickreverse(queue):
    push_to = queue_length(queue)

    while push_to:
        shift_head(queue, push_to)
        push_to -= 1

which works:

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]

Answer 3

A Simple way using another queue

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

1. create an empty queue using a python list
2. append items to list
3. create another empty queue.

4.Using a for loop pop the values from 1st queue to the second one.

5.Done!!!