Java数据结构：使用数组模拟队列（队列与环形队列）

最新推荐文章于 2023-06-27 15:32:30 发布
最新推荐文章于 2023-06-27 15:32:30 发布
阅读量598 收藏 14
点赞数 20
分类专栏： Java数据结构 文章标签： java 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60353039/article/details/127428465
版权

在这里插入图片描述

文章目录

1 队列

1.1 何为队列及实现思路

何为队列？

  • 队列是一个有序列表，可以通过数组或者链表来实现；
  • 满足：先存入的数据先取出，后存入的数据后取出，即 先入先出。

实现思路：
在这里插入图片描述

  1. 队列本身是有序列表，可以使用数组进行模拟，上图所示，maxSize为队列的最大容量；
  2. 由于队列先入先出的特点，分别使用front和rear记录队列的队首与队尾，其中front指向队首的前一个位置，rear指向队尾（实际值）；
  3. 当入队操作完成时，则相应的rear要发生变化，如图（入队三个元素时），此时数组0、1、2索引都有值，rear指向队尾，即索引为2的位置；
  4. 取出队首元素时，由于front指向的是队尾的前一个元素，所以需要先让front自增1，而后再取值，即第一次取出时，front=0对应的为队首元素；
  5. 当front = rear时队列为空，当rear=maxSize-1，即队尾指向数组末尾，说明队列已满，在设计入队和出队方法时需要特别注意！

1.2 数组模拟队列ArrayQueue的实现

详细可见代码注释，ArrayQueue.java参考代码如下：

/**
 * 使用数组模拟队列 ArrayQueue类
 */
class ArrayQueue{
    private int maxSize; //数组的最大容量
    private int front; //队列头
    private int rear; //队列尾
    private int[] arr; //用于存放数据

    //创建队列的构造器
    public ArrayQueue(int arrMaxSize){
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = -1; //指向队列头的前一个位置
        rear = -1; //指向队列尾部，指向具体的数据
    }

    //判断队列是否已满
    public boolean isFull(){
        return rear == maxSize-1;
    }

    //判断队列是否为空
    public boolean isEmpty(){
        return rear==front;
    }

    //添加数据到队列
    public void addQueue(int item){
        //先判断队列是否满
        if (isFull()){
            System.out.println("队列已满,不能加入数据");
            return;
        }
        //添加操作
        arr[++rear] = item; //rear后移，加入元素item
    }

    //获取队列的数据
    public int getQueue(){
        //判断是否为空
        if (isEmpty()){
            throw new RuntimeException("当前队列为空");
        }
        return arr[++front];
    }

    //显示当前队列中的所有数据
    public void showQueue(){
        if (isEmpty()){
            System.out.println("当前队列为空");
        }
        for (int i = front+1; i <= rear; i++) {
            System.out.printf("arr[%d] = %d\n", i, arr[i]);
        }
    }

    //显示头数据
    public int peek(){
        if (isEmpty()){
            throw new RuntimeException("当前队列为空!");
        }
        return arr[front+1];
    }
}

1.3 测试队列ArrayQueueDemo测试类的实现

为了便于队列的测试，我们初始假定队列的最大元素数量为3，具体代码及结果如下：

import java.util.Scanner;

/**
 * @author 兴趣使然黄小黄
 * @version 1.0
 * 使用数组模拟队列
 */
public class ArrayQueueDemo {

    public static void main(String[] args) {
        //创建一个最大元素数量为3的队列
        ArrayQueue arrayQueue = new ArrayQueue(3);
        char key = ' '; //接收用户输入
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        //菜单
        while (loop){
            System.out.println("s: 显示队列");
            System.out.println("e: 退出程序");
            System.out.println("a: 添加数据到队列");
            System.out.println("p: 查看头数据");
            System.out.println("g: 从队列里取出数据");
            key = scanner.next().charAt(0);
            switch (key){
                case 's':
                    arrayQueue.showQueue();
                    break;
                case 'a':
                    System.out.print("请输入一个数字: ");
                    int item = scanner.nextInt();
                    arrayQueue.addQueue(item);
                    break;
                case 'g':
                    try {
                        int queue = arrayQueue.getQueue();
                        System.out.println("取出的数据是: " + queue);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    break;
                case 'p':
                    try {
                        int peek = arrayQueue.peek();
                        System.out.println("查看的数据是: " + peek);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("已退出程序");
    }
}

实现结果：

s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
a
请输入一个数字: 1
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
a
请输入一个数字: 3
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
a
请输入一个数字: 7
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
p
查看的数据是: 1
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
g
取出的数据是: 1
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
g
取出的数据是: 3
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
s
arr[2] = 7
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
e
已退出程序

Process finished with exit code 0

但是，经过笔者的反复测试，很快就发现了一个巨大的bug！
比如：先让三个数入队，即先将队列存满。然后，让三个元素出队。此时理论上队列应该为空，但是当我继续入队一个元素时，结果如下:
队列虽然为空，但是无法继续存储数据！
在这里插入图片描述

实际上，此时虽然满足front=rear，但队列的样子应该是这样的：
在这里插入图片描述
即 此时队列虽然看起来是满的，但是，实际没满， 相当于以这种方式实现队列属于一次性产品！因此，我们通过算法进行优化，引出 环形队列。

2 环形队列

2.1 环形队列简介及实现思路

由于之前的方式会出现队列为满实际未满的情况，为了实现使用数组模拟队列，我们可以通过对前面的数组模拟队列进行优化，充分利用数组，即 将数组看成一个环形的（主要通过取模的方式来实现）。

实现思路：

  1. front变量指向队首元素， 即arr[front]就是队列的第一个元素;

  2. rear变量指向队尾元素的后一个位置， 即arr[rear-1]为队尾元素。这么做的目的是为了空出一个空间，为了区分队列满和队列空的条件；

  3. 当队列满时：(rear+1)%maxSize = front。 在环形队列中，由于空出一个空间，则数组最多存放maxSize-1个元素，rear的最大值为maxSize-1;
    在这里插入图片描述

  4. 出队操作：(front+1)%maxSize = front，入队操作：(rear+1)%maxSize = rear；

  5. 当队列为空的时候：front = rear;
    在这里插入图片描述

  6. 队列中有效的数据个数为：(rear+maxSize-front)%maxSize。 也可以写成 abs(rear-front)%maxSize。

  • 当rear在front之后(这里指的是数组中索引位的前后，并非逻辑上的前后)，有效数据个数=rear-front=(rear+maxSize-front)%maxSize
  • 当rear在front之前(这里指的是数组中索引位的前后，并非逻辑上的前后)，有效数据个数=(rear+maxSize-front)%maxSize

环形队列的图片出自：@csdn-所遇皆惊喜：数据结构 - 队列 && 环形队列（循环队列）

2.2 数组模拟环形队列CircleArrayQueue的实现

详细可见代码注释，CircleArrayQueue.java参考代码如下：

/**
 * @author 兴趣使然黄小黄
 * @version 1.0
 * 数组模拟环形队列
 */
public class CircleArrayQueue {
    private int maxSize; //数组的最大容量
    private int front; //队列头
    private int rear; //队列尾后一个元素
    private int[] arr; //用于存放数据

    //创建队列的构造器
    public CircleArrayQueue(int arrMaxSize){
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = 0;
        rear = 0;
    }

    //判断队列是否已满
    public boolean isFull(){
        return (rear + 1) % maxSize == front;
    }

    //判断队列是否为空
    public boolean isEmpty(){
        return rear==front;
    }

    //添加数据到队列
    public void addQueue(int item){
        //先判断队列是否满
        if (isFull()){
            System.out.println("队列已满,不能加入数据");
            return;
        }
        //添加操作
        arr[rear] = item; //直接添加, 因为rear指向队尾后一个位置
        rear = (rear + 1) % maxSize; //rear后移
    }

    //获取队列的数据
    public int getQueue(){
        //判断是否为空
        if (isEmpty()){
            throw new RuntimeException("当前队列为空");
        }
        //1.先把front对应的值保存
        int value = arr[front];
        //2.front后移
        front = (front + 1) % maxSize;
        return value;
    }

    //返回有效数据的个数
    public int size(){
        return (rear + maxSize - front) % maxSize;
    }

    //显示当前队列中的所有数据
    public void showQueue(){
        if (isEmpty()){
            System.out.println("当前队列为空");
        }
        //注意取模
        for (int i = front; i < front + size(); i++) {
            System.out.printf("arr[%d] = %d\n", i % maxSize, arr[i%maxSize]);
        }
    }

    //显示头数据
    public int peek(){
        if (isEmpty()){
            throw new RuntimeException("当前队列为空!");
        }
        return arr[front];
    }
}

2.3 测试队列CircleArrayQueueDemo测试类的实现

为了便于队列的测试，我们还是初始假定队列的最大元素数量为3，具体代码及结果如下：

import java.util.Scanner;

/**
 * @author 兴趣使然黄小黄
 * @version 1.0
 * 测试环形队列
 */
public class CircleArrayQueueDemo {
    public static void main(String[] args) {
        //创建一个最大元素数量为3的队列
        CircleArrayQueue circleArrayQueue = new CircleArrayQueue(3);
        char key = ' '; //接收用户输入
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        //菜单
        while (loop){
            System.out.println("s: 显示队列");
            System.out.println("e: 退出程序");
            System.out.println("a: 添加数据到队列");
            System.out.println("p: 查看头数据");
            System.out.println("g: 从队列里取出数据");
            key = scanner.next().charAt(0);
            switch (key){
                case 's':
                    circleArrayQueue.showQueue();
                    break;
                case 'a':
                    System.out.print("请输入一个数字: ");
                    int item = scanner.nextInt();
                    circleArrayQueue.addQueue(item);
                    break;
                case 'g':
                    try {
                        int queue = circleArrayQueue.getQueue();
                        System.out.println("取出的数据是: " + queue);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    break;
                case 'p':
                    try {
                        int peek = circleArrayQueue.peek();
                        System.out.println("查看的数据是: " + peek);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("已退出程序");
    }
}

结果如下：

s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
a
请输入一个数字: 1
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
a
请输入一个数字: 2
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
a
请输入一个数字: 3
队列已满,不能加入数据
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
g
取出的数据是: 1
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
g
取出的数据是: 2
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
g
java.lang.RuntimeException: 当前队列为空
	at com.hxh.queue.CircleArrayQueue.getQueue(CircleArrayQueue.java:48)
	at com.hxh.queue.CircleArrayQueueDemo.main(CircleArrayQueueDemo.java:36)
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
a
请输入一个数字: 1
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
s
arr[2] = 1
s: 显示队列
e: 退出程序
a: 添加数据到队列
p: 查看头数据
g: 从队列里取出数据
e
已退出程序

Process finished with exit code 0

可见，最大有效数量由于一个置空位置，由3变成了2。当两个元素入队后，将两个元素出队，再次入队，可以成功入队。说明，将数组看成环形数组，通过取模运算可以解决之前的一次性使用的问题。

写在最后

 本文被 Java数据结构 收录点击订阅专栏 ， 持续更新中。
 创作不易，如果你有任何问题，欢迎私信，感谢您的支持！
在这里插入图片描述
在这里插入图片描述

兴趣使然黄小黄
关注
  • 20
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 15
    评论
专栏目录
Java数组模拟优先级队列数据结构的实例
09-02
主要介绍了Java数组模拟优先级队列数据结构的实例,优先级队列中的元素会被设置优先权,本文的例子借助了Java中的TreeSet和TreeMap,需要的朋友可以参考下
java数组实现队列及环形队列实现过程解析
08-25
主要介绍了java数组实现队列及环形队列实现过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
【数据结构】Java中队列的常用方法及模拟实现
A_K_L的博客
04-15 480
概述 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。队列具有先进先出FIFO(FirstIn First Out)的特性。 队尾：进行插入操作的端称为队尾 队头：进行删除操作的端称为队头 Queue 从上面类的继承关系图可以看到Queue是一个接口，它的内部主要定义了以下几个方...
JAVA实现数组模拟队列
qq_56627079的博客
12-01 796
使用数组模拟队列
java模拟实现队列（Queue）
weixin_48654011的博客
03-20 1208
目录 单链表实现队列（Queue） 数组实现循环队列（Queue） 622. 设计循环队列LeetCode题 单链表实现队列（Queue） /** * 单链表实现队列 */ class Node { int val; Node next; public Node(int val){ this.val = val; } } public class MyQueue { public Node front;//对头 public
LinkedList栈与队列
qq_46493545的博客
04-04 669
LinkedList集合的， LinkedList<String> stack =new LinkedList<>(); //压栈，入栈 // stack.addFirst("第一颗子弹"); // stack.addFirst("第二颗子弹"); // stack.addFirst("第三颗子弹"); //等同 stack.push("第一颗子弹"); stack.push
Java数组模拟队列
coderZ666的博客
06-09 406
队列是一种特殊的线性表，特点是先进先出。 和栈相似，它们的操作都是受限的。 队列的两种操作，插入一个数据称为入队，删除一个数据称为出队，并且只能从队尾插入数据，只能在队头删除数据。本文带大家在Java中用数组模拟实现一个队列...
【Java数据结构与算法】队列
01-20
文章目录队列队列介绍数组模拟队列思路代码实现问题分析并优化代码代码实现环形队列 队列 队列介绍 对应是一个有序列表，可以用数组或是链表来实现 遵循先入先出的原则，即：先存入队列的数据，要先取出，后存入的要...
Java数据结构与算法02——队列
12-21
标签：Java 数据结构 算法 作者 ： Maxchen 版本 ： V1.0.0 日期 ： 2020/3/29 目录1.队列的概念2.数组模拟队列3.队列运行测试 1.队列的概念 队列同样是一种特殊的线性表，其插入和删除的操作分别在表的两端进行，...
JAVA—通过数组模拟队列
最新发布
weixin_57654532的博客
06-27 288
4.数组用于存储数据。
基于java的模拟队列实现
01-06
这是模拟队列的实现，没有源码，源码在另外一个上传的文件中，基本实现了队列的各种操作。
java多线程模拟队列实现排队叫号
08-29
java多线程模拟队列实现排队叫号，多线程模拟排队叫号取号
JAVA 模拟队列的实现
01-06
这是一篇使用java模拟队列实现的程序的课程设计，包含了队列界面的设计以及队列数据结构的模拟实现，是java学习的很好的参照，另外，包含了部分的源代码，具体源代码在其它文件夹。
队列——顺序存储java实现
LX__Mr的博客
08-17 392
队列存储分为两种，顺序存储和链式存储，如果是使用顺序存储，一般就用到数组来进行存储，链式存储就需要用到链表； 队列顺序存储——数组； 实现代码如下： package com.queue; import java.util.Scanner; public class ArrayQueue { public static void main(String[] args) { //测试一下 //创建一个队列 ArrayQueue1 arrayQueue
Java数组模拟环形队列.
m0_74195366的博客
10-19 95
数组模拟环形队列
数组模拟环形队列
weixin_45713331的博客
08-07 197
数组模拟环形队列的添加 取出 得到头元素 输出全部的数据等等。
Java数据结构--队列 & 数组模拟队列
天行健 君子以自强不息，地势坤 君子以厚德载物。
07-04 236
1. 队列 1.1 队列的应用场景和介绍 1.1.1 队列的应用场景 在食堂打饭的时候就是队列，先去就先打到饭 1.1.2 队列的介绍 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在 表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操 作的端称为队尾，进行删除操作的端称为队头。 队列是一个有序列表，可以用数组或是链表来实现。 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 队列:先进先出( FIFO
Java实现队列
南瓜籽_的博客
11-12 1329
Java实现队列
Java实现循环队列
南瓜籽_的博客
11-17 358
Java实现循环队列
请给出使用java语言完成数组模拟环形队列
02-17
当然可以，以下是使用Java语言完成数组模拟环形队列的代码： ```java public class CircularQueue { private int[] data; // 用于存储队列元素的数组 private int head; // 队列头指针 private int tail; // ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

兴趣使然黄小黄

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值