算法数据结构：栈、队列的另类实现

1、用两个栈实现队列

有时还会遇到要求用两个栈实现队列的需求，具体代码实现如下。

public class TwoStacksQueue {
    public Stack<Integer> stackPush;
    public Stack<Integer> stackPop;

    public TwoStacksQueue() {
        stackPush = new Stack<>();
        stackPop = new Stack<>();
    }

    public void pushToPop() {
        // push栈向pop栈倒入数据
        if (stackPop.isEmpty()) {
            while (!stackPush.isEmpty()) {
                stackPop.push(stackPush.pop());
            }
        }
    }

    public void queue(int value) {
        stackPush.push(value);
    }

    public int dequeue() {
        if (stackPop.isEmpty() && stackPush.isEmpty()) {
            throw new RuntimeException("Queue is empty!");
        }
        pushToPop();
        return stackPop.pop();
    }

    public int peek() {
        if (stackPop.isEmpty() && stackPush.isEmpty()) {
            throw new RuntimeException("Queue is empty!");
        }
        pushToPop();
        return stackPop.peek();
    }

    public static void main(String[] args) {
        TwoStacksQueue queue = new TwoStacksQueue();
        queue.queue(1);
        queue.queue(2);
        queue.queue(3);
        queue.queue(4);

        System.out.println("peek -> " + queue.peek());
        System.out.println(queue.dequeue());
        System.out.println("peek -> " + queue.peek());
        System.out.println(queue.dequeue());
        System.out.println("peek -> " + queue.peek());
        System.out.println(queue.dequeue());
        System.out.println("peek -> " + queue.peek());
        System.out.println(queue.dequeue());
    }
}

举个例子：比如有人问你如何用栈结构实现广度优先搜索（BFS），众所周知，BFS 是利用队列来实现的，怎么只利用栈来实现 BFS 呢？其实这里我们完全是可以先利用两个栈实现一个队列，然后在用自己实现的队列，来完成 BFS 代码的编写。

2、用两个队列实现栈

同样也可能会遇到要求用两个队列实现栈，代码实现如下。

public class TwoQueuesStack {
    public Queue<Integer> queue;
    public Queue<Integer> help;

    public TwoQueuesStack() {
        queue = new LinkedList<>();
        help = new LinkedList<>();
    }

    public void push(int value) {
        queue.offer(value);
    }

    private void helpOffer() {
        while (queue.size() > 1) {
            help.offer(queue.poll());
        }
    }

    public Integer poll() {
        // queue 中除 index = 0 外的所有数据转移到 help 数组中
        helpOffer();
        // 弹出 queue 中最后一个元素
        Integer cur = queue.poll();
        Queue<Integer> temp = queue;
        // 将 help 和 queue 交换
        queue = help;
        help = temp;
        // 返回最后一个元素
        return cur;
    }

    public Integer peek() {
        helpOffer();
        // 弹出 queue 中最后一个元素
        Integer cur = queue.poll();
        // 将 cur 入 help 队
        help.offer(cur);
        Queue<Integer> temp = queue;
        // 将 help 和 queue 交换
        queue = help;
        help = temp;
        // 返回最后一个元素
        return cur;
    }

    public boolean isEmpty() {
        return queue.isEmpty();
    }

    public static void main(String[] args) {
        TwoQueuesStack stack = new TwoQueuesStack();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.push(6);

        System.out.println("peek -> " + stack.peek());
        System.out.println(stack.poll());
        System.out.println("peek -> " + stack.peek());
        System.out.println(stack.poll());
        System.out.println("peek -> " + stack.peek());
        System.out.println(stack.poll());
        System.out.println("peek -> " + stack.peek());
        System.out.println(stack.poll());
        System.out.println("peek -> " + stack.peek());
        System.out.println(stack.poll());
        System.out.println("peek -> " + stack.peek());
        System.out.println(stack.poll());
    }
}

举个例子：比如有人问你如何用队列结构实现深度优先搜索（DFS）？众所周知，DFS 是利用栈来实现的，怎么只利用队列来实现 DFS 呢？其实这里我们完全是可以先利用两个队列实现一个栈，然后在用自己实现的栈，来完成 DFS 代码的编写。