算法刷题｜232.用栈实现队列、225.使用队列实现栈

用栈实现队列

题目：使用栈实现队列的下列操作：
push(x) – 将一个元素放入队列的尾部。
pop() – 从队列首部移除元素。
peek() – 返回队列首部的元素。
empty() – 返回队列是否为空。

思路：使用两个栈来实现队列的先进先出，进队的时候进入栈stackIn，出队的时候从栈stackOut出

class MyQueue {
    Stack<Integer> stackIn; 
    Stack<Integer> stackOut;
    public MyQueue() {
        stackIn = new Stack<>();
        stackOut = new Stack<>();
    }
    
    public void push(int x) {
        stackIn.push(x);
    }
    
    public int pop() {
        stackIn2Out();
        return stackOut.pop();
    }

    private void stackIn2Out(){
        if(stackOut.size() == 0){
            while(stackIn.size() != 0){
                stackOut.push(stackIn.pop());
            }
        }
    }
    
    public int peek() {
        stackIn2Out();
        return stackOut.peek();
    }
    
    public boolean empty() {
        if(stackIn.size() == 0 && stackOut.size() == 0){
            return true;
        }
        return false;
    }
}

使用队列实现栈

题目：使用队列实现栈的下列操作：
push(x) – 元素 x 入栈
pop() – 移除栈顶元素
top() – 获取栈顶元素
empty() – 返回栈是否为空

思路：使用两个队列来实现栈，要始终保持一个队列是空的

class MyStack {

    Queue<Integer> queue1;
    Queue<Integer> queue2;

    public MyStack() {
        queue1 = new ArrayDeque<>();
        queue2 = new ArrayDeque<>();
    }
    
    public void push(int x) {
        if(queue1.size() != 0){
            queue1.add(x);
        }else{
            queue2.add(x);
        }
    }
    
    public int pop() {
        if(queue1.size() != 0){
            int size = queue1.size() - 1;
            while(size --> 0){
                queue2.add(queue1.poll());
            }
            return queue1.poll();
        }else{
            int size = queue2.size() - 1;
            while(size --> 0){
                queue1.add(queue2.poll());
            }
            return queue2.poll();
        }
    }
    
    public int top() {
        if(queue1.size() != 0){
            int size = queue1.size() - 1;
            while(size --> 0){
                queue2.add(queue1.poll());
            }
            int res = queue1.peek();
            queue2.add(queue1.poll());
            return res;
        }else{
            int size = queue2.size() - 1;
            while(size --> 0){
                queue1.add(queue2.poll());
            }
            int res = queue2.peek();
            queue1.add(queue2.poll());
            return res;
        }
    }
    
    public boolean empty() {
        if(queue1.size() == 0 && queue2.size() == 0){
            return true;
        }
        return false;
    }
}

思路：使用一个队列，入栈就直接入队，出栈的时候就先将队列的前面的所有元素在入队到队尾，只留下最后一个元素，然后我们就可以出队了。

class MyStack {

    Queue<Integer> queue;

    public MyStack() {
        queue = new ArrayDeque<>();
    }
    
    public void push(int x) {
        queue.add(x);
    }
    
    public int pop() {
        reInQueue();
        return queue.poll();
    }

    private void reInQueue(){
        int size = queue.size() - 1;
        while(size --> 0){
            push(queue.poll());
        }
    }
    
    public int top() {        
    	reInQueue();
        int res = queue.peek();
        push(queue.poll());
        return res;
    }
    
    public boolean empty() {
        if(queue.size() == 0){
            return true;
        }
        return false;
    }
}