Java数据结构——队列
Posted RAIN 7
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java数据结构——队列相关的知识，希望对你有一定的参考价值。
前言
最近博主在学习JavaWeb的过程中，讲到了具体线程的知识，在写生产与消费者模型的具体代码时，发现涉及到了循环队列的知识，于是打算再次复习一下循环队列的具体编写
我们先复习一下队列的相关知识
一、队列
1.概念
只允许在一端进行插入数据操作，在另一端进行删除操作的特殊线性表，队列具有先进先出的特点
进行插入操作的一端称为队尾（rear）
进行删除操作的一端称为队头（front）
2.Java当中的队列
我们来看一下Java集合当中的有关队列的相关接口和类
我们可以看到 Queue 队列这个接口 底层可以是链表或者 顺序表来实现的 ，而在Java当中队列使用双端队列来进行维护的，同时 Deque 双端队列 也继承了Queue 这个接口
3.实例化对象
我们要想实例化具体队列的对象，必须new 一个 LinkedList 这个类出来。
Queue<Integer> queue = new LinkedList<>();
Deque<Integer> deque = new LinkedList<>();
LinkedList<Integer> queue2 = new LinkedList<>();
4.双端队列 (Deque)
双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque 是 “double ended queue” 的简称。
那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。
5.队列的常用方法
Deque 我们一看就知道Deque双端队列的方法比 Queue的方法多，因为双端队列可以可以从队头出（pollFirst()）、队尾出（pollLast()）,还可以从队头入（offerFirst（））、队尾入（offerLast（））
大家光看可能不太熟悉，我带着大家一块写代码来使用队列的一些常见方法
创建一个实例化对象
Queue<Integer> queue = new LinkedList<>();
入队操作
Queue 这个接口中给我们提供了 offer() 这个方法来进行入队操作
给这个队列进行入队操作，添加一些元素（入队操作使用的是尾插法）
queue.offer(1);
queue.offer(2);
queue.offer(3);
queue.offer(4);
我们在队列中添加了四个元素，如下图所示
现在队头元素是1，我们使用peek方法查看一下队首元素
出队操作
Queue 这个接口给我们提供了 poll()方法,返回队首元素并删除
也提供了 peek()方法，返回队首元素不删除
queue.poll();
queue.poll();
我们将之前入队的元素进行出队两次，现在队首元素是3
查看一下
判断是否为空
Queue 提供了 isEmpty() 判断队列是否为空，返回值是 true 或 false
// 在进行两次出队操作，此时队列应该为空
queue.poll();
queue.poll();
System.out.println(queue.isEmpty());
运行结果
二、Java实现简单队列
队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。
在这里我们用 链表来实现 队列的内部常见方法
// 用单链表来实现简单的队列内部方法
// 先建立一个Node类，队列中的每个元素都相当于一个节点
class Node
public int val;
public Node next;
// 写一个这个类的构造方法
public Node(int val)
this.val = val;
public class MyQueue
// 我们想呀，一个队列肯定是有队头，也肯定有一个队尾的
// 所以定义 队头和队尾
private Node first ;
private Node last;
// 入队
// 入队这里要用到尾插法
public void offer(int val)
Node cur = new Node(val);
// 第一次插入时，我们要把头尾指针指向这个节点
if(this.first == null)
this.first = cur;
this.last = cur;
else
// 不是第一次插入，那么就用尾插法的思想进行插入元素
this.last.next =cur;
this.last = cur;
// 出队
public int poll()
if(isEmpty())
throw new UnsupportedOperationException("队列为空");
int ret = this.first.val;
this.first = this.first.next;
return ret;
// 得到队头元素但不删除
public int peek()
if(isEmpty())
throw new UnsupportedOperationException("队列为空");
int ret = this.first.val;
return ret;
// 队列是否为空
public boolean isEmpty()
if(this.first== null)
return true;
return false;
三、循环队列
实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。
环形队列通常使用数组实现
设计循环队列
我们就借助一道题来开启今天的设计循环队列吧…
这道题让我们来设计一个循环队列，并且把相关方法给实现
我们先来简单了解一下循环队列的结构
循环队列的底层其实是一个数组，为什么是循环呢？
就是我们来看
在这样的一个数组中，如果我们每一个格子都放满了，将队首元素出队，还想入一个元素，那么就从数组的0下标继续存储
这样的数组模型可能不太好理解，我们可以把这个数组看成环形的数组空间
front 是队首元素的下标
rear 是当前可存放元素的下标
当然我们能够想得到 入队出队的方式：
假如要入一个元素x,x 存放到 elem[rear],rear++;
假如要出一个元素x，直接 front++;
我们在这个环形的空间内不断入队出队，可以实现循环的效果
了解了循环队列的结构，那么随之而来的问题就很多了
第一个问题：front 和 rear 相遇之后到底是满还是空呢？
上图有两种情况，
第一种：当队列存满之后，front和rear就会相遇
第二种，当队列为空时，front 和rear 也会相遇
第二个问题：rear 每次存放完成之后，能不能进行 rear= rear+1？
在这种情况下，我们想想继续存入元素，那么 rear 如何从下标7 到下标1呢？
第三个问题： 每次出队操作时，能不能进行 front = front+1？
这种情况下，我们还想继续出队，可以 front = front+1 吗？
我们接下来逐一解决这些问题
首先第一个问题，
rear 是代表当前可以存放数组元素的下标
因为 front 、rear 相遇无法判断满还是空，所以我们干脆浪费一个数据元素的空间，最后一个空间不放元素，帮我们来判断是空还是满
我们现在想把 89 放到这个队列当中，但是每次放入元素时都要判断队列是否已经满了，那么此时我们看一下 rear下标的下一个 是不是 front，如果是的话就说明满了。
所以解决第一个问题是怎样解决的呢？
每次在放元素的时候都去判断当前rear 的下一个是不是 front，如果是就满了！！
第二、三问题怎么解决呢？
数组下标循环的小技巧
数组下标index 是 0、1、2、3、4、5、6、7
我们通过简单的运算就可以得到循环的下标
(index+1)% length
我们来试一试
当 index = 7 ，( index+1 )% length = 0
成功的实现了数组下标的循环操作
解决了这三个问题，我们来实现循环队列的具体方法
循环队列的具体实现
方法一
class MyCircularQueue
private int front;
private int rear;
private int[] elem;
public MyCircularQueue(int k)
// 构造方法
this.front = 0;
this.rear = 0; // 队首队尾下标都初始化为0
this.elem = new int[k]; // new 一个 k大小的数组
// 入队操作
public boolean enQueue(int value)
// 如果队列已经满了，那么入队失败
if(isFull()) return false;
// 往rear 下标存放元素，之后rear向后走一格
this.elem[this.rear] = value;
this.rear = (this.rear+1)%this.elem.length;
return true;
public boolean deQueue()
//出队操作
if(isEmpty())
// 如果队列为空，那么出队失败
return false;
this.front = (this.front+1)%this.elem.length;
return true;
public int Front()
// 得到队首元素
if(isEmpty())
// 如果队列为空，那么返回-1
return -1;
return this.elem[this.front];
public int Rear()
// 得到队尾元素
if(isEmpty())
// 如果队列为空，那么返回-1
return -1;
// 如果队列不为空，那么返回rear的前一格元素，注意rear==0的情况
//rear == 0 的这种情况，前一个是数组的最后一个下标
int index = (this.rear ==0)? this.elem.length-1: this.rear-1;
return this.elem[index];
public boolean isEmpty()
// 只要 rear 和 front 相遇时那么说明队列为空
if(this.rear==this.front)
return true;
return false;
public boolean isFull()
// 如果front的前一格是rear 的话，那么就说明队列是满的
// 注意千万不要直接 front-1==rear,如果front ==0 ，那么就无法判断了
// 一定要考虑 front == 0 的这种情况，前一个是数组的最后一个下标
int index = (this.front ==0)? this.elem.length-1: this.front-1;
if(index == rear)
return true;
return false;
我们将这个代码进行OJ测试，
我们发现并没有通过测试，我们通过输出来看一下原因：
为什么会出现这样的结果呢？
在构造函数时传入的参数是3，预期结果是能够入三个元素才满，但是我们定义的循环队列必然会浪费一个空间，所以只能存两个元素，插入第三个元素的时候就失败了。
这个问题很好解决，我们在构造函数这里定义数组的空间大上一格,new int[k+1]，这样这个队列中就可以插入k 个元素
public MyCircularQueue(int k)
// 构造方法
this.front = 0;
this.rear = 0; // 队首队尾下标都初始化为0
this.elem = new int[k+1]; // new 一个 k+1大小的数组
再来提交OJ测试
通过测试！！
方法二
当然了，还有另外一种不需要浪费数组空间的做法
设置一个size来记录 队列中元素的大小
入队时size++
出队时size–
当size==0 ，队列为空
当size == elem.length ，此时队列已满
按照这个思路我们有了另外一种写法
代码展示
class MyCircularQueue
private int front;
private int rear;
private int[] elem;
private int size;
public MyCircularQueue(int k)
this.front = 0;
this.rear = 0;
this.elem = new int[k];
this.size = 0;
// 入队操作
public boolean enQueue(int value)
// 如果队列已经满了，那么队列插入失败
if(isFull())
return false;
// 如果队列未满，那么插入到数组中
this.elem[this.rear] = value;
this.rear++;
if(rear>=this.elem.length)
rear = 0;
this.size++;
return true;
public boolean isFull()
if(this.size == this.elem.length)
return true;
return false;
public boolean deQueue()
//出队操作
if(isEmpty())
// 如果队列为空，那么出队失败
return false;
front++;
if(front>=this.elem.length)
front = 0;
this.size--;
return true;
public boolean isEmpty()
if(this.size==0)
return true;
return false;
public int Front()
// 得到队首元素
if(isEmpty())
// 如果队列为空，那么返回-1
return -1;
return this.elem[this.front];
public int Rear()
// 得到队尾元素
if(isEmpty())
// 如果队列为空，那么返回-1
return -1;
// 如果队列不为空，那么返回rear的前一格元素，注意rear==0的情况
//rear == 0 的这种情况，前一个是数组的最后一个下标
int index = 0;
if(this.rear == 0)
index = this.elem.length-1;
else
index = rear-1;
return this.elem[index];
OJ测试结果：
通过测试！！
好了，这一节我们主要复习了队列的相关知识，了解了循环队列如何具体实现，如果感兴趣的同学可以自己实现一下双端队列的具体代码，希望大家多多练习！！
谢谢欣赏！
以上是关于Java数据结构——队列的主要内容，如果未能解决你的问题，请参考以下文章