数组模拟队列

最新推荐文章于 2024-04-17 21:16:47 发布
最新推荐文章于 2024-04-17 21:16:47 发布
阅读量1.1k 收藏 4
点赞数 5
分类专栏： 数据结构与算法(Java实现版) 文章标签： java 数据结构 算法 数组 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37530429/article/details/125782449
版权

🏀 队列介绍

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

🏀 数组模拟队列

✏️📕 数组模拟队列整体思路

    因为队列的输出和输入是分别从头部和尾部来处理，因此借助两个变量front和tail分别记录队列前后端的下标，front会随着数据的输出而改变，而tail会随着数据的输入而改变，tail和front的初始值为-1，如下图所示为数组模拟队列存取过程。👇👇👇

在这里插入图片描述

✏️📕数据存入队列的思路分析

（1）将尾指针往后移：tail + 1，当front == tail 时队列为空；
（2）若尾指针tail小于队列的最大下标maxSize - 1时，则将数据存入tail所指的数组元素中，否则无法存入数据，当tail == maxSize - 1时队列已满。（maxSize - 1判断为已满原因：数组下标是从零开始）

✏️📕具体代码实现
package com.java.queue;

import java.util.Scanner;

/**
 * Author:YuHao
 * Description:使用数组模拟队列
 * Date:2022/7/14
 * Version:1.0
 */
public class ArraySimulationQueue {
    public static void main(String[] args) {
        ArrayQueue arrayQueue = new ArrayQueue(3);
        char key = ' ';
        Scanner scanner = new Scanner(System.in);
        boolean tag = true;
        while(tag){
            System.out.println("show(s):显示队列数据");
            System.out.println("exit(e):程序退出");
            System.out.println("add(a):增加队列数据");
            System.out.println("get(g):取出队列数据");
            System.out.println("head(h):显示头部数据");
            key = scanner.next().charAt(0);
            switch (key){
                case 's':
                    System.out.println("队列数据如下所示:");
                    arrayQueue.showData();
                    break;
                case 'e':
                    tag = false;
                    System.out.println("程序已退出");
                    break;
                case 'a':
                    System.out.println("请输入一个整数:");
                    arrayQueue.addData(scanner.nextInt());
                    break;
                case 'g':
                    System.out.println("所取得数据为:");
                    try {
                        System.out.println(arrayQueue.getData());
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    System.out.println("队列头部数据为:");
                    try {
                        arrayQueue.headData();
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
            }
        }
    }
}


class ArrayQueue {

    private int maxSize; //队列最大容量
    private int front; //头指针
    private int tail; //尾指针
    private int[] array; //该数组用来存放数据，模拟队列

    //创建队列构造器
    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        this.front = -1; //指向队列头部，分析出front是指向队列头的前一个位置
        this.tail = -1; //指向队列尾部，指向队列尾的数据(即就是队列的最后一个数据)
        this.array = new int[maxSize];
    }

    //判断队列已满
    public boolean isFull(){
        return tail == maxSize - 1; //数组下标从零开始，所以实际最大容量是maxSize - 1
    }

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

    //队列插入数据
    public void addData(int data){ //插入数据，无返回值
        if (isFull() == true){
            System.out.println("队列已满，不能继续添加数据");
            return;
        }
        tail++;
        array[tail] = data;
    }

    //从队列获取数据
    public int getData(){ //获取数据，有返回值
        if (isEmpty() == true){
            throw new RuntimeException("队列为空，无法获取数据");
        }
        front++;
        return array[front];
    }

    //显示队列中所有的数据
    public void showData(){
        if (isEmpty() == true){
            System.out.println("队列中没有数据");
            return;
        }
        for (int i = 0; i < array.length; i++){
            System.out.println("array["+i+"] = "+array[i]);
        }
    }

    //显示头部数据，不取数据
    public int headData(){ //有返回值
        if (isEmpty() == true){
            throw new RuntimeException("队列为空，无数据");
        }
        return array[front+1];
    }
}
✏️📕问题分析并优化

（1）目前数组使用一次就不能用了，没有达到复用的效果；
（2）将这个数组使用取模算法，改进成一个环形的数组（使用取模：% 来实现）。

 下面使用取模小算法对其优化，如下所示👇👇👇

🏀 数组模拟环形队列

✏️📕数组模拟环形队列思路

  如下图所示：
（1）front变量的含义做一个调整：front就指向队列的第一个元素，也就是说array[front]就是队列的第一个元素，front的初始值为0；
（2）tail变量的含义做一个调整：tail指向队列的最后一个元素的后一个位置，因为希望空出一个空间作为约定，tail的初始值为0；
（3）当队列满时，条件为（tail + 1）%maxSize == front，想比较上述模拟过程发生了改变；
（4）当队列为空的条件，front == tail；
（5）队列中有效的数据个数为：(tail + maxSize - front)%maxSize。
在这里插入图片描述

 根据环形队列的思路，对数组模拟队列的代码进行优化，以下为优化后的代码实现，如下所示👇👇👇

✏️📕 具体代码实现
package com.java.queue;

import java.util.Scanner;

/**
 * Author:YuHao
 * Description: 数组模拟环形队列
 * Date:2022/7/14
 * Version:1.0
 */
public class ArraySimulationCircleQueue {
    public static void main(String[] args) {
        CircleQueue arrayQueue = new CircleQueue(4); //需要做加1处理，预留取模运算的位置
        char key = ' ';
        Scanner scanner = new Scanner(System.in);
        boolean tag = true;
        while(tag){
            System.out.println("show(s):显示队列数据");
            System.out.println("exit(e):程序退出");
            System.out.println("add(a):增加队列数据");
            System.out.println("get(g):取出队列数据");
            System.out.println("head(h):显示头部数据");
            key = scanner.next().charAt(0);
            switch (key){
                case 's':
                    System.out.println("队列数据如下所示:");
                    arrayQueue.showData();
                    break;
                case 'e':
                    tag = false;
                    System.out.println("程序已退出");
                    break;
                case 'a':
                    System.out.println("请输入一个整数:");
                    arrayQueue.addData(scanner.nextInt());
                    break;
                case 'g':
                    System.out.println("所取得数据为:");
                    try {
                        System.out.println(arrayQueue.getData());
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    System.out.println("队列头部数据为:");
                    try {
                        arrayQueue.headData();
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
            }
        }
    }
}

class CircleQueue{
    private int maxSize; //队列最大容量
    private int front; //front就指向队列的第一个元素，也就是说array[front]就是队列的第一个元素，front的初始值为0
    private int tail; //tail指向队列的最后一个元素的后一个位置，因为希望空出一个空间作为约定，tail的初始值为0
    private int[] array; //该数组用来存放数据，模拟队列

    //创建队列构造器
    public CircleQueue(int maxSize) {
        this.maxSize = maxSize;
        this.front = 0; //指向队列头部元素，front即是指向队列头的位置
        this.tail = 0; //指向队列尾部元素后一个位置，预留一个位置出来做环形队列
        this.array = new int[maxSize];
    }

    //判断队列已满，条件改变，取模判断
    public boolean isFull(){
        return (tail + 1) % maxSize == front; //
    }

    //判断队列是否为空，条件不变
    public boolean isEmpty(){
        return tail == front;
    }

    //队列插入数据
    public void addData(int data){ //插入数据，无返回值
        if (isFull() == true){
            System.out.println("队列已满，不能继续添加数据");
            return;
        }
        //条件改变，因为tail本身就是指向后一个元素，所以直接将数据加入
        array[tail] = data;
        //后移，需要考虑取模
        tail = (tail + 1) % maxSize;
    }

    //从队列获取数据
    public int getData(){ //获取数据，有返回值
        if (isEmpty() == true){
            throw new RuntimeException("队列为空，无法获取数据");
        }
        //条件改变,因为front本身就是指向队列的第一个元素，所以需要借助临时变量进行赋值
        int result = array[front];
        //后移，这里需要考虑取模
        front = (front + 1) % maxSize;
        //返回临时变量
        return result;
    }

    //显示队列中所有的数据
    public void showData(){
        if (isEmpty() == true){
            System.out.println("队列中没有数据");
            return;
        }
        //循环条件改变，只显示出有效数据，条件为: (tail + maxSize - front) % maxSize
        //而且i的初始值从front开始，而不是从零开始遍历
        //这个部分需要好好思考一下
        for (int i = front; i < front + valuableData(); i++){
            System.out.println("array["+i % maxSize+"] = "+array[i % maxSize]);
        }
    }

    //求出队列中的有效数据
    public int valuableData(){
        return (tail + maxSize - front) % maxSize;
    }

    //显示头部数据，不取数据
    public int headData(){ //有返回值
        if (isEmpty() == true){
            throw new RuntimeException("队列为空，无数据");
        }
        //稍作改变，front本身就是指向队列的第一个元素
        return array[front];
    }
}

    以上便是数组模拟队列及优化成环形队列的全部分析和实现过程，路过的小伙伴，如果博文有帮助到你解决问题，可以点赞+收藏+关注一波呀~本人将会持续更新相关数据结构与算法Java实现版本学习的博文，感谢您的支持哦！！！芜湖起飞✈️✈️✈️

在这里插入图片描述

Fish_Vast
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
用数组模拟队列
自律即是最自由
05-23 343
定义 队列是一种特殊的线性表，它的特点是先进先出，即先入队列的先队列。队列的插入是在队列尾部（rear），队列的删除是在队列头部（front） 数组模拟队列 变量说明 maxSize：队列的最大容量 rear：记录队列尾部的下标，指向队尾元素,队尾元素为 arr[rear] front：记录队列头部的下标，指向队列头的前一个位置，即队列的第一个元素为 arr[front+1] 队列满的条件： rear=maxSize-1 队列空的条件： rear=front 代码实现 //使用数组模拟队列-编写一个Arr
数组模拟环形队列
weixin_50125130的博客
04-12 104
队列和环形队列的相关概念 队列是数据结构的一种类型，主要特点：先进先出 先进先出：好比如排队买奶茶 先来得人肯定比后来的早点买到奶茶 2.环形队列是特殊队列的一种，特点能重复使用，像环形一样；普通队列取数据是前面的空间闲置不能利用，环形队列很好的解决这个问题 ###创建环形队列类 public class ArrayQueue{ //size表示 队列的大小 int size; //front 表示指向环形队列**首元素元素** int front; //rear 表示指向
数组模拟实现队列
weixin_72668830的博客
05-05 258
队列（Queue）是一种先进先出（FIFO，First In First Out）的数据结构。与栈（Stack）不同，队列是在一端进行插入操作，在另一端进行删除操作。队列的基本操作包括入队（Enqueue）和出队（Dequeue），以及获取队列长度（Size）、判断队列是否为空（IsEmpty）等操作。
【数据结构】—— 队列基础知识以及数组模拟队列的分析、演示及优化_arr 队列
最新发布
2401_84182578的博客
04-17 927
例如当 rear = 2 ，front = 0 时，maxSize - 1 = 2，maxSize = 3（因为下标从零开始），所以(2 + 1) % 3 == 0，所以队列已满。再次存入数据发现就算是取出了数据的情况下依然不能向队列中存入数据，没有达到复用的效果，所以我们可以优化一下我们的程序，让它在取出数据后依然可以继续存入。例如当 rear = 2，front =0，maxSize = 3时，(2 + 3 - 0) % 3 等于 2 ，说明该队列中有效数据的个数为两个。可以看到运算全部正确。
使用数组模拟队列
ice_YJY的博客
03-28 252
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。缺陷：这样模拟的数组只能使用一次，向队列中插入maxQueue个元素再取出之后再想插入元素就会显示队列已满；这时就需要改进，使用数组模拟环形队列，使这个数组可以循环复用。
数据结构--使用数组模拟队列
weixin_50204197的博客
02-15 240
数据结构，队列，java
用数组模拟实现队列
m0_56398287的博客
09-24 317
【代码】用数组模拟实现队列。
【算法02】数组模拟队列（一次性&&循环）
qq_59942266的博客
10-16 273
“Duplicated code fragment”提示、scanner.close()方法、直接输出Java中的类得到的结果、快速生成对象快捷键、自得人生哲理之一
数据结构 -- 线性表 -- 数组模拟队列
m0_46218511的博客
10-13 92
一、概述 数组模拟队列 存在问题：不是环形队列，队列只能用一次 二、代码实现 import java.lang.reflect.Array; import java.util.Scanner; /** * 数组模拟队列 * 存在问题：不是环形队列，队列只能用一次 * @date 2021/10/12 23:50 */ public class ArrayQueue<T> { private int maxSize; // 表示数组的最大容量 private int fr
数组实现队列
09-13
由数组实现队列，包括队列的创建、入队和出队。通过打印显示出队的结果。正在学习数据结构的童鞋可以参考。
java数组实现队列及环形队列实现过程解析
08-25
Java数组实现队列是使用Java语言中数组来模拟队列的实现过程。队列是一种重要的数据结构，广泛应用于计算机科学和软件开发中。在Java中，可以使用数组来模拟队列的实现。 数组实现队列的基本概念 在Java中，数组是...
Java数组模拟优先级队列数据结构的实例
09-02
在上述的Java代码示例中，作者通过数组来模拟优先级队列的实现。这个模拟版本采用了类似`TreeSet`和`TreeMap`的方法，即通过比较器（Comparator）来确定元素的顺序。数组是基础，但是仅靠数组本身无法自动维护元素的...
用数组实现的优先队列（JAVA）
04-10
在Java中，我们可以使用数组来实现优先队列。这篇文章将探讨如何利用数组实现优先队列，并通过提供的`PriorityQ.java`文件来深入理解其实现原理。 1. **优先队列基本概念** 优先队列是一种数据结构，它维护了一个...
数组循环队列.rar
07-09
在数组循环队列中，我们利用数组作为底层数据存储，并通过巧妙的索引操作模拟队列的“先进先出”（FIFO）原则。这种数据结构在处理大量数据时尤其有用，因为它可以避免频繁的内存分配和释放，从而提高程序运行效率。...
数据结构-队列（数组实现）
weixin_43265151的博客
03-02 382
一.概念 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。通俗来讲队列的特点是，先进先出。 类似于现实中的排队买票，先来的先买票，后来的后买票，不能插队。 通过概念可以总结出： 队列是有序列表，可以用数组，链表实现（本文使用数组实现）...
数组模拟队列（queue）
jefferyfg的博客
09-24 1786
队列介绍 队列是一个有序列表，可以用数组或者链表实现 遵循先进先出的原则:先存入队列的数据，要先取出，后存入的数据，要后取出 使用数组模拟队列示意图 数组模拟队列思路： 队列本身是有序列表，如果使用数组的结构来存储队列的数据，则队列数组的声明如上图，maxSize是队列的最大容量。 因为队列的的输出、输入分别从前后端来处理，所以需要两个变量fornt个rear分别记录前后端的下标，fro...
C++实现循环队列（数组模拟）【保姆级讲解】
weixin_55755506的博客
12-10 3548
看起来还不错，但仔细观察出队到队空时，队列里面没有数了，也就是队空了，可以继续加数据，但是，表示队列头尾的变量已经到了数组的最右边的下一个索引，已经没办法再往右了，同时数组还是空的。这里可以将数组的一个格子空出来，当数组还有一个格子的时候，就当作队列已经满了。出队的话，可以利用和入队类似的办法，但数组无法删除元素，但我们可以用一个数组索引的变量表示队头的位置，每次出队只需把这个索引向递增即可。这样看起来可以，但是有一个问题，我们需要时刻记得我们入队了几次，否则就无法根据索引入队了。没有到达数组末尾的时候，
数组模拟环形队列代码实现
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
发出的红包

打赏作者

Fish_Vast

您的打赏是对我最大的支持！！！

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

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

打赏作者

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

抵扣说明：

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

余额充值