代码随想录算法训练营第十天 | 栈与队列理论基础、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.用栈实现队列
考察对 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. 用队列实现栈
考察对 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();
}
}