2. 数组模拟队列，以及环形队列

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

1. 使用数组模拟队列，编写一个ArrayQueue类

  • 注意事项:
  1. front和rear的初始值都是-1
  2. 从队尾插入一个数据rear+1
  3. 从队头取出一个数据front+1
  4. 队满 rear == maxSzie-1
  5. 队空 front == rear

//使用数组模拟队列，编写一个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;  //指向队列的头部，分析出这个front是指向队列头的前一个位置
        rear = -1;   //指向队列的尾部，指向队列尾的数据（即就是队列的最后一个数据）

    }

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

    //判断队列是否为空
    public boolean isEmpty(){
        return front == rear;    //如果rear等于front我们认为队列是空的
    }

    //添加数据到队列,入队列
    public void addQueue(int n){
        //判断队列是否满
        if (isFull()){
            System.out.println("队列满，无法加入数据");
            return;
        }
        rear++;  //让rear后移，说明添加了一个数据
        arr[rear] = n;

    }

    //获取队列的数据，出队列
    public int getQueue(){
        //判断队列是否空
        if (isEmpty()){
            //通过抛出异常来处理
            throw new RuntimeException("队列空，不能取数据");

        }

        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()){
            throw new RuntimeException("队列是空的，没有数据");
        }
        return arr[front+1];
    }


}

2. 使用队列

  • 注意事项
  1. Scanner scanner = new Scanner(System.in) 可以实现键盘输入
  2. scanner.next().charAt(0); 接收一个字符
  3. int value = scanner.nextInt(); 获取输入的数字
  4. scanner.close(); 关闭scan
public class ArrayQueueDemo {

    public static void main(String[] args) {
        //测试一下
        //创建一个队列
        ArrayQueue arrayQueue = new ArrayQueue(3);
        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):查看队列头的数据");
            key = scanner.next().charAt(0);//接收一个字符
            switch (key){
                case 's':
                    arrayQueue.showQueue();
                    break;
                case 'a':
                    System.out.println("输入一个数");
                    int value = scanner.nextInt();
                    arrayQueue.addQueue(value);
                    break;
                case 'g':   //取出数据
                    try {
                        int res = arrayQueue.getQueue();
                        System.out.printf("取出的数据是%d\n",res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':  //查看队列头的数据
                    try {
                        int res = arrayQueue.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("程序退出");

    }

}

在这里插入图片描述
1. 但是这种队列有一个缺点，无法循环使用，当我把队列里面的数据全部取出来之后，无法再次插入
2. 因为我们对数组是否装满的判断是rear等于maxSzie-1
3. 所以我们为了解决这种问题，需要使用到环形队列

在这里插入图片描述

3.创建一个环形队列

  • 注意事项
  1. front和rear的初始值都是0
  2. 队满 (rear+1)%maxSize==front
  3. 队空 front == rear
  4. 加入一个数
        //直接将数据加入
        arr[rear] = n;
        //将rear后移，这里必须考虑取模,这个就是模拟环形队列的主要思想
        rear = (rear+1)%maxSize;
  1. 取出一个数
        int value = arr[front];   
        front = (front+1)%maxSize;
        return value;
  1. 遍历一遍所有的数据
    //显示队列的所有数据
    public void showQueue(){
        //遍历
        if(isEmpty()){
            System.out.println("队列是空的，没有数据");
            return;
        }
        // 思路：从front开始遍历，遍历多少个元素
        //
        for (int i = front; i < front + size(); i++) {
            System.out.printf("arr[%d]=%d\n",i%maxSize,arr[i%maxSize]);
        }
    }


    //求出当前队列的有效数据的个数
    public int size(){
        //rear = 2    1
        //front = 1    0
        //maxSize = 3    3

        return (rear+maxSize-front)%maxSize;
    }

举个例子：

  • 现在队列是空的，插入一个数字5， 那么arr[0] == 5 ,rear = [0+1] % 3 =1
  • rear确实向后移动了一位
  • 那么现在在删除数字5，那么 value = arr[0] , front = [0+1]%3 = 1
  • front也向后移动了一位
  • 以上是说明一直在加，无论是存数据，还是取数据rear和front都是在增加

例子2：

  1. 这个时候我连续插入3个数据，并取出一个数据，那么rear现在等于0 ，front现在等于1
  2. 那么如果是普通队列，就无法再插入数据了，因为我的rear 已经大于 maxSize-1 了
  3. 但是我使用了环形队列，我现在再次插入一个数据5
  4. 那么arr[0] == 5 ,rear = [0+1] % 3 =1
  5. 这就模拟了环形队列
  6. 当我再次取出2个数据，那么front 也等于0了，这里也实现了循环
//使用数组模拟循环队列，编写一个ArrayQueue类
class ArrayQueue2{

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


    //创建队列的构造器
    public ArrayQueue2(int arrMaxSize){

        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = 0;
        rear = 0;

    }

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

    //判断队列是否为空
    public boolean isEmpty(){
        return front == rear;    //如果rear等于front我们认为队列是空的
    }

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

    }

    //获取队列的数据，出队列
    public int getQueue(){
        //判断队列是否空
        if (isEmpty()){
            //通过抛出异常来处理
            throw new RuntimeException("队列空，不能取数据");

        }

        //这里需要分析front是指向队列的第一个元素
        //1.先把front 对应的值保留到一个临时的变量
        //2.将front后移 考虑取模
        //3.将临时保存的变量返回
        int value = arr[front];
        front = (front+1)%maxSize;
        return value;
    }


    //显示队列的所有数据
    public void showQueue(){
        //遍历
        if(isEmpty()){
            System.out.println("队列是空的，没有数据");
            return;
        }
        // 思路：从front开始遍历，遍历多少个元素
        //
        for (int i = front; i < front + size(); i++) {
            System.out.printf("arr[%d]=%d\n",i%maxSize,arr[i%maxSize]);
        }
    }


    //求出当前队列的有效数据的个数
    public int size(){
        //rear = 2    1
        //front = 1    0
        //maxSize = 3    3

        return (rear+maxSize-front)%maxSize;
    }


    //显示队列的头数据，注意不是取出数据
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列是空的，没有数据");
        }
        return arr[front];
    }


}

4. 使用环形队列

public class ArrayQueueDemo2 {

    public static void main(String[] args) {
        //测试一下
        //创建一个队列
        ArrayQueue2 arrayQueue = new ArrayQueue2(4);
        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):查看队列头的数据");
            key = scanner.next().charAt(0);//接收一个字符
            switch (key){
                case 's':
                    arrayQueue.showQueue();
                    break;
                case 'a':
                    System.out.println("输入一个数");
                    int value = scanner.nextInt();
                    arrayQueue.addQueue(value);
                    break;
                case 'g':   //取出数据
                    try {
                        int res = arrayQueue.getQueue();
                        System.out.printf("取出的数据是%d\n",res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':  //查看队列头的数据
                    try {
                        int res = arrayQueue.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("程序退出");

    }

}
乖乖虎学Java
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java数组实现队列及环形队列实现过程解析
08-25
本文详细介绍了Java数组实现队列及环形队列的实现过程，通过ArrayQueue类和ArrayQueueDemo类的实现，演示了如何使用数组来模拟队列的实现。这种实现方式可以满足高性能和低内存占用的需求，是一种常用的解决方案。
Java实现顺序队列
qq_44717657的博客
03-27 1585
Java简单实现队列，出队 入队 置空 判空等操作
队列——顺序存储java实现
LX__Mr的博客
08-17 403
队列存储分为两种，顺序存储和链式存储，如果是使用顺序存储，一般就用到数组来进行存储，链式存储就需要用到链表； 队列顺序存储——数组； 实现代码如下： package com.queue; import java.util.Scanner; public class ArrayQueue { public static void main(String[] args) { //测试一下 //创建一个队列 ArrayQueue1 arrayQueue
【数据结构】—— 队列基础知识以及数组模拟队列的分析、演示及优化_arr 队列(1)
2401_84183545的博客
05-11 295
1）队列是一个有序列表，可以用数组或是链表来实现2）遵循先入先出的原则。即先存入队列的数据要先取出，后存入队列的数据要后取出。（加数据是在队列的尾部加，取数据是在队列的首部取）
java接口实现队列的顺序_java实现BlockingQueue接口的队列解析
weixin_42696271的博客
02-13 441
java实现BlockingQueue接口的队列解析java实现BlockingQueue接口的队列解析一jdk中的阻塞队列概况二阻塞队列与非阻塞队列中的方法对比非阻塞队列常用方法阻塞队列常用方法 三各阻塞队列实现原理ArrayBlockingQueueLinkerBlockingQueuePriorityBlockingQueueDelayQueueSynchronousQueueDelayed...
队列——Java语言实现
K 的小想法
07-24 228
队列 队列是一个有序列表，可以用数组或者链表来实现。 队列遵循先入先出的原则，即：先存入队列的数据先取出，后存入的后取出。 例：用数组实现一个队列 public class ArrQueueDemo { public static void main(String[] args) { //测试 //创建一个队列 ArrayQueue queue = new ArrayQu...
java 顺序队列_java队列实现方法(顺序队列,链式队列,循环队列)
weixin_29334463的博客
02-21 208
双向顺序队列ArrayDeque和双向链式队列LinkedList，JDK已经包含，在此略。ArrayDeque包括顺序栈和顺序队列，LinkedList包含链式栈和链式队列。ArrayDeque和LinkedList都是线程不安全的。PriorityQueue优先队列也在JDK。1.顺序队列的实现package lang;import java.io.Serializable;import ja...
windows环形队列.zip
01-18
其中，C++可以利用STL库中的`deque`容器模拟环形队列，或者直接操作固定大小的数组。C#则可以使用`System.Collections.Generic.Queue<T>`类，通过自定义索引来实现环形特性。 4. **线程安全与同步** 在多线程环境...
什么是环形数组以及学习环形数组的意义是什么
最新发布
05-13
2. **提高性能**：环形数组的插入和删除操作的时间复杂度为 O(1)，这使得它在实现队列等数据结构时表现出色。高效的性能意味着可以更快地处理数据，对于实时应用尤为重要。 3. **简化逻辑**：使用环形数组可以简化...
易语言-易语言数组实现环形队列、栈等
06-25
在易语言中，我们可以通过数组模拟环形队列的实现： 1. **初始化**：首先定义一个固定大小的数组作为环形队列的存储空间，然后设定队列的头指针和尾指针，通常初始值为0。 2. **入队操作**（Enqueue）：当队列未满...
C语言实现使用静态数组实现循环队列源码.zip
11-13
在循环队列中，数组用于模拟环形结构。 2. **指针和指针运算**：队头和队尾的指针在数组中移动，理解指针的加减运算对于实现循环队列至关重要。 3. **条件判断**：在队列操作中，需要检查队列是否为空和是否已满，...
java实现顺序队列
初心不忘、始终方得
05-12 2467
使用java语言实现顺序队列
数组模拟环形队列
u013926385的博客
07-03 544
数组模拟环形队列
环形队列学习（以数组模拟）
weixin_57214688的博客
05-11 366
什么？环形队列也不难呀
数组模拟(环形)队列
s19862388581的博客
12-06 609
一. 队列介绍 队列是一个有序列表，可以用数组或是链表来实现。 队列遵循先入先出的原则。即：先存入队列的数据要先取出，后存入的数据要后取出。 二. 数组模拟队列思路 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图，其中maxSize是该队列的最大容量。 因为队列的输出、输入时分别从前后端来处理，因此需要两个变量front和rear分别记录队列前后端的下标，front会随着数据输出而改变，而rear则是随着数据输入而改变，如图所示： 当我们将数据存入队列时称为“addQu
数组模拟环形队列实现
java123456111的博客
09-05 281
1、因为队列的输入、输出是分别从前后端来处理，因此需要两个变量front和rear分别记录队列前后端的下标，front会随着数据输入而改变，而rear则是随着数据的输入而改变。2）若尾指针rear小于队列的最大下标 maxSize - 1,则表示队列未满，则可以将数据存放到队列中，否则无法存入数据。1）当front == rear，表示队列为空，将尾部指针往后移动一位，即rear+1。取数据的时候是从队列的头部取，rear值不变，front值依次递减。，即：先存入队列的数据，要先取出，后存入的要后取出。
数组模拟实现环形队列
weixin_73869209的博客
09-04 259
笔者: 最爱吃兽奶博文内容: 数据结构队列的模拟实现这篇博客理解起来或许没有那么简单,我尽力讲的容易理解一点,接下来跟我一起去看看吧!队列是一种特殊的线性数据结构，它遵循先进先出（First In First Out，FIFO）的原则。队列可以看作是一种排队的数据结构，类似于现实生活中的排队。在队列中，新元素被添加到队列的末尾，而从队列中移除元素的操作只能从队列的前端进行。上图八个小球按序号依次入队列队列有两个基本操作：入队（enqueue）和出队（dequeue）。
数组模拟环形队列代码实现
03-13
以下是一个简单的数组模拟环形队列的代码实现： ``` #define MAXSIZE 100 // 队列的最大长度 typedef struct { int data[MAXSIZE]; // 存储队列元素的数组 int front; // 队头指针 int rear; // 队尾指针 } CircularQueue; // 初始化队列 void InitQueue(CircularQueue *q) { q->front = q->rear = 0; } // 判断队列是否为空 int IsEmpty(CircularQueue *q) { return q->front == q->rear; } // 判断队列是否已满 int IsFull(CircularQueue *q) { return (q->rear + 1) % MAXSIZE == q->front; } // 入队操作 int EnQueue(CircularQueue *q, int x) { if (IsFull(q)) { return 0; // 队列已满，入队失败 } q->data[q->rear] = x; q->rear = (q->rear + 1) % MAXSIZE; // 队尾指针后移 return 1; // 入队成功 } // 出队操作 int DeQueue(CircularQueue *q, int *x) { if (IsEmpty(q)) { return 0; // 队列为空，出队失败 } *x = q->data[q->front]; q->front = (q->front + 1) % MAXSIZE; // 队头指针后移 return 1; // 出队成功 } ``` 希望能对你有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值