一、背景
栈和队列是数据结构中最常用到的两种结构，有非常广泛的运用，该篇文章将通过动画的手段，展示栈和队列相互实现的底层原理，让我们真正搞懂栈和队列的特性。
二、概念
2.1 栈
栈[Stack]:是一种限定仅在表尾进行插入和删除操作的线性表；即后进先出（LIFO-last in first out），最后插入的元素最先出来
- 入栈（push）
- 出栈 (pop)
2.2 队列
队列[Queue]：是一种限定仅在表头进行删除操作，仅在表尾进行插入操作的线性表；即先进先出（FIFO-first in first out）:最先插入的元素最先出来。
- 入队(enqueue)
- 出队(dequeue)
三、栈和队列的相互实现
3.1 用队列实现栈
-
模拟入栈的实现原理
-- 栈的特性是新加入的元素出现在栈顶，保证后进先出。
-- 队列的特性为新加入的元素出现在队尾，队列的队尾元素最后出队。
-- 按以上两个前提，我们可以让队头至队尾前的其它所有元素依次出队再入队，直至在队尾新加入的元素被移到队头，也即实现了让新压入的元素保留在栈顶。
-
模拟出栈的实现原理
-- 由于在入栈时保证队列中新加入队尾的元素被移到了队头，出栈只需弹出队头元素即可。 -
完整代码实现
/**
* 用队列模拟实现栈
*
* @author zhuhuix
* @date 2020-06-09
*/
public class QueueImplStack {
// 定义队列
private Queue<Integer> queue;
public QueueImplStack() {
queue = new LinkedList();
}
// 入栈--在队尾加入元素后,让其他元素按顺序出队再入队，保持新加入的元素永远在队头
public void push(Integer e) {
queue.offer(e);
int size = queue.size();
int i = 0;
while (i < size - 1) {
queue.offer(queue.poll());
i++;
}
}
// 出栈--将队尾前的其它所有元素出队再入队，直至队尾元素移到队头
public Integer pop() {
return queue.poll();
}
// 查看栈顶元素--即队头元素
public Integer peek() {
return queue.peek();
}
// 是否为空
public boolean isEmpty() {
return queue.isEmpty();
}
public static void main(String[] args) {
QueueImplStack stack = new QueueImplStack();
stack.push(1);
System.out.println(stack.peek());
stack.push(2);
System.out.println(stack.peek());
stack.push(3);
System.out.println(stack.peek());
System.out.println("=============");
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.isEmpty());
}
}
3.2 用栈实现队列
- 模拟入队的实现原理
-- 队列的特性最新入队的元素需排在队尾，最先入队的元素排在队头，按队头到队尾的顺序依次出队。
-- 对应到栈的数据结构上，也即需将新加入的元素保留在栈顶，保证先进先出。
-- 按以上两个前提，需在存放数据的栈的基础上再增加一个辅助栈，在每次入队时，先将存放数据的栈弹入辅助栈，再把需加入的新元素压入数据栈底，最后把辅助栈中的元素弹出依次压入数据栈，这样保证了新加入的元素，沉在栈底。
- 模拟出队的实现原理
-- 由于在入队时，通过数据栈与辅助栈的交换，实现了后加入的元素沉在栈底，先进入的元素保留在栈顶，直接通过出栈弹出即可。- 完整代码实现
/**
* 用栈模拟实现队列
*
* @author zhuhuix
* @date 2020-06-09
*/
public class StackImplQueue {
// 数据栈
private Stack<Integer> stack;
// 辅助栈
private Stack<Integer> aux;
StackImplQueue() {
stack = new Stack<>();
aux = new Stack<>();
}
// 入队--通过数据栈与辅助栈相互交换，保证新加入的元素沉在数据栈底
public void enqueue(Integer e) {
while (!stack.isEmpty()) {
aux.push(stack.pop());
}
stack.push(e);
while(!aux.isEmpty()){
stack.push(aux.pop());
}
}
// 出队--弹出数据栈元素
public Integer dequeue(){
return stack.pop();
}
// 查看队头元素
public Integer peek(){
return stack.peek();
}
// 是否为空
public boolean isEmpty(){
return stack.isEmpty();
}
public static void main(String[] args) {
StackImplQueue queue = new StackImplQueue();
queue.enqueue(1);
System.out.println(queue.peek());
queue.enqueue(2);
System.out.println(queue.peek());
queue.enqueue(3);
System.out.println(queue.peek());
System.out.println("=============");
System.out.println(queue.dequeue());
System.out.println(queue.dequeue());
System.out.println(queue.dequeue());
}
}
四、总结
通过以上栈和队列相互交叉的实践，我们对栈和队列的重大特性有了深入了解：
- 栈和队列都是线性连续结构，增加和删除元素不会影响破此连续性
- 栈通过栈顶的操作实现元素的增加与删除，也即只能在一端进行操作
- 队列通过队尾增加元素，队头删除元素，也即可以在两端操作