代码随想录算法训练营第十天 | 栈与队列理论基础、232.用栈实现队列、225. 用队列实现栈

代码随想录算法训练营第十天 | 栈与队列理论基础、232.用栈实现队列、225. 用队列实现栈

栈与队列理论基础

栈是先进后出，队列是先进先出，。如图所示：

1.Java中的栈

栈（Stack）是一种受限的线性数据结构，所谓受限是指栈只暴露栈顶和栈底的操作，其底层是由数组实现的。

（1）Java中栈的继承关系

从继承关系中可以看到 Stack 的基本方法与底层实现。由于 Vector 是动态数组接口，其底层的实现是数组，因此Stack的底层实现也是数组，且继承了 Vector 的公共方法。由于 Vector 类具有动态扩容和随机访问的特性，因此继承了 Vector 类的 Stack 也同样具有这些特性，这恰好违背了 Stack 数据结构的设计原理，正因为如此，Java 中的 Stack 一直被认为是糟糕的实现，官方也将 Stack 标志为“弃用”（deprecated）。
综上所述，导致 Stack 糟糕实现的原因是 Stack 与 Vector 类的关系出现了错误，不应该是继承关系（is-a），而应是组合关系（has-a）。

因此，官方推荐使用 Deque / dek / 接口来实现 Stack：

Deque<E> stack = new ArrayDeque<>();

虽然官方做出了推荐，但是仍然可以发现，Deque 实现的 Stack 实质是一个双端队列，可以在队列的两端实现插入和删除操作，仍然破坏力了封装性，并不安全。因此，在实际中更推荐再做一层封装，通过逻辑限定为只能一端操作插入和删除，形成一个真正的栈。

2.Java中的队列

（1）Java中的常见队列

① ArrayList：ArrayList 可以被用作队列，通过在列表末尾添加元素，并使用 remove(0) 方法从列表的开头删除元素。但是，由于在列表的开头删除元素会导致后续元素的移动，因此对于大量的插入和删除操作来说，ArrayList 的性能可能不是最佳选择。
② LinkedList：LinkedList 也可以用作队列。LinkedList 实现了 Queue 接口，可以使用 offer() 方法在队列的末尾添加元素，使用 poll() 方法从队列的开头删除并返回元素。LinkedList 对于插入和删除操作具有较好的性能，因为它使用了指针来链接元素，而不需要移动其他元素。
③ ArrayBlockingQueue：ArrayBlockingQueue 是一个有界阻塞队列，底层使用数组实现。它有一个固定的容量，并且在插入或删除元素时可能会阻塞线程，直到满足特定的条件。
④ LinkedBlockingQueue：LinkedBlockingQueue 是一个可选有界或无界的阻塞队列，底层使用链表实现。它具有类似于 ArrayBlockingQueue 的功能，但在内部实现上略有不同。
⑤ PriorityBlockingQueue：PriorityBlockingQueue 是一个支持优先级的无界阻塞队列。元素按照它们的优先级顺序被插入和删除。
⑥ ConcurrentLinkedQueue：ConcurrentLinkedQueue 是一个非阻塞无界队列，它适用于多线程环境。它使用链表实现，并且提供了高效的并发操作。

（2）Queue 接口分析

Queue 接口是 Java 集合框架中定义的一个接口，它代表了一个先进先出（FIFO）的队列。Queue 接口继承自 Collection 接口，它定义了一组方法来操作队列中的元素。下面是 Queue 接口的一些主要方法和特性的详细解释：
① 添加元素：
boolean add(E element): 将指定的元素添加到队列的末尾，如果成功则返回 true，如果队列已满则抛出异常。
boolean offer(E element): 将指定的元素添加到队列的末尾，如果成功则返回 true，如果队列已满则返回 false。

② 移除元素：
E remove(): 移除并返回队列头部的元素，如果队列为空则抛出异常。
E poll(): 移除并返回队列头部的元素，如果队列为空则返回 null。

③ 获取头部元素：
E element(): 获取队列头部的元素，但不移除它，如果队列为空则抛出异常。
E peek(): 获取队列头部的元素，但不移除它，如果队列为空则返回 null。

④ 队列大小：
int size(): 返回队列中的元素个数。
boolean isEmpty(): 判断队列是否为空。

232.用栈实现队列

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

考察对 Stack 的操作

思路：使用栈来模式队列的行为。如果仅仅用一个栈是不行的，所以需要两个栈：一个输入栈，一个输出栈。重点在于 pop() 操作。

class MyQueue {
    Stack<Integer> stackIn; // 负责进栈
    Stack<Integer> stackOut; // 负责出栈

	// 队列初始化
    public MyQueue() {
        stackIn = new Stack<>();
        stackOut = new Stack<>();
    }
    
    // 进队列
    public void push(int x) {
        stackIn.push(x);
    }
    
    // 出队列：若出栈非空，则直接 pop() 即可;否则应将进栈的所有元素转移至出栈，再 pop()。
    public int pop() {
        if (!stackOut.empty()) {
            return stackOut.pop();
        }
        while (!stackIn.empty()) {
            stackOut.push(stackIn.pop());
        }
        return stackOut.pop();
    }
    
    // 返回队列开头的元素：复用以上 pop() 函数，提高代码可读性；但最后记得将弹出的元素压回出栈。
    public int peek() {
        int first = this.pop();
        stackOut.push(first);
        return first;
    }
    
    // 判断队列是否为空：仅在入栈与出栈同时为空时返回 true。
    public boolean empty() {
        return stackIn.empty() && stackOut.empty();
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

225. 用队列实现栈

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

考察对 Queue 的操作（使用 LinkedList 实现）

思路：使用队列来模式栈的行为，与上一题不同，使用一个队列即可完成各种操作。重点同样在于 pop() 操作：一个队列在模拟栈弹出元素的时候只要将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部，此时再去弹出元素就是栈的顺序了。

class MyStack {
    Queue<Integer> queue;
    // 初始化
    public MyStack() {
        queue = new LinkedList<>();
    }
    // 进栈
    public void push(int x) {
        queue.add(x);
    }
    // 出栈：将队列中待弹出元素之前的各元素重新加入至队列，则下一个弹出的即为所求元素。
    public int pop() {
        int size = queue.size(); // 队列长度
        size--; // 待弹出元素之前的元素数量
        while (size-- > 0) {
            queue.add(queue.poll());
        }
        return queue.poll();
    }
    // 返回栈开头的元素：复用以上 pop() 函数，提高代码可读性；但最后记得将弹出的元素重新入队。
    public int top() {
        int temp = this.pop();
        queue.add(temp);
        return temp;
    }
    // 断栈是否为空：即判断队列是否为空
    public boolean empty() {
        return queue.isEmpty();
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

其他解法：

1.使用 ArrayDeque 实现。

class MyStack {
    // Deque 接口继承了 Queue 接口
    // 所以 Queue 中的 add、poll、peek等效于 Deque 中的 addLast、pollFirst、peekFirst
    Deque<Integer> que1;
    /** Initialize your data structure here. */
    public MyStack() {
        que1 = new ArrayDeque<>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        que1.addLast(x);
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        int size = que1.size();
        size--;
        // 将 que1 导入 que2 ，但留下最后一个值
        while (size-- > 0) {
            que1.addLast(que1.peekFirst());
            que1.pollFirst();
        }

        int res = que1.pollFirst();
        return res;
    }
    
    /** Get the top element. */
    public int top() {
        return que1.peekLast();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return que1.isEmpty();
    }
}

2.同样使用 LinkedList 实现。

class MyStack {

    Queue<Integer> queue;

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

    //每 offer 一个数（A）进来，都重新排列，把这个数（A）放到队列的队首
    public void push(int x) {
        queue.offer(x);
        int size = queue.size();
        //移动除了 A 的其它数
        while (size-- > 1)
            queue.offer(queue.poll());
    }

    public int pop() {
        return queue.poll();
    }

    public int top() {
        return queue.peek();
    }

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