前言：
本篇博客实在上一篇队列基础上加强版，使数组空间能充分利用，建议先点击查看Java基础算法之------队列
环形队列
环形队列，故名思意，该数组队列的数据结构像一个圆环一样，圆环的特点，没有尾部，所以，只要队列的有效空间还有，那么我们就可以继续王队列里面添加数据，而我们上一篇的队列，则没有很好的利用数组的空间，会造成数据的假溢出现象（数组队列里面没有数据，但是我们还是无法添加数据）
画图解释如下：
//当我们在实例化对象时，自动帮我们初始化我们所需要的数据
//创建无参构造器
public CircleArrayQueue(){
//默认初始化大小
this.maxSize = 3;
//初始化容器
arr = new int[maxSize];
//队列头指针分析front是指向队列头的前一个指针，没去出一个数据向前移一位
front = 0;
//队列尾指针，指向队列尾，没添加一个数据，向前移一位
rear = 0;
}
//创建队列有参构造器
public CircleArrayQueue(int arrayMaxSize) {
this.maxSize = arrayMaxSize;
//初始化容器
arr = new int[maxSize];
//队列头指针分析front是指向队列头的前一个指针，没去出一个数据向前移一位
front = 0;
//队列尾指针，指向队列尾，没添加一个数据，向前移一位
rear = 0;
}
说明：
- maxSize：这个队列的大小
- arrayMaxSize：我们传的数组大小
- front：头指针，这个指针永远指向队列的头元素，初始值为 0
- rear：尾指针，这个指针指向队列的最后一个元素的后一个元素，初始值为 0 ，所以这个队列的可用大小 = size - 1
- arr：表示这个队列
队列中几种特殊状态的判断：
- 为空：当 rear = front 时，队列为空
- 为满：当 (rear + 1) % size = front 时，表示队列已满
- 添加数据：当添加数据的时候，rear 指针应该后移一位，所以 rear = (rear + 1) % size
- 取出数据：取出数据的时候，front 指针也应该后移一位，所以 front = (front + 1) % size
- 队列中的元素个数：队列中的元素个数 = (rear + size - front) % size
画图分析上面的公式：
代码分析如下：
判断队列是否为空
//判断队列是否为空
boolean isEmpty(){
return rear == front;
}
判断队列是否已满
//判断对列是否已满
boolean isFull(){
return (rear+1)%maxSize == front;
}
添加元素
//添加元素
void addQueue(int n){
if (isFull()) {
System.out.println("队列已满不能添加数据~~");
return;
}
arr[rear] = n;
//防止数组越界
rear = (rear + 1) % maxSize;
}
取出元素
//取出元素
int getQueue(){
if (isEmpty()) {
throw new RuntimeException("队列为空，无法继续取出数据");
}
//我们需要知道front下一次指向哪里
//所以我们需要将arr[front]的值先存到一个变量value中
//然后将front指针移动，最后将value返回
int value = arr[front];
front = (front + 1) % maxSize;
return value;
}
显示所有元素
//显示所有元素
void showQueue(){
if (isEmpty()) {
System.out.println("队列为空，无法展示全部数据");
return;
}
//遍历所有队列，我们需要考虑我们需要遍历的队列是哪个，
// 我们不能按照以前的方法遍历的原因是，我们不知道这个环形队列是在哪个区域，一旦我们的队列
//出现
// ---------------------------
// | | | | | |
// ---------------------------
// 0 1 2 3
// front指向4，rear指向0 这是我们按上面的方法遍历就会出现多打印0的现象
// 所以我们需要分析遍历的区间（长度）是多长，按上面的例子我们只需要打印1次
// 也就是说我们，的有效长度为1，我们自己可以看出来但是怎样用代码实现呢？
//我们学过数学知道我们可以将上面的图形进行转换，如下
// ------------------------------------------------
// | | | | | | | | | |
// ------------------------------------------------
// 0 1 2 3 4 0 1 2 3
// ▲ ▲
// front rear
// 所以我们的实际长度就是上面两个三角之间的长度，因为front是头指针，所以我们如果从
// front开始遍历，控制的大小应为，front+有效数据大小
//关于(rear+maxSize-front)%maxSize，我们在图中已经解释过了
// 也就是front+(rear+maxSize-front)%maxSize
// 所以代码如下：
for (int i = front; i < front+size(); i++) {
System.out.printf("arr[%d] = %d\n",i,arr[i]);
}
}
int size(){
return (rear + maxSize - front) % maxSize;
}
显示头数据
//显示头数据，注意不是取数据，仅仅是显示头数据
int headQueue(){
if (isEmpty()) {
throw new RuntimeException("队列为空，无法继续取出头数据");
}
//因为front直接指的就是头部
return arr[front];
}
显示尾数据
//显示尾数据
int rearQueue(){
if (isEmpty()) {
throw new RuntimeException("队列为空，无法继续取出尾数据");
}
//因为我们总是指向最后一位元素的后一位
return arr[rear-1];
}
源代码如下
package com.toulan.circlequeue;
import java.util.Scanner;
/**
* @author loltoulan
* @version 1.0.0
* @time 2020/3/31 19:05
* @message
*/
public class CircleQueue {
public static void main(String[] args) {
CircleArrayQueue queue = new CircleArrayQueue();
System.out.println(queue.getMaxSize());
char key = ' ';
Scanner scanner = new Scanner(System.in);
boolean loop = true;
while (loop) {
System.out.println("s(show) 显示队列");
System.out.println("e(exit) 退出程序");
System.out.println("a(add) 添加数据到队列");
System.out.println("g(get) 从队列中取出数据");
System.out.println("h(head) 查看队列头的数据");
System.out.println("r(rear) 查看队列尾的数据");
key = scanner.next().charAt(0);
switch (key){
case 's':
queue.showQueue();
break;
case 'e':
scanner.close();
loop = false;
break;
case 'a':
System.out.println("请输入一个数字:");
int value = scanner.nextInt();
queue.addQueue(value);
break;
case 'g':
try {
int result = queue.getQueue();
System.out.println("从队列中取出的数据是："+result);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'h':
try {
int result = queue.headQueue();
System.out.println("队列的头数据是："+result);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'r':
try {
int result = queue.rearQueue();
System.out.println("队列的尾数据是:" + result);
} catch (Exception e) {
System.out.println(e.getMessage());
}
default:
break;
}
}
}
}
class CircleArrayQueue{
//最大容量
private int maxSize;
//队列头，也可以看作头指针
private int front;
//队列尾，也可以看作尾指针
private int rear;
//该数组用于模拟队列，存储数据
private int[] arr;
public int getMaxSize() {
return maxSize;
}
public void setMaxSize(int maxSize) {
this.maxSize = maxSize;
}
public int getFront() {
return front;
}
public void setFront(int front) {
this.front = front;
}
public int getRear() {
return rear;
}
public void setRear(int rear) {
this.rear = rear;
}
CircleArrayQueue(){
//默认初始化大小
this.maxSize = 3;
//初始化容器
arr = new int[maxSize];
//队列头指针分析front是指向队列头的前一个指针，没去出一个数据向前移一位
front = 0;
//队列尾指针，指向队列尾，没添加一个数据，向前移一位
rear = 0;
}
//创建队列构造器
CircleArrayQueue(int arrayMaxSize) {
this.maxSize = arrayMaxSize;
//初始化容器
arr = new int[maxSize];
//队列头指针分析front是指向队列头的前一个指针，没去出一个数据向前移一位
front = 0;
//队列尾指针，指向队列尾，没添加一个数据，向前移一位
rear = 0;
}
//判断对列是否已满
boolean isFull(){
return (rear+1)%maxSize == front;
}
//判断队列是否为空
boolean isEmpty(){
return rear == front;
}
//添加元素
void addQueue(int n){
if (isFull()) {
System.out.println("队列已满不能添加数据~~");
return;
}
arr[rear] = n;
//防止数组越界
rear = (rear + 1) % maxSize;
}
//取出元素
int getQueue(){
if (isEmpty()) {
throw new RuntimeException("队列为空，无法继续取出数据");
}
//我们需要知道front下一次指向哪里
//所以我们需要将arr[front]的值先存到一个变量value中
//然后将front指针移动，最后将value返回
int value = arr[front];
front = (front + 1) % maxSize;
return value;
}
//显示所有元素
void showQueue(){
if (isEmpty()) {
System.out.println("队列为空，无法展示全部数据");
return;
}
//遍历所有队列，我们需要考虑我们需要遍历的队列是哪个，
// 我们不能按照以前的方法遍历的原因是，我们不知道这个环形队列是在哪个区域，一旦我们的队列
//出现
// ---------------------------
// | | | | | |
// ---------------------------
// 0 1 2 3
// front指向4，rear指向0 这是我们按上面的方法遍历就会出现多打印0的现象
// 所以我们需要分析遍历的区间（长度）是多长，按上面的例子我们只需要打印1次
// 也就是说我们，的有效长度为1，我们自己可以看出来但是怎样用代码实现呢？
//我们学过数学知道我们可以将上面的图形进行转换，如下
// ------------------------------------------------
// | | | | | | | | | |
// ------------------------------------------------
// 0 1 2 3 4 0 1 2 3
// ▲ ▲
// front rear
// 所以我们的实际长度就是上面两个三角之间的长度，因为front是头指针，所以我们如果从
// front开始遍历，控制的大小应为，front+有效数据大小
//关于(rear+maxSize-front)%maxSize，我们在图中已经解释过了
// 也就是front+(rear+maxSize-front)%maxSize
// 所以代码如下：
for (int i = front; i < front+size(); i++) {
System.out.printf("arr[%d] = %d\n",i,arr[i]);
}
}
int size(){
return (rear + maxSize - front) % maxSize;
}
//显示头数据，注意不是取数据，仅仅是显示头数据
int headQueue(){
if (isEmpty()) {
throw new RuntimeException("队列为空，无法继续取出头数据");
}
//因为front直接指的就是头部
return arr[front];
}
//显示尾数据
int rearQueue(){
if (isEmpty()) {
throw new RuntimeException("队列为空，无法继续取出尾数据");
}
//因为我们总是指向最后一位元素的后一位
return arr[rear-1];
}
}
扫一扫
185
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
