文章目录
队列(Queue)
一、 概念
- 与栈相反,队列就像食堂排队买饭一样,排好队后,第一个来的人,先买饭,后来的人后买,依次从队尾排到队头,离开的时候,买好饭的人从队头离开
- 或者可以这么理解:队列就是挤牙膏,出去的都是前面的,后面的挤向前面
- 队列和栈一样,可以使用数组实现也可以使用链表实现
1.尾进头出
- 队列只能在一段进行插入数据,在另一端进行删除的特殊线性表。
- 尾进头出 :先进先出,后进后出。
- 插入的一端叫队尾,删除的一端叫队头。
二、模拟队列
1.单链表实现队列
普通单链表:
加last结点
- 入队列: 头插法 o(1)
- 出队列:删除链表中的最后一个结点 o(n)
- 用last记录尾结点来改进:
- 入队:从尾结点插入 o(1)
- 出队:从头结点删除 o(1)
局限:只能从尾部插入,头部删除,但是双链表没有限制
1.1 设置结点
public class MyQueue {//单链表实现队列
static class Node {
public int val;
public Node next;
public Node(int val) {
this.val = val;
}
}
public int usedSize;
public Node Last;
public Node Head;
设置头尾结点,使用大小
1.2 入队offer
public void offer(int val) {//入队
Node node = new Node(val);
if (Head == null) {//当头结点为空时
Head = node;
Last = node;
} else {
Last.next = node;//尾插
Last = node;//Last后移
}
usedSize++;
}
当头结点为空时,头尾结点都是node
否则进行尾插法,List结点后移
1.3出队 poll
public int poll() {//出队
if (empty()) {
return -1;
}
int val = Head.val;
Head = Head.next;
if (Head==null){
Last = null;//只剩一个结点
}
usedSize--;
return val;
}
1.判断是否为空
2.记录头结点的值
3.头结点后移一位,如果移位后的头结点为空,则Last也要置为空
4.返回记录的val
1.4 empty方法,peek方法,getUsedSize方法
public boolean empty() {
return usedSize == 0;
}
public int peek(){
if (empty()){
return -1;
}
return Head.val;
}
public int getUsedSize(){
return usedSize;
}
2.双链表实现队列
- 两端都可以出入,并且时间复杂度都是o(1)
-
2.1 创建结点
public class MyQueue1 {
public static class ListNode {
ListNode next;
ListNode prev;
int val;
public ListNode(int val) {
this.val = val;
}
}
ListNode head;
ListNode last;
int size = 0;
创建头尾结点,构造方法,长度大小
2.2 入队列
public void offer(int data) {
ListNode node = new ListNode(data);
if (head == null) {
head = node;
} else {
last.next = node;
node.prev = last;
}
last = node;
size++;
}
当头结点为空的时候,头尾结点都是node
不为空,在尾部插入,尾结点后移,长度加一
2.3 出队列
public int poll() {
int val = 0;
if (head == null) {
return -1;
} else if (head == last) {
val = head.val;
head = null;
last = null;
} else {
val = head.val;
head = head.next;
head.prev.next = null;
head.prev = null;
}
size--;
return val;
}
val记录要返回的值
如果头结点为空,不能删除,返回-1
只有一个结点,取出val,头尾结点置空
否则,删除头结点,返回头结点的值,长度减一;
当然,也可以头结点入队,尾结点出队
2.4 peek、size、isEmpty方法
public int peek() {
if (head == null) {
return -1;
}
return head.val;
}
public int size() {
return size;
}
public boolean isEmpty() {
return head == null;
}
同上
三、环形队列
1. 环形队列一般用数组实现
1.因为要循环的进入队列,我们把数组看成一个环形的结构
2.我们在进队时要考虑数组是否满了
2.判断数组是否满了的方法:
- 1.使用usedsize,每次进队出队改变usedsize的大小,当usedsize等于数组的长度时说明已经存满
- 2.使用标记,空的为false,判断要添加的位置是否为空,如果进队,标记为true,出队标记为false
- 3.牺牲一个空间,来表示已经存满,判断rear的下一个是不是front,是front证明满了
3.下标循环
- 牺牲一个空间,当rear的下一个是front时,来判断数组是否满了
- 如果此时头结点是元素出队,将89入队,此时rear应该移动到0下标,
- rear = (rear+1)%len :通过加一取余数组长度,完成数组索引的循环
- 当出队时,front从7下标移动到0小标:front = (front +1)%len
数组下标循环技巧
1.向后:下标 = (当前下标+要移动的距离)%数组长度
2.向前:小标 = (当前小标+数组长度-要移动的距离)%数组长度
4、双端队列(Deque)
双端队列:两端都能进出队列
deque 是 “double ended queue” 的简称
-
Deque是一个接口,使用时必须创建LinkedList对象
-
add和offer的区别:add在没有可用空间,无法插入元素时,会抛出一个异常
四、队列的使用
- Queue是一个接口,它的底层是通过链表实现的
- 方法:offer入队、poll出队、peek获取队头、size个数、isEmpty判断队列是否为空
public static void main(String[] args) {
Queue<Integer> queue = new LinkedList<>();
queue.offer(1);//相当于尾插法
queue.offer(2);
queue.offer(3);
queue.offer(4);
System.out.println(queue.isEmpty());
System.out.println(queue.size());
queue.poll();
System.out.println(queue.size());
System.out.println(queue);
}
public static void main(String[] args) {
Deque<Integer> deque = new LinkedList<>();双链表实现双端队列
Queue<Integer> queue = new LinkedList<>();双链表实现普通队列
LinkedList<Integer> stack = new LinkedList<>(); 链式栈
LinkedList<Integer> list = new LinkedList<>();当链表使用
都是通过创建LinkedList对象实现,只不过实现了不同的接口
Deque<Integer> deque1 = new ArrayDeque<>();底层由数组实现的双端队列
Deque<Integer> deque = new LinkedList<>();双链表实现双端队列
Deque<Integer> stack1 = new ArrayDeque<>(); 双端队列实现顺序栈
LinkedList<Integer> stack = new LinkedList<>(); 双链表实现链式栈
}
- Queue是个接口,在实例化时必须实例化LinkedList的对象,因为LinkedList实现了Queue接口。
- 都是通过创建LinkedList对象实现,只不过实现了不同的接口
- ArrayDeque,数组实现的双端队列
五、OJ题
1.设计循环队列
1.1 思路
- 1.环形队列底层通过数组实现,设置队头和队尾
- 2.因为要牺牲一个数组的空间,来判断是否队列满了,所以在生成数组时+1
- 3.判断数组是否为满:看rear的下一个是不是front
- 4.入队:如果队列满了,返回false,否则存进当前队尾下标,队尾通过公式以循环的方式移动一位
- 5.出队:队尾=队头,说明队列为空,不能出队,否则让队头通过公式以循环的方式移动一位
1.2 代码
class MyCircularQueue {
private int[] elem;
private int front;//队头
private int rear;//队尾
public MyCircularQueue(int k) {
this.elem = new int[k+1];
}
//入队
public boolean enQueue(int value) {
//1.检查队列是否已满
if (isFull()) {
return false;
} else {
elem[rear] = value;
rear = (1 + rear) % elem.length;
}
return true;
}
/**
* 出队
* @return
*/
public boolean deQueue() {
if (isEmpty()) {
return false;
} else {
front = (front + 1) % elem.length;
}
return true;
}
public int Front() {
if (isEmpty()){
return -1;
}
return elem[front];
}
public int Rear() {//获取队尾元素,rear前一个下标
if (isEmpty()){
return -1;
}
int index =(rear == 0)?elem.length-1:rear-1;//判断0->7的情况
return elem[index];
}
/**
* 判断是否为空
*
* @return
*/
public boolean isEmpty() {
return rear == front;
}
/**
* 判断队列是否为满
*
* @return
*/
public boolean isFull() {
//判断队尾的下一个是不是队头
return (rear + 1) % elem.length == front;
}
}
/**
* Your MyCircularQueue object will be instantiated and called as such:
* MyCircularQueue obj = new MyCircularQueue(k);
* boolean param_1 = obj.enQueue(value);
* boolean param_2 = obj.deQueue();
* int param_3 = obj.Front();
* int param_4 = obj.Rear();
* boolean param_5 = obj.isEmpty();
* boolean param_6 = obj.isFull();
*/
2.用队列实现栈
2.1 思路
- 栈是先进后出,队列是先进先出,一个队列无法实现,用两个队列实现
- 一个队列用来存储,一个队列为空
- 将size-1个数从不为空的队列取出,存到空队列中
- 原来队列中剩余的就相当于从栈中取出的,清空队列
- 存入的新队列的队尾,就相当于栈顶
- 如果继续从栈中出栈,再次size-1个数存进空队列
- 入栈:放进不为空的队列的队尾
2.2 图解
2.1 代码
class MyStack {
private Queue<Integer> qu1;
private Queue<Integer> qu2;
public MyStack() {
qu1 = new LinkedList<>();//初始化
qu2 = new LinkedList<>();
}
public void push(int x) {
if (!qu1.isEmpty()) {
qu1.offer(x);
} else if (!qu2.isEmpty()) {
qu2.offer(x);
} else {
qu1.offer(x);
}
}
public int pop() {
int data = 0;
if (empty()) {//两个队列都为空,当前栈为空,不能删元素
return -1;
}
if (!qu1.isEmpty()) {
int size = qu1.size();//size是不停变化的
for (int i = 0; i < size - 1; i++) {
int val = qu1.poll();
qu2.offer(val);
}
return qu1.poll();//返回剩余的值
} else {
int size = qu2.size();
for (int i = 0; i < size - 1; i++) {
int val = qu2.poll();
qu1.offer(val);
}
return qu2.poll();
}
}
public int top() {
if (empty()) {
return -1;
}
if (!qu1.isEmpty()) {
int val = -1;
int size = qu1.size();
for (int i = 0; i < size; i++) {
val = qu1.poll();
qu2.offer(val);
}
return val;
} else {
int val = -1;
int size = qu2.size();
for (int i = 0; i < size; i++) {
val = qu2.poll();
qu1.offer(val);
}
return val;
}
}
public boolean empty() {
return qu1.isEmpty() && qu2.isEmpty();
}
}
3.用栈实现队列
3.1 思路
- 一个栈实现不了,需要用两个栈实现队列
- 入队:存进第一个栈中
- 出队:如果第二个栈为空,将第一个栈的元素依次取出放进第二个栈,取出第二个栈的栈顶
- 如果第二个栈不为空,取出第二个栈的栈顶元素
3.2 图解
3.3 代码
class MyQueue2 {
private Stack<Integer> stack1;
private Stack<Integer> stack2;
public MyQueue2() {//初始化
stack1 =new Stack<>();
stack2 =new Stack<>();
}
public void push(int x) {
stack1.push(x);//直接压入第一个栈
}
public int pop() {
if (empty()){//判断两个栈是否都为空
return -1;
}
int val = -1;
if (stack2.isEmpty()){//第二个栈为空时,将第一个栈依次取出存进第二个栈
int size = stack1.size();
for (int i = 0; i < size; i++) {
val = stack1.pop();
stack2.push(val);
}
}
val = stack2.pop();//取出第二个栈的栈顶
return val;
}
public int peek() {//方法与pop一样,为简化写法、只是返回值不停
if (empty()){
return -1;
}
if (stack2.empty()){
while (!stack1.empty()){
stack2.push(stack1.pop());
}
}
return stack2.peek();
}
public boolean empty() {//返回两个栈都为空的情况
return stack2.isEmpty()&&stack1.isEmpty();
}
}