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

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量86 收藏
点赞数
文章标签： java 队列 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51453935/article/details/114744119
版权

队列

数组模拟队列

前提

  1. front指的是队列中的第一个数据的前一个位置，rear指的是队列中的最后一个数据的位置,maxSize指的是数组长度即队列大小
  2. front 的初始值 = -1，rear 的初始值 = -1
  3. 队列为空的判断条件：front == rear
  4. 队列满的判断条件：rear = maxSize - 1
  5. 队列中有效的数据个数：rear

思路

  1. 创建一个类来模拟队列

       class Queue{
       private int maxSize;//数组最大长度
       private int front;//队列头,指向第一个数据的前一个位置
       private int rear;//队列尾，指向最后一个数据的位置
       private int[] arr;//用于存放数据，模拟队列
   
       //队列构造器
       public Queue(int arrMaxSize){
           maxSize = arrMaxSize;
           arr = new int[maxSize];
           front = -1;//指向队列头的前一个位置
           rear = -1;//指向队列尾的位置，即最后一个数据
       }
   }

  2. 判断队列是否为空

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

  3. 判断队列是否满

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

  4. 入队列，添加数据

     //入队列，即添加数据
     public void addQueue(int n){
         if (isFull()){
             System.out.println("队列已满！");
             return;
         }
         rear ++;
         arr[rear] = n;
     }

  5. 出队列，取出数据

       //出队列，即取出数据
       public int getQueue(){
           if (isEmpty()){
               throw new RuntimeException("队列为空！");
           }
           return arr[++front];
       }

  6. 显示所有数据

       //显示队列所有数据
   public void showQueue(){
       if (isEmpty()){
           System.out.println("队列为空！");
           return;
       }
       for (int i = 0; i < arr.length; i++) {
           System.out.print("arr["+ i +"]="+ arr[i] + "\t");
       }
       System.out.println();
   }

  7. 显示队列头数据

     //取队列头的数据
     public int headQueue(){
         if (isEmpty()){
             throw new RuntimeException("队列为空!");
         }
         return arr[++front];
     }

缺点

数组无法进行复用，也就是数据存入队列后，队列满了的情况下取出所有数据，在重新添加数据到队列时，会出现队列满的情况

完整代码

    
    package ArrayQueue;
    
    import java.util.Scanner;
    
    /**
     * Created by lenovo on 2021/3/13.
     */
    public class ArrayQueue {
        public static void main(String[] args) {
            Queue queue = new Queue(3);
            char key = ' ';
            Scanner scanner = new Scanner(System.in);
            boolean loop = true;
            //输出用户菜单
            while(loop){
                System.out.println("s(show):显示队列");
                System.out.println("a(add):添加数据");
                System.out.println("g(get):取出数据");
                System.out.println("h(head):显示队列头的数据");
                System.out.println("e(exit):退出程序！");
                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.println("取出的数据为:" + res);
                        }catch (Exception e){
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'h':
                        try {
                            int res = queue.headQueue();
                            System.out.println("取出的数据为:" + res);
                        }catch (Exception e){
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'e':
                        scanner.close();
                        loop = false;
                        break;
                }
            }
            System.out.println("程序退出！");
        }
    }
    
    class Queue{
        private int maxSize;//数组最大长度
        private int front;//队列头
        private int rear;//队列尾
        private int[] arr;//用于存放数据，模拟队列
    
        //队列构造器
        public Queue(int arrMaxSize){
            maxSize = arrMaxSize;
            arr = new int[maxSize];
            front = -1;//指向队列头的前一个位置
            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;
            }
            rear ++;
            arr[rear] = n;
        }
    
        //出队列，即取出数据
        public int getQueue(){
            if (isEmpty()){
                throw new RuntimeException("队列为空！");
            }
            return arr[++front];
        }
    
        //显示队列所有数据
        public void showQueue(){
            if (isEmpty()){
                System.out.println("队列为空！");
                return;
            }
            for (int i = 0; i < arr.length; i++) {
                System.out.print("arr["+ i +"]="+ arr[i] + "\t");
            }
            System.out.println();
        }
    
        //取队列头的数据
        public int headQueue(){
            if (isEmpty()){
                throw new RuntimeException("队列为空!");
            }
            return arr[++front];
        }
    }

数组模拟环形队列

前提

  1. front指的是队列中第一个数据的位置，rear指的是队列中最后一个数据的后一个位置，maxSize指的是数组长度即队列大小
  2. front 的初始值 = 0，rear 的初始值 = 0
  3. 队列为空的判断条件：front == rear
  4. 队列满的判断条件：（rear + 1）% maxSize == front
  5. 队列中有效的数据个数：(rear + maxSize - front) % maxSize

思路

  1. 创建一个类模拟环形队列
    class CQueue{
        private int maxSize;
        private int front;//指向队列的第一个数据的位置
        private int rear;//指向队列最后一个数据的后一个位置
        private int[] arr;
    
        //队列构造器
        public CQueue(int arrMaxSize){
            maxSize = arrMaxSize;
            arr = new int[maxSize];
        }
    }
  1. 判断队列是否为空
    //队列是否为空
        public boolean isEmpty(){
            return front == rear;
        }
  1. 判断队列是否满
    //队列是否已满
        public boolean isFull(){
            return (rear + 1) % maxSize == front;
        }
  1. 添加数据到队列，入队列
    //添加数据到队列
        public void addQueue(int n){
            if (isFull()){
                System.out.println("队列已满！");
                return;
            }
            arr[rear] = n;
            rear = (rear + 1) % maxSize;
        }
  1. 取出数据，出队列
    //取出数据出队列
        public int getQueue(){
            if (isEmpty()){
                throw new RuntimeException("队列为空！");
            }
            int temp = arr[front];
            front = (front + 1) % maxSize;
            return temp;
        }
  1. 获取队列中有效数据的个数
    //获取队列中有效数据的个数
        public int size(){
            return (rear + maxSize - front) % maxSize;
        }
  1. 显示队列所有数据
    //显示队列所有数据
        public void showQueue(){
            if (isEmpty()){
                System.out.println("队列为空！");
                return;
            }
            for (int i = front; i < front + size(); i++) {
                System.out.print("arr[" + i % maxSize + "]=" + arr[i % maxSize] + "\t");
            }
            System.out.println();
        }
  1. 显示队列头数据
    //取出队列头的数据
        public int headQueue(){
            if (isEmpty()){
                throw new RuntimeException("队列为空！");
            }
            return arr[front];
        }

解决的问题

解决了数组无法进行复用的情况，在取出所有数据后再重新存入数据到队列中，可以存放成功，不会出现队列满的情况

完整代码

    package ArrayQueue;
    
    import java.util.Scanner;
    
    /**
     * Created by lenovo on 2021/3/13.
     */
    public class CircleQueue {
        public static void main(String[] args) {
            CQueue cqueue = new CQueue(4);
            char key = ' ';
            Scanner scanner = new Scanner(System.in);
            boolean loop = true;
            //输出用户菜单
            while(loop){
                System.out.println("s(show):显示队列");
                System.out.println("a(add):添加数据");
                System.out.println("g(get):取出数据");
                System.out.println("h(head):显示队列头的数据");
                System.out.println("e(exit):退出程序！");
                key = scanner.next().charAt(0);
                switch (key){
                    case 's':
                        cqueue.showQueue();
                        break;
                    case 'a':
                        System.out.println("请输入一个数：");
                        int value = scanner.nextInt();
                        cqueue.addQueue(value);
                        break;
                    case 'g':
                        try {
                            int res = cqueue.getQueue();
                            System.out.println("取出的数据为:" + res);
                        }catch (Exception e){
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'h':
                        try {
                            int res = cqueue.headQueue();
                            System.out.println("取出的数据为:" + res);
                        }catch (Exception e){
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'e':
                        scanner.close();
                        loop = false;
                        break;
                }
            }
            System.out.println("程序退出！");
        }
    }
    class CQueue{
        private int maxSize;
        private int front;//指向队列的第一个数据的位置
        private int rear;//指向队列最后一个数据的后一个位置
        private int[] arr;
    
        //队列构造器
        public CQueue(int arrMaxSize){
            maxSize = arrMaxSize;
            arr = new int[maxSize];
        }
    
        //队列是否为空
        public boolean isEmpty(){
            return front == rear;
        }
    
        //队列是否已满
        public boolean isFull(){
            return (rear + 1) % maxSize == front;
        }
    
        //添加数据到队列
        public void addQueue(int n){
            if (isFull()){
                System.out.println("队列已满！");
                return;
            }
            arr[rear] = n;
            rear = (rear + 1) % maxSize;
        }
    
        //取出数据出队列
        public int getQueue(){
            if (isEmpty()){
                throw new RuntimeException("队列为空！");
            }
            int temp = arr[front];
            front = (front + 1) % maxSize;
            return temp;
        }
    
        //显示队列所有数据
        public void showQueue(){
            if (isEmpty()){
                System.out.println("队列为空！");
                return;
            }
            for (int i = front; i < front + size(); i++) {
                System.out.print("arr[" + i % maxSize + "]=" + arr[i % maxSize] + "\t");
            }
            System.out.println();
        }
    
        //获取队列中有效数据的个数
        public int size(){
            return (rear + maxSize - front) % maxSize;
        }
    
        //取出队列头的数据
        public int headQueue(){
            if (isEmpty()){
                throw new RuntimeException("队列为空！");
            }
            return arr[front];
        }
    }
MC_Leonard
关注
数组模拟环形队列
qq_39032364的博客
08-15 507
数组模拟环形队列 1.数组模拟队列的缺陷 如上图所示，当使用数组模拟队列时，已经取出的数组实际上以及占据着数组的相应的位置，数组使用了一次之后就不能使用，造成空间浪费，为了解决这样的问题，出现了环形队列。 2.环形队列 1.主要算法：取模运算 2.分析说明 变量 front （头索引）初始值：0 指向队列的第一个元素 rear （尾索引）初始值：0 指向队列最后一个元素的下一个元素 maxsize 数组的最大长度 分析说明 1.尾索引的下一个为头索引时表示队列满，将队列容量...
队列：数组模拟环形队列
weixin_45607513的博客
02-24 123
思路 1.将front变量进行了调整，之前的front是指向的队列第一个元素的前一个值，而现在指向队列的第一个元素，也就是说arr[front]就是队列的第一个元素。front初始值=0。 2.rear变量的含义的调整：rear指向队列的最后一个元素的后一个位置。因为希望空出一个空间作为约定。rear初始值=0； 3.当队列满时，条件是[rear+1]%maxSize = front。 4.当队列为空的条件，rear=front。 5.队列中有效的数据的个数为(rear+maxSize-front)%max
队列、使用数组模拟环形队列
Foools的博客
03-04 185
队列 队列是一个有序列表，可能用数组或链表来实现。 先进入的数据先取出，后进入的数组后取出。 数组模拟队列的思路： 队列本身就是一个有序列表，maxSize来记录该数组最大容量；front和rear分别记录队列前后端的下标，front随着数据输出而改变，rear随着数据输入而改变。 加入数据：若队列不为满，尾部指针后移：rear+1 拿出数据：若队列不为空，前端指针后移：front+1 代码： package com.dataStructure; import java.util.Scanner; pub
二、数组模拟环形队列思路及代码实现
zhaozhiwei314的博客
01-13 212
队列 总：我首先会介绍数组模拟队列思路及代码实现，并分析其弊端；之后将代码进行优化，将其转换为数组模拟环形队列。 1.队列介绍 (1)队列是一个有序列表，可以使用数组或者链表来实现 (2)遵循先入先出的原则：即先存入队列的数据会先被取出，后被存入的数据后被取出。 2.数组模拟队列思路 (1)队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的申明如下图，其中maxSize是该队列的最大容量 (2)因为队列的输入输出是从前后端来处理，因此需要两个变量front和rear分别记录队列前后端的下标，
数组模拟环形队列案例和思路
qq_40823802的博客
08-09 642
思路如下： **1. front:**front就指向队列的第一个元素，也就是说arr[front]就是队列的第一个元素。front的初始值为0. **2.rear:**rear指向队列的最后一个元素的后一个位置，因为希望空出一个空间作为约定。rear的初始值为0 3.当队列满时，条件是**（rear+1）%maxSize=front【满】。** 4.当队列为空的条件时，rear==front【空...
数组模拟队列与环形队列
JaxonChan的博客
08-23 106
队列 队列是一个有序列表，可以用数组或是链表来实现。 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。 front: 指向队列头的前一个元素，初始值front=-1。 rear：指向队列尾，即 queue[rear] 就是队列的最后一个数据，初始值rear=-1。 1.将尾指针往后移：rear+1 ,队列为空的条件：front == rear 。 2.若尾指针 rear 小于队列的最大下标 maxsize-1，则将数据存入 rear所指的数组元素中，否则无法存入数据。 队列为
数组模拟环形队列(思路分析) [数据结构与算法][Java]
m0_57001006的博客
07-31 496
我们从数组模拟环形队列实现中如果要进行出队列的操作,这个时候一定注意,因为我们出队列是从队列的头部位置开始出队列,那么我们在出队列的时候一定要用到一个"临时变量",使用这个临时变量先将我们当前的front指向的元素保存到这个临时变量中,然后再进行指针后移,然后我们再将临时变量中存储的队列中被删除的元素返回。对于之前我们讲过的非环形队列来讲我们的maxSize即使队列底层数组的最大容量,还是队列的长度,但是这里我们对于环形队列来讲数组的最大容量=队列容量+1。移动次数=间隔数+1;...
数据结构----数组实现队列和环形队列
weixin_44251874的博客
03-12 213
队列 1.应用场景 银行排队等 2.关于队列 1）队列是一个有序列表，可以用数组或单链表实现 2）队列遵循先进先出的原则，即：先存入进队列的数据先取出，后存入的后取出 3）示意图： 3.单队列实现思路 1）队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中maxSize 是该队 列的最大容量。 2）因为队列的输出、输入是分别从前后端来处理，因此需要两个变量front 及rear 分别记录队列前后端的下标，front 会随着数据输出而改变，而rear 则是随着数据输入而改变
Java 使用数组来模拟普通队列和数组模拟环形队列实现
Beyond_Nothing
05-10 601
1.模拟普通队列 队列:先进先出,后进后出; 即尾进头出 应用: 银行叫号系统 会出现一个问题: 该数组只能使用一次,数组满后就算是你此刻取了数据也无法再添加进去,同样,当把数据全部取出来之后,就算添加了数据也是无法取出来的.即没有达到复用的效果. (解决此问题参考 2.模拟环形队列 取模完成) 思路: private int maxSize; //表示数组最大容量 private int front; //队列头 private int rear; //队列尾 private int[] arr; //该
【数据结构】—— 队列基础知识以及数组模拟队列的分析、演示及优化
周小末天天开心的博客
11-10 1807
队列基础知识——数组模拟队列和数组模拟环形队列的分析和演示
数组和队列
weixin_43096582的博客
03-31 550
二维数组的概述： 二维数组其实就是一个元素为一维数组的数组； 格式1： 数据类型[][] 变量名=new 数据类型[m][n]; m表示这个二维数组有多少个数组 n表示每一个一维数组的元素个数 举例： int[][] arr=new int[3][2]; 定义了一个二维数组arr 这个二维数组有3个一维数组，名称是ar[0],arr[1],arr[2] 每个一维数组有2个元素，可以通过arr[m]...
c语言数组实现环形缓冲区,[嵌入式开发模块]环形缓冲区/循环队列 C语言实现
weixin_35775446的博客
05-21 849
忙着毕设，很久没有写文章了，终于答辩完了，得了个校优秀毕业设计。毕设做的是个智能接口模块，用一周时间入门了，MC9S12XEP100的开发，又用一周时间入门了uC/OS-II嵌入式操作系统，在做毕设的过程中学到了很多，现在把一些工具发上来分享。这里分享一个自己用纯C实现的环形缓冲区。环形缓冲区有很多作用，比如嵌入式中的通信可以用环形缓冲区作为信道，一个线程往里放字节，一个线程取字节进行处理，只要保...
【环形数组和链表的区别】：在JavaScript中选择合适的数据结构
[【环形数组和链表的区别】：在JavaScript中选择合适的数据结构](https://img-blog.csdnimg.cn/d3d19783c88546e6960c4ae6602f3876.png) # 1. 数据结构基础和JavaScript中的应用 在编程的世界里，数据结构是构建高效...
刷题学习—数据结构(字符串、栈和队列、链表、数组与矩阵、哈希表、位运算)
np131131的博客
11-01 1187
参考了很多大佬的题解，仅作为自己学习笔记用。 数据结构相关 第一章 字符串 1.字符串循环移位包含 给定两个字符串 s1 和 s2，要求判定 s2 是否能够被 s1 做循环移位得到的字符串包含 解决办法：s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2 是否是 s1s1 的子字符串即可。 public class Exer { public boolean strStr(String s1, String s2) { StringBuilder sb = new
工厂模式的介绍及实现
户伟伟的博客
09-25 114
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Spring Boot 学习和使用
cesske的博客
09-24 1084
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 413
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 899
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
Java数组与环形数组实现队列详解
"这篇教程详细解析了如何使用Java数组实现队列以及环形队列，提供了具体的示例代码，适合学习者参考学习。" 在Java编程中，队列是一种线性数据结构，遵循先进先出（FIFO）的原则。数组是实现队列的基本方式之一，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值