代码随想录算法训练营第十天 | LeetCode232.用栈实现队列、LeetCode225.用队列实现栈

LeetCode 232 用栈实现队列

题目链接：232.用栈实现队列

本题考查的是我们对栈和队列的掌握程度。

【解题思路】

用一个栈作为压入栈，在压入数据时只往这个栈中压入，记为stackPush；另一个栈只作为弹出栈，在弹出数据时只从这个栈弹出，记为stackPop。

【解题步骤】

1.push栈向pop栈倒入数据：

        判断Pop栈是否为空：如果为空，则向pop栈倒入数据，直到倒空为止；如果不为空，则结束。

2.向队列中添加元素：

        1）向push栈压入元素；

        2）将push栈的元素倒入pop栈。

3.队列出队：

        1）判断pop栈与push栈是否为空：如果为空，则弹出警告，队列为空；

        2）将push栈的元素倒入pop栈；

        3）返回并移除pop栈顶元素。

4.返回队列开头元素：

        1）判断pop栈与push栈是否为空，若为空，返回错误警告；

        2）将push栈的元素倒入pop栈；

        3）返回pop栈顶元素。

【代码部分】

java：

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() {
        if(empty()){
            throw new RuntimeException("Queue is empty!");
        }
        stackOut.push(stackIn.pop());
        return stackOut.pop();
    }
    
    public int peek() {
        if(empty()){
            throw new RuntimeException("Queue is empty!");
        }
        stackOut.push(stackIn.pop());
        return stackIn.peek();
    }
    
    public boolean empty() {
        if(stackIn.isEmpty() && stackOut.isEmpty()){
            return true;
        }else return false;
    }

    private void dumpstackIn(){
        if(!stackOut.isEmpty())return;
        while(!stackIn.isEmpty()){
            stackOut.push(stackIn.pop());
        }
    }
}

【疑难点】

1.如果stackPush要往stackPop中压入数据，那么必须一次性把stackPush中的数据全部压入。

2.如果stackPop不为空，stackPush绝对不能向stackPop中压入数据。

LeetCode 225 用队列实现栈

题目链接：225. 用队列实现栈

打开思路，本题并不一定需要两个队列来模拟栈，其实用一个队列就可以了。

【解题思路】

本题既可以用两个队列实现，也可以用一个队列实现：

方法一，用两个队列实现：
        队列一将除了最后进栈的一位元素之外的所有元素弹出，队列二把队列一弹出的元素进队记录下来，循环往复

方法二，用一个队列实现：
将队列里的元素依次弹出，每次弹出后重新进栈，直到当前队尾的元素到达队头。

【解题步骤】

方法一：

                1.构造函数：
                                        在函数前新建两个队列queue1与queue2，在函数里初始化这两个队列。

                 2.入栈操作：
                                        1）将要入栈元素放入辅助队列；
                                        2）循环将当前队列元素放入辅助队列；
                                        3）创建一个临时队列，辅助两个队列完成交换元素；
                                        4）两个队列交换元素，最后将元素全放入queue1中。

                3.出栈操作：
                                        因为在入栈时，queue1中的元素与栈中保持一致，所以接下来的操作只看queue1的即可。

                4.返回栈顶元素：
                                       返回queue1中的元素即可。

                5.判断当前栈是否为空：
                                        判断queue1中的元素是否为空即可。

方法二：

                1.创建一个新队列；

                2.构造函数：
                                初始化新队列。

                3.入栈操作：
                                直接将元素用queue.add()方法添加进队列。

                4.出栈操作：
                                1）调用第七步函数，将队列中的元素重新排列；        

                                2）调用queue.poll()方法，返回出队的值。

                5.返回栈顶元素：
                                1）调用第七步函数，将队列中的元素重新排列；
                                2）将队头元素出队，新建一个临时变量result接收出队元素；
                                3）为了不丢失这个“栈顶元素”，需要将队头元素重新用add方法入队；
                                4）返回result。

                6.判断当前栈是否为空：
                                判断队列是否为空即可。

                7.创建一个新函数，用来将队列调换位置，模拟栈：
                                1）新建一个size元素，用来记录queue的长度；
                                2）循环将队列里的元素出队再进队，，每次移动size减一，直到size小于1。

【代码部分】

java:

class MyStack {
        Queue<Integer> queue;

    public MyStack() {
        queue = new LinkedList<>();
    }
    
    public void push(int x) {
        queue.add(x);
    }
    
    public int pop() {
        rePosition();
        return queue.poll();
    }
    
    public int top() {
        rePosition();;
        int result = queue.poll();
        queue.add(result);
        return result;
    }
    
    public boolean empty() {
        return queue.isEmpty();
    }

    private void rePosition(){
        int size = queue.size();
        size --;
        while(size-- > 0){
            queue.add(queue.poll());
        }
    }
}