（两百二十二）leetcode 用队列实现栈

1. 题目

https://leetcode-cn.com/problems/implement-stack-using-queues/

使用队列实现栈的下列操作：

push(x) -- 元素 x 入栈
pop() -- 移除栈顶元素
top() -- 获取栈顶元素
empty() -- 返回栈是否为空
注意:

你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。
你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/implement-stack-using-queues
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

2.思路

我联想到了昨天写的两个栈输出最小值，有个解法是使用链表的，我照着记忆写了一个，但是不满足题目要求，栈本来就是用链表实现的，题目要求是使用队列

稍微百度了下队列的实现

        Queue queue = new LinkedList();
        queue.add(5);
        queue.add(4);
        queue.add(3);
        queue.add(2);
        queue.add(1);
        queue.add(0);


        queue.poll();
        System.out.println("queue : " + queue);
        System.out.println("queue : " + queue.isEmpty());
        System.out.println("queue : " + queue.peek());


queue : [4, 3, 2, 1, 0]
queue : false
queue : 4

 

问题在于队列是先进先出的，对应到堆栈就是pop方法和peek方法是不对应的，我想着是要拿尾巴的时候将前面的全部出来，只剩下尾巴。

 

3.coding

3.1 双队列

class MyStack {
    Queue<Integer> queue = new LinkedList();
    Queue<Integer> queue2 = new LinkedList();
    /** Initialize your data structure here. */
    public MyStack() {

    }

    /** Push element x onto stack. */
    public void push(int x) {
        if (!queue2.isEmpty()){
            queue2.add(x);
        } else {
            queue.add(x);
        }
    }

    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        if (queue.isEmpty() && queue2.isEmpty()) {
            return Integer.MIN_VALUE;
        } else if (queue2.isEmpty()){
            while(queue.size() != 1){
                queue2.add(queue.poll());
            }
            return queue.poll();
        } else {
            while(queue2.size() != 1){
                queue.add(queue2.poll());
            }
            return queue2.poll();
        }
    }

    /** Get the top element. */
    public int top() {
        int value = pop();
        if (value != Integer.MIN_VALUE){
            if (!queue.isEmpty()){
                queue.add(value);
            } else {
                queue2.add(value);
            }
        }
        return value;
    }

    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue.isEmpty() && queue2.isEmpty();
    }
}

这样看起来还不如push的时候累一点

class MyStack{
    Queue<Integer> queue = new LinkedList();
    Queue<Integer> queue2 = new LinkedList();
    /** Initialize your data structure here. */
    public MyStack() {

    }

    /** Push element x onto stack. */
    public void push(int x) {
        if (!queue2.isEmpty()){
            queue.add(x);
            while(!queue2.isEmpty()){
                queue.add(queue2.poll());
            }
        } else {
            queue2.add(x);
            while(!queue.isEmpty()){
                queue2.add(queue.poll());
            }
        }
    }

    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        if (queue.isEmpty() && queue2.isEmpty()) {
            return Integer.MIN_VALUE;
        } else if (queue2.isEmpty()){
            return queue.poll();
        } else {
            return queue2.poll();
        }
    }

    /** Get the top element. */
    public int top() {
        if (queue.isEmpty() && queue2.isEmpty()) {
            return Integer.MIN_VALUE;
        } else if (queue2.isEmpty()){
            return queue.peek();
        } else {
            return queue2.peek();
        }
    }

    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue.isEmpty() && queue2.isEmpty();
    }
}

 

3.2 单队列

class MyStack {
    Queue<Integer> queue = new LinkedList();
    /** Initialize your data structure here. */
    public MyStack() {

    }

    /** Push element x onto stack. */
    public void push(int x) {
        queue.add(x);
        int size =  queue.size();
        for (int i = 0; i < size-1; i++){
            queue.add(queue.remove());
        }
    }

    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        return queue.poll();
    }

    /** Get the top element. */
    public int top() {
        return queue.peek();
    }

    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue.isEmpty();
    }
}

这样做很巧妙，每次push的时候都将新的放在最前面