什么是队列
1、队列是一个有序列表，可以用数组或者链表实现
2、遵循先进先出的原则。即先存入队列的数据先取出，后存入的数据后取出
3、允许插入数据的一端称为队尾，允许取出数据的一端称为队头
用数组模拟队列
思想
1）队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如上图。
2）因为队列的输出输入是分别从前后两端来处理的，因此需要两个变量front和rear来分别记录队列前后两端的下标。front随数据的取出而改变，rear随数据的输入而改变。
3）做一个约定，front指向第一个数据的前一个位置，即在一个空队列中，front为-1；而rear指向最后一个数据所在的位置；front==rear时，说明队列为空，此时front和rear的值都为-1；若rear小于队列的最大下标maxSize-1，则可以将数据存入rear所指向的数组元素中，否则无法存入数据，当rear==maxSize-1时，说明队列已经填满数据。
代码实现
public class ArrayQueueDemo {
private int maxSize;
private int front;
private int rear;
private int[] arrayQueue;
public ArrayQueueDemo(int maxSize) {
this.maxSize=maxSize;
this.arrayQueue=new int[maxSize];
this.front=-1;
this.rear=-1;
}
public boolean isFull() {
return rear==maxSize-1;
}
public boolean isEmpty() {
return rear==front;
}
public void inQueue(int num) {
if(isFull()) {
System.out.println("队列满了");
return;
}
rear++;
arrayQueue[rear]=num;
}
public int outQueue() {
if(isEmpty()) {
throw new RuntimeException("队列为空，无法取出数据");
}
front++;
return arrayQueue[front];
}
public void showQueue() {
if(isEmpty()) {
System.out.println("队列为空，无法展示");
return;
}
for(int i=front+1;i<arrayQueue.length;i++) {
System.out.printf("arrayQueue[%d]=%d\n",i,arrayQueue[i]);
}
System.out.println();
}
public int showHead() {
if(isEmpty()) {
throw new RuntimeException("队列为空，无法展示");
}
return arrayQueue[front+1];
}
public static void main(String[]args) {
ArrayQueueDemo a=new ArrayQueueDemo(3);
char key=' ';
Scanner scanner=new Scanner(System.in);
boolean loop=true;
while(loop) {
System.out.println("s(show):展示整个队列");
System.out.println("i(in):向队列插入一个数据");
System.out.println("o(out):从队列中取出一个数据");
System.out.println("h(head):得到目前队列中的头的数据");
System.out.println("e(exit):退出");
key=scanner.next().charAt(0);
switch (key) {
case 's':
a.showQueue();
break;
case 'h':
try {
a.showHead();
}catch(Exception e){
System.out.println(e.getMessage());
}
break;
case 'i':
System.out.println("请输入要插入的数据");
int value=scanner.nextInt();
a.inQueue(value);
break;
case 'o':
try {
int data=a.outQueue();
System.out.printf("取出的数据是%d\n",data);
}catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'e':
scanner.close();
loop=false;
break;
default:
break;
}
}
System.out.println("退出");
}
}
运行结果
s(show):展示整个队列
i(in):向队列插入一个数据
o(out):从队列中取出一个数据
h(head):得到目前队列中的头的数据
e(exit):退出
i
请输入要插入的数据
1
s(show):展示整个队列
i(in):向队列插入一个数据
o(out):从队列中取出一个数据
h(head):得到目前队列中的头的数据
e(exit):退出
i
请输入要插入的数据
2
s(show):展示整个队列
i(in):向队列插入一个数据
o(out):从队列中取出一个数据
h(head):得到目前队列中的头的数据
e(exit):退出
i
请输入要插入的数据
3
s(show):展示整个队列
i(in):向队列插入一个数据
o(out):从队列中取出一个数据
h(head):得到目前队列中的头的数据
e(exit):退出
s
arrayQueue[0]=1
arrayQueue[1]=2
arrayQueue[2]=3
s(show):展示整个队列
i(in):向队列插入一个数据
o(out):从队列中取出一个数据
h(head):得到目前队列中的头的数据
e(exit):退出
o
取出的数据是1
s(show):展示整个队列
i(in):向队列插入一个数据
o(out):从队列中取出一个数据
h(head):得到目前队列中的头的数据
e(exit):退出
s
arrayQueue[1]=2
arrayQueue[2]=3
s(show):展示整个队列
i(in):向队列插入一个数据
o(out):从队列中取出一个数据
h(head):得到目前队列中的头的数据
e(exit):退出
h
2
s(show):展示整个队列
i(in):向队列插入一个数据
o(out):从队列中取出一个数据
h(head):得到目前队列中的头的数据
e(exit):退出
e
退出
数组模拟环形队列
思想
1）利用数组模拟队列，在插入数据又取出后，取出过数据的位置无法再利用，造成资源浪费。因此考虑用数组模拟环形队列，利用取模的方式将数组看成是环形的。
2）为了用数组模拟环形队列，front和rear变量的含义做一个调整：front指向队列的第一个元素，即front直接指向队头所在的位置；而rear指向队列的最后一个元素的后一个位置（该位置不存放数据，且动态变化），即rear指向队尾所在的位置的后一个位置；两者初始值都为0。
3）约定数组空出一个位置不用于插入数据，则一个环形队列最多能插入maxSize-1个数据。
根据约定和front和rear的变化，以一个大小为5的数组推为例推导环形队列的有效数据个数和队列满的判断条件。
maxSize=5 rear front 有效个数
maxSize=5 1 0 1
maxSize=5 2 0 2
maxSize=5 3 0 3
maxSize=5 4 1 3
maxSize=5 0 2 3
maxSize=5 4 0 4
maxSize=5 0 1 4
4）队列有效数据个数是(rear+maxSize-front)%maxSize
5）队列满时的条件是(rear+1)%maxSize==front，因为数组被看作是首尾相连的，所以rear和front的位置会因为数据的插入和取出而变化，因此需要
6)队列为空时的条件是rear==front
代码实现
public class Loop_ArrayQueueDemo {
private int maxSize;
private int front;
private int rear;
private int[] arrayQueue;
public Loop_ArrayQueueDemo(int maxSize) {
this.maxSize=maxSize;
this.arrayQueue=new int[maxSize];
this.front=0;
this.rear=0;
}
public boolean isFull() {
return (rear+1)%maxSize==front;
}
public boolean isEmpty() {
return rear==front;
}
public void inQueue(int num) {
if(isFull()) {
System.out.println("队列已满，无法插入数据");
return;
}
arrayQueue[rear]=num;//直接插入数据
rear=(rear+1)%maxSize;//rear后移一位，必须考虑取模
}
public int outQueue() {
if(isEmpty()) {
System.out.println("队列为空，无法读取数据");
}
int temp=arrayQueue[front];
arrayQueue[front]=0;
front=(front+1)%maxSize;
return temp;
}
public int size() {
return (rear+maxSize-front)%maxSize;
}
public void showQueue() {
if(isEmpty()) {
System.out.println("队列为空，无法展示");
return;
}
for(int i=front;i<front+size();i++) {//要从front所指向的位置开始遍历，遍历次数为有效数据的个数
System.out.printf("arrayQueue[%d]=%d\n",i%maxSize,arrayQueue[i%maxSize]);
//数组模拟环形队列，数组大小固定，所以通过i%maxSize来确定数据在环形队列中的位置
}
System.out.println();
}
public void showHead() {
if(isEmpty()) {
throw new RuntimeException("队列为空，无法展示");
}
System.out.println(arrayQueue[front]);
}
public static void main(String[] args) {
Loop_ArrayQueueDemo laq=new Loop_ArrayQueueDemo(5);
laq.inQueue(2);
laq.inQueue(1);
laq.inQueue(3);
laq.inQueue(6);
char key=' ';
Scanner scanner=new Scanner(System.in);
boolean loop=true;
while(loop) {
System.out.println("s(show):展示整个队列");
System.out.println("i(in):向队列插入一个数据");
System.out.println("o(out):从队列中取出一个数据");
System.out.println("h(head):得到目前队列中的头的数据");
System.out.println("e(exit):退出");
key=scanner.next().charAt(0);
switch (key) {
case 's':
laq.showQueue();
break;
case 'h':
try {
laq.showHead();
}catch(Exception e){
System.out.println(e.getMessage());
}
break;
case 'i':
System.out.println("请输入要插入的数据");
int value=scanner.nextInt();
laq.inQueue(value);
break;
case 'o':
try {
int data=laq.outQueue();
System.out.printf("取出的数据是%d\n",data);
}catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'e':
scanner.close();
loop=false;
break;
default:
break;
}
}
System.out.println("退出");
}
}
运行结果
展示队列
队列满的情况下插入数据
展示队头指向的数据
取出数据后再插入数据并展示
退出
扫一扫
472
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
