Question

这不是硬件或作业。这是我自己练习的东西。

给定一个队列，写一个Reverse方法可以反转队列的元素。 MyQueue保持不变。

签名：

public Queue<T> reverse(Queue<T> myQueue) {

注意：无法使用节点或数组创建队列。

队列已经实现了我们可以使用的方法：

void enqueue(T element)
T dequeue();
boolean isFull();
boolean isEmpty();
int size();

Answer 1

您可以使用堆栈来反转队列。

以下是Java中的内容：

public void reverse(Queue q)
{
    Stack s = new Stack();  //create a stack

    //while the queue is not empty
    while(!q.isEmpty())
    {  //add the elements of the queue onto a stack
       s.push(q.serve());
    } 

    //while the stack is not empty
    while(!s.isEmpty())
    { //add the elements in the stack back to the queue
      q.append(s.pop());
    }

}

队列的追加和投放方法是添加和删除该队列的元素。

以下是一个例子：

队列包含元素：

1 2 3 4

当元素添加到堆栈时，数字1将位于列表的底部，4位于顶部：

1 2 3 4＆lt; - top

现在弹出堆栈并将元素放回队列中：

4 3 2 1

我希望这会有所帮助。

Answer 2

将输入队列的元素出列到堆栈
将元素从堆栈中弹出，将每个元素排入输出队列。

Answer 3

您可以在没有任何其他数组或列表的情况下执行此操作，只需通过递归：

public static <T> Queue<T> flip(Queue<T> q) {
    Queue<T> ret = new Queue<>();
    recursiveFlip(q, ret);
    return ret;
}

private static <T> void recursiveFlip(Queue<T> src, Queue<T> dest) {
    T buffer = src.dequeue();
    if(!src.isEmpty()) {
        recursiveFlip(src, dest);
    }
    dest.enqueue(buffer);
}

第一个元素将堆叠在堆栈的“浅”部分中，而最后一个元素将堆叠在“更深”部分中，当递归到达结尾时，“更深”的值将首先添加，而“浅”则最后添加。

但请注意，每一个元素意味着更深入递归，因此如果队列太大，将发生堆栈溢出错误。

此外，原始队列不会“翻转”。

Answer 4

我使用了两种不依赖于队列大小的方法。第一个使用 Stack ，第二个使用 Java 8 Stream API （最快）。

我的测试中逆转队列的最有效解决方案是：

private Queue<Integer> reverse(Queue<Integer> queue) {
        List<Integer> collect = queue.stream()
                .collect(Collectors.toList());
        Collections.reverse(collect);
        return new LinkedList<>(collect);
    }

反向方法反转队列的元素

4 个答案:

您可以使用堆栈来反转队列。

以下是一个例子：