栈和队列
数据结构
线性表:一次保存单个同类型元素,多个元素之间逻辑上连续
数组,链表,栈,队列,字符串(内部是char[])
栈和队列其实是操作受限
的线性表
数组,链表,既可以在头部插入和删除,也能在尾部插入和删除,甚至在任意位置都可以插入和删除
“栈和队列”只能在一端插入元素和删除元素
栈(LIFO: Last in First Out)
- 只能从一端插入元素,也只能从这一端取出元素(栈顶)类似水杯
将元素12345依次添加到栈中
最先添加的元素就在当前栈的最底端,最后添加的元素就在栈的最顶端
- 添加元素只能从栈顶添加
- 取出元素只能从栈顶取出
从栈中取出元素的顺序和栈中添加元素的顺序恰好相反
最后添加的元素最先取出 -> Last in First Out(LIFO)
栈的特点:先进后出,后进先出的线性表
添加元素和删除元素的一端称为栈顶,另一端称为栈底
栈的应用
- undo(撤销)操作
在任何一个编辑器中输错了一个内容使用ctrl + Z
就返回到了上一次输入的内容
在任何一个浏览器点击返回就能返回上一次浏览的网页
都是栈的应用
- 操作系统栈
程序在执行过程中,从A函数调用B函数,从B函数调用C函数,返回执行时如何得知从哪里开始继续执行呢,其实背后就是栈这个结构
出栈后弹出func();
从funB()
第二行开始执行,结束后funB()
出栈,funB()
弹出
funA()
第三行开始执行,结束后funA()
出栈,funA()
弹出
栈的实现
基于数组实现的栈 - 顺序栈
栈只能在栈顶插入元素,在栈顶删除元素的结构
数组末尾插入和删除元素,数组末尾就是此时的栈顶!
基于链表实现的栈 - 链式栈
栈的三个核心操作
push(E e)
:向栈中添加元素 -> 入栈,压栈
E pop()
:出栈操作,弹出栈顶元素
E peek()
:查看栈顶元素,但不出栈
public class StackTest {
public static void main(String[] args) {
MyStack<Integer> stack = new MyStack<>();
stack.push(1);
stack.push(3);
stack.push(5);
stack.push(7);
stack.push(9);
System.out.println(stack);
// 9
System.out.println(stack.pop());
System.out.println(stack);
}
}
//[1, 3, 5, 7, 9] top
//9
//[1, 3, 5, 7] top
队列(FIFO: First in First Out)
栈和队列是一码事,都是对只能在线性表的一端进行插入和删除
因此,栈和队列可以相互转换
队列:FIFO,先进先出的数据结构,元素从“队尾”添加到队列中,元素从“队首”出队列
push(E val)
:将元素入队
peek()
:查看队首元素
pop()
:弹出队首元素
现实生活中,各式各样的“排队”操作
同样的,队列也有基于数组实现的队列和基于链表实现的队列
顺序队列 链式队列
问:对于队列来说,是基于链表比较好还是基于数组?
出队操作只能在队列的头部进行,若采用数组的方案,每次出队一个元素就得搬移剩下的所有元素向前移动一个单位
此时采用链表的方案更加适合队列的结构
出队列:删除头节点
添加元素:在链表的尾部添加
队列和栈的区别
队列的子类比较多:除了普通队列,还有优先级队列,循环队列。
栈结构比较简单,就是基于动态数组实现的顺序栈
相对于栈来说,队列的实现子类是比较多的,比如普通FIFO队列,双端队列Deque,循环队列LoopQueue
,优先级队列 PriorityQueue
队列的三个核心操作
void offer(E val);// 入队操作
E poll();// 出队操作
E peek();// 查看队首元素
public interface Queue<E> {
// 入队操作
void offer(E val);
// 出队操作
E poll();
// 查看队首元素
E peek();
boolean isEmpty();
}
//此处非java.util.Queue而是自己写的Queue LinkedQueue也是自己写的
Queue<Integer> queue = new LinkedQueue<>();
queue.offer(1);
queue.offer(3);
queue.offer(5);
queue.offer(7);
queue.offer(9);
// front [1,3,5,7,9] tail
System.out.println(queue);
queue.poll();
// front [3,5,7,9] tail
System.out.println(queue);
用队列模拟一个栈
//java.util.Queen java.util.LinkedList
Queue<Integer> queue = new LinkedList<>();
queue.offer(1);
queue.offer(3);
queue.offer(5);
queue.offer(7);
queue.offer(9);
System.out.println(queue);
queue.poll();
System.out.println(queue);
//[1, 3, 5, 7, 9]
//[3, 5, 7, 9]
此处的Queue
为java.util.Queue
非自己写的
leetcode 栈实现队列
思路:s1永远是保存元素的栈
- 先将s1中的所有元素依次弹出放入s2
- 将新元素入s1 = 》此时这个新元素就变为了s1的栈底元素(队尾元素)
- 将s2中的元素再依次弹回来(先进先出)
循环队列:长度固定的数组
循环队列:基本都是使用长度固定的数组来实现,数组在实现队列时,若从数组头部删除元素,需要频繁地移动后面的元素,带来效率比较低
出队和入队操作:使用两个引用,一个head
,一个tail
,添加元素在数组尾部添加,删除元素只需要移动head引用指向的地址即可(逻辑删除)
操作系统的生产消费者模型,MySQL数据库
的InnoDB存储引擎
中的redo日志
都是采用循环队列的方式
循环队列就是使用长度固定的数组来实现,数组头部就是队首(head
),数组的尾部是队尾(tail
),数组[head..tail)
是循环队列的有效元素
head永远指向循环队列的第一个元素
tail永远指向循环队列有效元素的后一个位置
循环队列出队一个元素
-
循环队列在删除元素时,不需要进行数据的搬移
-
当有新的元素在添加时就会覆盖掉之前的元素
-
所谓的循环队列指的是当head或者tail引用走到数组末尾时,下一次再继续向后移动,其实返回数组的头部继续操作
问题:当数组为空和数组为满时 head == tail,如何区分两种情况?
我们在循环队列中,若tail+1 == head 就认为循环队列已满
- 在循环队列中浪费一个空间,判断队列是否已满(之后tail就不会等于head了,而是判断tail + 1和head是否相等)
- 若此时
(tail + 1) % n == head;
认为此时循环队列已满 head == tail
认为队列为空
但是head和tail的移动不能简单的+1
使用取模%
操作,取数组长度
tail = (tail + 1) % n
对数组长度取模的本质:head和tail走到数组最后一个索引位置时,下一次要返回数组头部,就必须使用+1对n取模
如:上图中tail = 4
,tail+1 = 5,而数组长度为5,对数组长度取模得0,得到head
双端队列:Deque -> Queue的子接口
这个队列
既可以从尾插,头出
也可以从头插,尾出
双端队列的一个常用子类就是LinkedList
Deque<Integer> stack = new LinkedList<>();
stack.push(1);
stack.push(3);
stack.push(5);
System.out.println(stack.pop());
-
入栈叫
push
-
入队列叫
offer
-
出栈叫
pop
-
出队列叫
poll
Deque<Integer> queue = new LinkedList<>();
queue.offer(1);
queue.offer(3);
queue.offer(5);
System.out.println(queue.poll());