目录
1. 循环队列也是一种数据结构。基于上述队列的缺点，此时就有了循环队列，如下图：
前言
队列是一种数据结构，在Java集合框架中，有对应的实现的接口，Queue是一个队列规范的接口，Deque是一个双端队列实现的接口，由于两个都是接口，所以是不能直接进行是实例化的，需要接口引用具体的类来进行实例化，所以底层可以是顺序表（数组），也可以是链表（单 / 双链表）。
一、普通队列
1. 概念
队列：只可以在一段进行插入操作，在另一端进行删除操作的线性表，队列具有先进先出的特性，在插入操作的一端称作队尾，进行删除操作的一端称作队头。
2. Queue（Java集合框架的接口）
如上图：Queue（队列）是一个接口，底层是一个双向链表来实现的，所以Queue不能直接实例化一个对象，只能是接口引用一个具体类（LinkedList）的方式来实例化。
3. Queue中的方法
| boolean offer（E e） | 入队列 |
| E poll（） | 出队列 |
| peek（） | 获取队头元素 |
| int size（） | 获取队列中的有效元素个数 |
| boolean isEmpty（） | 判断队列是否为空 |
4. 方法使用演示
public static void main(String[] args) {
//尾插法和头部删除
MyQueue queue = new MyQueue();
queue.offer(1);
queue.offer(2);
queue.offer(3);
System.out.println(queue.peek());//1
System.out.println(queue.poll());//1
System.out.println(queue.peek());//2
System.out.println(queue.isEmpty());//false
System.out.println(queue.usedSize);//3
}5. 队列的模拟实现
注：双向链表是最合适实现一个队列的，双向链表可以在尾部插入，也可以在尾部进行删除，因为每个节点都有前驱和后继节点，插入和删除的时间复杂度都是O（1），但是如果是单链表此时只能使用尾插法插入，使用头删法（在头部进行删除）时间复杂度才是O（1）.
//单链表实现一个队列
public class MyQueue {
static class Node {
public int val;
public Node next;
public Node(int val) {
this.val = val;
}
}
public Node head;
public Node last;
public int usedSize;
//入队
public void offer(int val) {
Node node = new Node(val);
if (head == null) {
head = node;
last = node;
}else {
last.next = node;
last = node;
}
usedSize++;
}
//出队
public int poll() {
if (isEmpty()) {
throw new EmptyException("队列是空的！");
}
int ret = head.val;
head = head.next;
if (head == null) {
last = null;//如果只有一个节点，那么last也要置空
}
usedSize--;
return ret;
}
//判断队列是否为空
public boolean isEmpty() {
return usedSize == 0;
}
//获取队列队顶元素
public int peek() {
if (isEmpty()) {
throw new EmptyException("队列是空的！");
}
return head.val;
}
//获取队列有效元素的个数
public int getUsedSize() {
return usedSize;
}
}6. 顺序普通队列的缺点：
如下图：此时一个数组实现的顺序队列正在一边入队元素，一边出队元素，如果队列中的元素满了，此时元素再进行出队，但是后边的元素是入不进来的，虽然前面的格子空出来了，但是此时元素只能从队尾进入，队头出，可以看出，此时的队列的利用效率不是很高。
二、循环队列
1. 循环队列也是一种数据结构。基于上述队列的缺点，此时就有了循环队列，如下图：
2. 是一个类似圆形的数组：
| 1. 有front指针和rear指针同时指向数组的0下标，入队元素就让rear指针往后走一个，之后出队元素时，就让front指针向后移动。 |
| 2. 当循环队列满了，此时rear指针可以往前走一步，到达0下标，然后继续入队元素。 |
3. 所以此时有两个问题：
| 1. 当队列满，如何让rear指针指向0下标？ |
| 2. 当队列满时，rear = front；当队列为空时，rear = front，所以如何判断队列的空和满？ |
1. 每次入队元素或者出队元素时，让 rear =（rear + 1）% queue.size()，front =（front + 1）% queue.size()，而不是简单的rear++，front++，所以就可以让rear下标和front下标在走到最后一个位置时，再往后走一步就又到了0下标的位置。
2. 通过浪费一个空间来区分队列的空和满，如果rear指针的下一个就是front（0下标），此时就认为队列为满，当rear = front时，此时队列为空。（或者使用usedSize来记录当前元素个数也可以）。
4. 循环队列的实现： （oj题链接：力扣）
package Review;
//循环队列底层就是一个数组
//浪费掉最后一个空间来表示队列是否是满的
//就是每次都让rear往后走一步，之后进行判断如果rear的下一个位置就是0下标
//此时队列就是满的，如果front == rear，此时队列是空的
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;
}
//2.入队元素，之后让rear引用往后走一步
elem[rear] = value;
rear = (rear + 1) % elem.length;
return true;
}
public boolean deQueue() {
if (isEmpty()) {
return false;
}
//front++;
front = (front + 1) % elem.length;
return true;
}
public int Front() {
if (isEmpty()) {
return -1;
}
return elem[front];
}
public int Rear() {
if (isEmpty()) return -1;
//return elem[rear - 1];
//此时还有一个问题需要注意，如果rear到了0下标，之后就数组越界了
//数组是没有-1下标的，
//也就是让rear返回数组的最后一个下标
int index = (rear == 0) ? elem.length - 1 : rear - 1;
return elem[index];
}
public boolean isFull() {
return (rear + 1) % elem.length == front;
}
public boolean isEmpty() {
return front == rear;
}
}三、双端队列（Deque）
1. 概念
双端队列就是可以在两端都可以入队，也可以出队的队列，元素可以从队头入队和出队，也可以从队尾出队和入队。
2. 双端队列的使用
（在实际使用中，Deque接口使用的是比较多的，栈和队列都可以使用该接口，这个接口中有栈的方法，也有队列的方法）
public static void main9(String[] args) {
//底层是一个双向链表
Deque<Integer> deque = new LinkedList<>();
//数组实现的双端队列：底层就是一个数组
Deque<Integer> deque1 = new ArrayDeque<>();
//顺序的双端队列也可以当作栈来使用
Deque<Integer> stack = new ArrayDeque<>();
stack.push(1);
stack.push(2);
stack.push(3);//顺序的双端队列（底层是用数组来实现的）也提供了栈的相关的方法
}
public static void main8(String[] args) {
//双端队列
Deque<Integer> deque = new LinkedList<>();
//普通队列
//Queue中既有offer方法，也有add方法，add在无法添加一个元素时，会抛出一个异常
//offer方法优于add方法，如果无法添加元素，offer方法不会抛出异常
Queue<Integer> queue = new LinkedList<>();
//链式栈 虽然是具体的类但是里面有栈的方法
//LinkedList类中的方法是最多的，因为它实现了很多接口，此时一定会重写接口中的方法
LinkedList<Integer> stack = new LinkedList<>();
//双向链表
List<Integer> list = new LinkedList<>();
//其他的都是使用接口来引用的：只有接口中的方法
}3. 面试题
| 1. 用栈实现一个队列 （oj链接：力扣） | 思路：用两个栈才能实现一个队列，因为栈是先进后出，队列是先进先出；此时需要把栈中的全部元素入栈到第二个栈中，此时的栈顶元素就是出队的元素。 |
| 2. 用队列实现一个栈 （oj链接：力扣） | 思路：两个队列实现一个栈，”入栈“开始入到第一个队列中，之后入队就入到不为空的队列中，”出栈“就出到另一个队列中，出size-1个元素，最后剩下的一个元素就是要出栈的元素。 |
两个队列实现一个栈：
import java.util.LinkedList;
import java.util.Queue;
class MyStack2 {
private Queue<Integer> qu1;
private Queue<Integer> qu2;
public MyStack2() {
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() {
if (empty()) {
return -1;
}
if (!qu1.isEmpty()){
//此时一定需要定义一个size来存放qu1的容量，如果直接将size
//写进for循环中，size一直在改变，就会导致循环的次数减少
int size = qu1.size();
for (int i = 0; i < size-1; i++) {
qu2.offer(qu1.poll());
}
return qu1.poll();
}else {
int size = qu2.size();
for (int i = 0; i < size-1; i++) {
qu1.offer(qu2.poll());
}
return qu2.poll();
}
}
public int top() {
if (empty()) return -1;
if (!qu1.isEmpty()){
//此时一定需要定义一个size来存放qu1的容量，如果直接将size
//写进for循环中，size一直在改变，就会导致循环的次数减少
int size = qu1.size();
int val = -1;
for (int i = 0; i < size; i++) {
val = qu1.poll();
qu2.offer(val);
}
return val;
}else {
int size = qu2.size();
int val = -1;
for (int i = 0; i < size; i++) {
val = qu2.poll();
qu1.offer(val);
}
return val;
}
}
public boolean empty() {
return qu1.isEmpty() && qu2.isEmpty();
}
}两个队列实现一个栈：
import java.util.Stack;
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;
if (stack2.isEmpty()) {
while (!stack1.isEmpty()) {
stack2.push(stack1.pop());
}
}
return stack2.pop();
}
public int peek() {
if (empty()) return -1;
if (stack2.isEmpty()) {
while (!stack1.isEmpty()) {
stack2.push(stack1.pop());
}
}
return stack2.peek();
}
public boolean empty() {
return stack1.isEmpty() && stack2.isEmpty();
}
}
1476
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
