数组模拟队列和数组模拟环形队列

最新推荐文章于 2024-11-12 21:14:07 发布
最新推荐文章于 2024-11-12 21:14:07 发布
阅读量464 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxy_c/article/details/121867177
版权

队列

队列介绍：
1、队列是一个有序列表，可以用数组或是链表来实现。
2、遵循先进先出的原则。即：先存入队列的数据，要先取出。后存入的数据，后取出

数组模拟队列示意图：
在这里插入图片描述

  • maxSize 是该队列的最大容量
  • 存入数据时从 尾节点存入，尾节点移动，头节点不动
  • 取出数据时从头节点取出，头节点移动，尾节点不动

加入数据的思路分析

当我们将数据存入队列时称为 ”addQueue“,addQueue 的处理需要有两个步骤
1、将尾指针往后移：rear+1,当front == rear 【队列为空】
2、若尾指针 rear 小于队列的最大下标 maxSize-1,则将数据存入所指的数组元素中，否则无法存入数据。 rear == maxsize -1 [队列满]

tip:数组模拟队列是从 0 开始, 第 一 个数据是放在第 0 的位置，第 二个数据是放在第 1 的位置,因此 队列最大值是 Maxsize - 1

代码实现：

package com.aiguigu.queue;

import java.util.Scanner;

public class ArrayQueueDemo {
    public static void main(String[] args) {
        ArrayQueue queue = new ArrayQueue(5);
        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(getQueue):从队列取出数据");
            System.out.println("h(head):显示队列头的数据");
            key = scanner.next().charAt(0);//接收一个字符

            switch (key){
                case 's'://显示数据
                     queue.showQueue();
                    break;
                case 'a'://添加数据
                    System.out.println("输入一个数");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g'://取出数据
                    try {
                        int res = queue.getQueue();
                        System.out.printf("取出的数据是%d\n",res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h'://查看队列头的数据
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列的头数据是%d\n",res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e'://退出
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }

        }
        System.out.println("程序退出");
    }

}

 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;//指向队列头部，front是指向队列头的前一个位置
        rear = -1; //指向队列尾部，指向队列的最后一个数据
    }

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

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

    //添加数据到队列
    public void addQueue(int n){
        //判断队列是否已满
        if(isFull()){
            System.out.println("队列已满，不能加入数据");
            return;
        }
        //添加数据到队列
        arr[++rear] = n;//让 rear 后移，在 rear 的位置插入数据
    }


    //获取队列的数据
    public int getQueue(){
        //判断队列是否为空
        if (isEmpty()){
            System.out.println("队列为空的，没有数据~~");
            throw new RuntimeException("队列空，不能取数据");//抛异常的效果和 return一样
        }
        front++;//front后移
        return arr[front];

    }


    public void showQueue(){
        //判断队列是否为空
        if (isEmpty()){
            System.out.println("队列为空的，没有数据~~");
            return;
        }
        //遍历
        for (int i = 0; i <arr.length ; i++) {
            System.out.printf("arr[%d]=%d\n",i,arr[i]);
        }
    }

    //显示队列的头数据，注意不是取数据
    public int headQueue(){
        //判断队列是否为空
        if (isEmpty()){
            System.out.println("队列为空的，没有数据~~");
            throw new RuntimeException("队列空，不能取数据");//抛异常的效果和 return一样
        }
        return arr[front + 1];
    }

}

运行效果：

s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
s
队列为空的，没有数据~~
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
a
输入一个数
2
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
s
arr[0]=2
arr[1]=0
arr[2]=0
arr[3]=0
arr[4]=0
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
a
输入一个数
3
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
a
输入一个数
4
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
s
arr[0]=2
arr[1]=3
arr[2]=4
arr[3]=0
arr[4]=0
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
a
输入一个数
5
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
a
输入一个数
6
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
s
arr[0]=2
arr[1]=3
arr[2]=4
arr[3]=5
arr[4]=6
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
a
输入一个数
1
队列已满，不能加入数据
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
h
队列的头数据是2
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
g
取出的数据是2
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
h
队列的头数据是3
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
g
取出的数据是3
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
g
取出的数据是4
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
g
取出的数据是5
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
g
取出的数据是6
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
g
队列为空的，没有数据~~
队列空，不能取数据
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
a
输入一个数
1
队列已满，不能加入数据
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
e
程序退出

Process finished with exit code 0

数组模拟队列存在的问题和优化

1、目前数组使用一次1就不能用，没有达到服用的效果
2、将这个数组使用算法，改进成一个环形的队列 取模：%

数组模拟环形队列

在这里插入图片描述
思路：
1、front 变量的含义做一个调整：front 就指向队列的第一个元素，就是说 arr[front] 是队列的第一个元素， front的初始值 = 0
2、rear 变量的含义做一个调整：rear 就指向队列的最后一个元素的后一个位置，因为希望空出一个空间作为约定， rear的初始值 = 0
3、当队列满时，条件是 （rear + 1 + maxSize）% maxSize = front
4、队列为空的条件，rear == front
5、队列有效的数据的个数 （rear+maxSize-front）% maxSize
6、我们就可以在原来的队列上修改得到，一个环形队列

个人理解：
当 rear 的上面那个位置是front 时 队列满 因此是 (rear+1 + maxsize)%maxsize = front
Rear – front 表示 它两节点中间还有几个元素，但是 rear 有可能跑到 front 前面 ，这样Rear – front 得到的值就是负数，但是元素个数不能是负数，因此加上maxsize 再对 maxsize 取模，这样既不影响 元素的真实个数 又能使 元素的真实个数一直为正数，
(Rear-front + maxsize)%maxsize

package com.aiguigu.queue;

import java.util.Scanner;

public class CircleAraayQueueDemo {
        public static void main(String[] args) {
            CircleArrayQueue circleQueue = new CircleArrayQueue(5);
            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(getQueue):从队列取出数据");
                System.out.println("h(head):显示队列头的数据");
                key = scanner.next().charAt(0);//接收一个字符

                switch (key){
                    case 's'://显示数据
                        circleQueue.showQueue();
                        break;
                    case 'a'://添加数据
                        System.out.println("输入一个数");
                        int value = scanner.nextInt();
                        circleQueue.addQueue(value);
                        break;
                    case 'g'://取出数据
                        try {
                            int res = circleQueue.getQueue();
                            System.out.printf("取出的数据是%d\n",res);
                        }catch (Exception e){
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'h'://查看队列头的数据
                        try {
                            int res = circleQueue.headQueue();
                            System.out.printf("队列的头数据是%d\n",res);
                        }catch (Exception e){
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'e'://退出
                        scanner.close();
                        loop = false;
                        break;
                    default:
                        break;
                }

            }
            System.out.println("程序退出");
        }
}

class CircleArrayQueue{

    private int maxSize;//表示数组的最大容量
    private int front;//队列头
    private int rear;//队列尾
    private int[] arr;//该数组用于存放数据，模拟队列

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

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

    //添加数据到队列
    public void addQueue(int n){
        //判断队列是否已满
        if(isFull()){
            System.out.println("队列已满，不能加入数据");
            return;
        }
        //添加数据到队列
        arr[rear] = n;//直接将数据加入
        rear = (rear+1)%maxSize;//将 rear后移，这里考虑到取模
    }

    //获取队列的数据
    public int getQueue(){
        //判断队列是否为空
        if (isEmpty()){
            System.out.println("队列为空的，没有数据~~");
            throw new RuntimeException("队列空，不能取数据");//抛异常的效果和 return一样
        }
        int value = arr[front];//先定义一个变量将数组的值存放再移动front
        front = (front+1)%maxSize;//front后移,考虑取模
        return value;
    }

    //显示队列信息
    public void showQueue(){
        //判断队列是否为空
        if (isEmpty()){
            System.out.println("队列为空的，没有数据~~");
            return;
        }
        //从 front开始遍历，变历 front +有效数据个数
        for (int i = front; i <front+size(); i++) {
            System.out.printf("arr[%d]=%d\n",i % maxSize,arr[i % maxSize]);
        }
    }

    //求出当前队列的有效个数
    public int size(){
        return (rear-front+maxSize) % maxSize;
    }

    //显示队列的头数据，注意不是取数据
    public int headQueue(){
        //判断队列是否为空
        if (isEmpty()){
            System.out.println("队列为空的，没有数据~~");
            throw new RuntimeException("队列空，不能取数据");//抛异常的效果和 return一样
        }
        return arr[front];
    }

}

运行结果：

s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
s
队列为空的，没有数据~~
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
a
输入一个数
10
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
a
输入一个数
20
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
a
输入一个数
30
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
a
输入一个数
40
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
s
arr[0]=10
arr[1]=20
arr[2]=30
arr[3]=40
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
a
输入一个数
50
队列已满，不能加入数据
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
h
队列的头数据是10
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
g
取出的数据是10
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
s
arr[1]=20
arr[2]=30
arr[3]=40
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(getQueue):从队列取出数据
h(head):显示队列头的数据
CXY_C
关注
专栏目录
Java数组模拟优先级队列数据结构的实例
09-02
`insert`方法用于向队列中添加元素，当队列未满时，元素会被添加到数组的下一个空位置，并且根据优先级重新排列数组中的所有元素。为了实现这个功能，`insert`方法包含了一个内部循环，比较新插入的元素与数组中现有...
数组模拟环形队列(思路分析) [数据结构与算法][Java]
m0_57001006的博客
07-31 508
我们从数组模拟环形队列实现中如果要进行出队列的操作,这个时候一定注意,因为我们出队列是从队列的头部位置开始出队列,那么我们在出队列的时候一定要用到一个"临时变量",使用这个临时变量先将我们当前的front指向的元素保存到这个临时变量中,然后再进行指针后移,然后我们再将临时变量中存储的队列中被删除的元素返回。对于之前我们讲过的非环形队列来讲我们的maxSize即使队列底层数组的最大容量,还是队列的长度,但是这里我们对于环形队列来讲数组的最大容量=队列容量+1。移动次数=间隔数+1;...
队列数组实现-环形队列
weixin_64650214的博客
12-26 213
队列-->数组实现
数组模拟环形队列
qq_61871695的博客
01-12 130
环形队列 是队列的一种改进，原来队列不能重复使用，出现溢出现象。 改进思路： front指向队列的第一个元素，初始值为0； rear指向队列最后一个元素的后一个位置（希望空出一个空间做约定），初始值为0； 当队列满时，条件是（rear+1）%maxsize==front; 当队列空时，条件是rear==front; 队列中有效数据为(rear+maxsize-front)%maxsize 改进的代码段： 注意： // 向对列中添加数据 public voi...
数据结构之数组环形队列(Java实现)
qq_27278865的博客
11-26 353
数组模拟队列时,会有不能复用的问题,这里使用环形队列来解决。 因为模拟的是环形队列,所以我们调整一下队列中各个属性的含义。 1.分析： 原来的非循环队列(非环形队列) ,在rear这个尾部指针到达rear==maxSize-1时,就不能再存放数据了,就算我们把数据给取出来,也只是在逻辑上把这个数据给取出来了,真实的情况是,这个数据取出来后,在队列中还有该数据,这个问题应该如何解决呢？答案是---环形队列。 所以我们要把这个队列给进行改进,把这个队列改成一个环形队列(循环队列),从而使该队列.
数组实现队列
09-13
由数组实现队列，包括队列的创建、入队和出队。通过打印显示出队的结果。正在学习数据结构的童鞋可以参考。
hb-zhyu的模拟队列
01-23
在这个问题中，我们被要求创建一个模拟队列，它需要支持四种基本操作：push、pop、empty 和 query。这是一个典型的基于数组的队列实现，适用于简单的线性数据结构。 ### 队列简介 队列是一种先进先出（FIFO, First ...
PHP使用数组实现队列
10-28
在PHP中，实现队列的功能通常会借助数组及其内置函数来模拟队列的基本行为。队列是一种先进先出（First In First Out, FIFO）的数据结构，类似于现实生活中的排队等候系统，如银行的排号机，最先排在队伍中的人会...
数组模拟环形队列重点总结
xinin919的博客
12-11 474
原因：我们用的rear=maxSize-1作为判断队满条件的缺陷，这种溢出不是真正的溢出，称为假溢出。②rear变量的含义变为队列最后一个元素的后一个位置，因为需要空出一个空间作为约定，初始值变为0；解决方案：将数组的前后端连接起来，形成一个环形的顺序表，即把存储队列元素的表从逻辑上看成一个环。⑤有效数据的个数为：(rear+maxSize-front)%maxSize;②队列为满的条件：(rear+1)%maxSize=front;这样一来，rear=4时，数据可以进入到下标为0的位置。
用数组模拟队列算法实现 模拟环形队列
qq_36273886的博客
08-05 123
问题引出： 银行收银员问题 思路分析 1.队列是先进先出的数据结构，所以需要两个指针，添加数据指针 rear，获取数据指针 front 2.需要创建一个数组，数组长度为maxsize 3.添加数据 rear上移，即rear+=1，获取数据 front指针上移 即front+=1 4.当rear和front相等时，数组为空，当rear = maxsize-1时，数组已满，禁止添加数据 5.将队列修改为环形队列，重点理清一个关系，即rear = front + maxsize时，数组已满 r..
（二）Java数据结构之基于数组实现的环形队列
baikunlong的博客
10-08 102
package top.baikunlong.queue; import java.util.Scanner; /** * @author baikunlong * @date 2020/10/7 11:53 */ public class ArrayQueue { private int maxSize;//最大容量，实际存储只有maxSize-1，有一个空间为预留空间。 private int front;//队头 private int rear;//队尾 .
数组模拟栈和队列（图解流程）
阿顾的博客
08-10 5059
  一 数组模拟栈 栈（stack），它是一种运算受限的线性表。这种限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底，向一个栈中插入新元素，我们一般称为入栈或者压栈，从一个栈中删除元素，我们一般称为弹栈或者出栈，即先进后出 入栈过程 首先声明一个固定大小的数组arr，并将索引index指向0位置，压入数据的时候，先给arr[index]赋值，再将inde...
数组模拟队列（queue）
jefferyfg的博客
09-24 1815
队列介绍 队列是一个有序列表，可以用数组或者链表实现 遵循先进先出的原则:先存入队列的数据，要先取出，后存入的数据，要后取出 使用数组模拟队列示意图 数组模拟队列思路： 队列本身是有序列表，如果使用数组的结构来存储队列的数据，则队列数组的声明如上图，maxSize是队列的最大容量。 因为队列的的输出、输入分别从前后端来处理，所以需要两个变量fornt个rear分别记录前后端的下标，fro...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 206
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
1112--接口
最新发布
kequanrrr的博客
11-12 225
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
JAVA-01-变量
LJH_laura_li的博客
11-08 482
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 320
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
Java数组与环形数组实现队列详解
"这篇教程详细解析了如何使用Java数组实现队列以及环形队列，提供了具体的示例代码，适合学习者参考学习。" 在Java编程中，队列是一种线性数据结构，遵循先进先出（FIFO）的原则。数组是实现队列的基本方式之一，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值