Question

我们获得了这项任务。

编写一个方法switchPairs，它将一堆整数作为参数，并从堆栈底部开始连续的数字对。

例： [1,2,3,4,5,6]成为[2,1,4,3,6,5]

但是我们也被告知我们只能使用一个队列进行辅助存储......我不知道这是怎么回事？我们不需要至少2个，因为我们想要交换数字对而你不能选择要弹出的堆栈索引吗？

Answer 1

嗯，你不需要多个队列。您只需要小心将元素插入队列。

这是一个快速的问题：

开始弹出堆栈元素。
您弹出的第二个元素，您想要插入之前弹出的元素前面。
完成后，以相反的顺序迭代队列（使用Deque或按相反的顺序对队列进行排序），将所有元素推入堆栈。

这是一个代码段。

public <T> Deque<T> switchPairs(final Deque<T> stack) {
    final Deque<T> result = new ArrayDeque<>();
    if(stack.size() % 2 != 0) {
        throw new IllegalArgumentException("I don't know how to handle odd sized lists.");
    }
    List<T> buffer = new LinkedList<>();
    int lastIndex = 0;
    while(!stack.isEmpty()) {
        buffer.add(stack.pop());
        buffer.add(lastIndex, stack.pop());
        lastIndex += 2;
    }
    for(final ListIterator<T> listIterator = buffer.listIterator(buffer.size()); listIterator.hasPrevious();) {
        result.push(listIterator.previous());
    }

    return result;
}

Answer 2

Deques支持两端的操作。所以利用它。

从您的堆栈中弹出项目，然后将addFirst和addLast替换为您的队列。因此，一堆[1,2,3,4,5,6]变为[2,4,6,5,3,1]。

现在，反转该过程，从队列中删除元素并将它们推回到堆栈中。我们做的最后一次操作是addLast;如果我们从removeFirst开始，它会有效地交换每对的顺序。（这都假设你的堆栈中有偶数个元素）

可视化：

stack           deque
[1,2,3,4,5,6]   []
[1,2,3,4,5]     >[6]
[1,2,3,4]       [6,5]<
[1,2,3]         >[4,6,5]
[1,2]           [4,6,5,3]<
[1]             >[2,4,6,5,3]
[]              [2,4,6,5,3,1]<

[2]             <[4,6,5,3,1]
[2,1]           [4,6,5,3]>
[2,1,4]         <[6,5,3]
[2,1,4,3]       [6,5]>
[2,1,4,3,6]     <[5]
[2,1,4,3,6,5]   []>

Answer 3

我们知道一个关键的事实：将堆栈的所有元素移动到队列然后返回到堆栈将简单地颠倒原始堆栈的元素的顺序。例如，[1,2,3,4]将产生[4,3,2,1]。

以下是我们可以做到的一种方式：

1) Pop and enqueue all elements of the stack to the queue.

2) Remove elements off of the queue two at a time and push it to the stack. By our crucial fact, we know that these two elements now have their orders reversed. Add the two values back onto the queue.

3) Repeat step two until all pairs have been cycled through.

4) Remove all elements of our queue and push it to the stack. We are almost done -- from our crucial fact, we know that this is our desired output in reverse.

5) Pop all elements of our stack and enqueue it. Remove all elements and push it back to the stack. This reverses everything and we have our desired output.

这是一个例子。假设我们从堆栈[1,2,3,4,5,6]开始，其中1是堆栈顶部...

(Step 0) [1, 2, 3, 4, 5, 6] (Stack)

(Step 1) [6, 5, 4, 3, 2, 1] (Queue) (1 is beginning of queue)

(Step 2) [6, 5, 4, 3] (Queue) [2, 1] (Stack)

(Step 2) [1, 2, 6, 5, 4, 3] (Queue)

(Step 3) [1, 2, 6, 5] (Queue) [4, 3] (Stack)

(Step 3) [3, 4, 1, 2, 6, 5] (Queue)

(Step 3) [3, 4, 1, 2] (Queue) [6, 5] (Stack)

(Step 3) [5, 6, 3, 4, 1, 2] (Queue)

(Step 4) [5, 6, 3, 4, 1, 2] (Stack)

(Step 5) [2, 1, 4, 3, 6, 5] (Queue)

(Step 5) [2, 1, 4, 3, 6, 5] (Stack)

当然，假设我们只提供基本的FIFO队列和LIFO堆栈（无法访问Deques或其他链接列表）。

Answer 4

1）将堆栈中的所有值弹出到队列中。

2）对于队列中的每对值，以相反的顺序将对推回堆栈。

使用下面的注释，我们注意到将所有元素推送到队列并返回列表将颠倒顺序。

然后，我们可以再次将值推送到列表中，并注意列表现在将按正确的顺序排列并应用2.

Stack bottom 1,2,3,4,5,6 top
Queue front 6,5,4,3,2,1 end
Stack bottom 6,5,4,3,2,1 top
Queue front 1,2,3,4,5,6 end

现在申请2）

Stack bottom 2,1,4,3,6,5 top

在一堆整数中交换对？

4 个答案: