使用数组模拟队列

最新推荐文章于 2022-04-11 16:01:37 发布
最新推荐文章于 2022-04-11 16:01:37 发布
阅读量139 收藏
点赞数
分类专栏： Java数据结构与算法 数组模拟队列 文章标签： java 队列 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43179622/article/details/116641777
版权

队列的介绍

  • 队列是一个有序列表，可以用数组或是链表来实现。
  • 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出
  • 示意图：(使用数组模拟队列示意图)
    在这里插入图片描述

数组模拟队列思路

  • 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队 列的最大容量。
  • 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front 及 rear 分别记录队列前后端的下标， front会随着数据输出而改变，而 rear 则是随着数据输入而改变，如图所示:
    在这里插入图片描述
  • 当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤：思路分析 ：
  •  1) 将尾指针往后移：rear+1 ,当 front == rear 【空】 

  •  2) 若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear所指的数组元素中，否则无法存入数据。 rear == maxSize - 1[队列满]

编码实现（使用数组模拟队列）

package com.zlx.queue;

import java.util.Scanner;

/**
 * @ClassName ArrayQueue
 * @Description TODO
 * @Author zhalongxi
 * @Date 2021/5/9 19:23
 * @Version 1.0
 **/
public class ArrayQueueDemo {
    public static void main(String[] args) {
        ArrayQueue arrayQueue = new ArrayQueue(3);//创建出一个队列
        char key = ' ';//接收用户输入的数据
        Scanner scanner = new Scanner(System.in); //控制台输入数据
        //在while循环中进行队列的操作
        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':
                    try {
                        arrayQueue.showArrQueue(); //打印出队列中的所有的数据
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'a':
                    System.out.println("请输入需要往队列中添加的元素:");
                    int value = scanner.nextInt(); //接收控制台输入的一个整形数据
                    arrayQueue.addQueue(value);
                    break;
                case 'g':
                    try {
                        arrayQueue.getQueue();//从队列中取出一个元素
                    } catch (Exception e) {
                        //处理从队列中取元素时的空队列跑出的异常
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        arrayQueue.getHeadQueue();//取出队列中的头元素
                    } catch (Exception e) {
                        //处理从队列中取元素时的空队列跑出的异常
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();//关闭控制台
                    loop = false;//结束循环
                    break;
            }
        }
        System.out.println("程序退出");
    }
}

class ArrayQueue{

    private int maxSize;//队列的最大的容量
    private int front;//队列头部
    private int rear;//队列尾部
    private int[] arr;//模拟队列的数组

    //1 使用构造器构造出一个队列
    /** @Description //TODO
     *  @Author zhalongxi
     *  @Date 19:24 2021/5/9
     *  @Param maxSize:队列的最大的容量
     *  @return
     **/
    public ArrayQueue(int arrMaxSize){
        maxSize = arrMaxSize;  //队列的最大的容量
        arr = new int[maxSize]; //创建出一个队列
        front = -1;//队列的头指向队列的第一个元素的前一个位置
        rear = -1;//队列的尾部指向队列的第一个元素的前一个位置
    }

    /** @Description 判断队列是否已满
     *  @Author zhalongxi
     *  @Date 19:33 2021/5/9
     *  @Param
     *  @return
     **/
    public boolean isFull(){
        return rear == maxSize - 1;
    }

    /** @Description 判断队列是否为空
     *  @Author zhalongxi
     *  @Date 19:34 2021/5/9
     *  @Param
     *  @return
     **/
    public boolean isEmpty(){
        return rear == front;
    }

    /** @Description 往队列中添加数据
     *  @Author zhalongxi
     *  @Date 19:35 2021/5/9
     *  @Param
     *  @return
     **/
    public void addQueue(int n){
        //判断队列是否已满
        if(isFull()){
            System.out.println("队列已满,请勿添加数据...");
            return ;
        }
        rear ++;
        arr[rear] = n;
    }

    /** @Description 从队列中取出一个元素
     *  @Author zhalongxi
     *  @Date 19:39 2021/5/9
     *  @Param
     *  @return
     **/
    public int getQueue(){
        //判断队列是否为空
        if(isEmpty()){
            //为空则抛出异常
            throw new RuntimeException("队列为空,无法从队列中获取到数据...");
        }
        front ++; //将队列的头部向前移动一位
        System.out.println("从队列中取出的元素："+arr[front]);
        return arr[front];
    }

    /** @Description 打印出队列中的所有的元素
     *  @Author zhalongxi
     *  @Date 19:44 2021/5/9
     *  @Param
     *  @return
     **/
    public void showArrQueue(){
        if(isEmpty()){
            System.out.println("队列是空的...");
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d]=%d\n",i,arr[i]);
        }
    }

    /** @Description 取出队列的头部元素
     *  @Author zhalongxi
     *  @Date 19:45 2021/5/9
     *  @Param
     *  @return
     **/
    public int getHeadQueue(){
        if(isEmpty()){
            throw new RuntimeException("队列为空...");
        }
//        front ++;
        System.out.println("从队列中取出的头元素："+arr[front]);
        return arr[front + 1];
    }
}

注意：这个队列有一个问题：就是一次性的队列，用完就没了。。所以需要将队列进行如下的改进：将这个数组使用算法，改进成一个环形的队列 取模：%，达到复用的效果。

数组模拟环形队列

对前面的数组模拟队列的优化，充分利用数组. 因此将数组看做是一个环形的。(通过取模的方式来实现即可)

  1. 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定,这个在做判断队列满的 时候需要注意 (rear + 1) % maxSize == front 满]
  2. rear == front [空]
  3. 分析示意图
    在这里插入图片描述

编码实现

package com.zlx.queue;

import java.util.Scanner;

/**
 * @ClassName CircleArrayQueueDemo
 * @Description TODO
 * @Author zhalongxi
 * @Date 2021/5/9 22:45
 * @Version 1.0
 **/
public class CircleArrayQueueDemo {

    public static void main(String[] args) {
        //注意，此环形队列的有效数据实际上只有3,因为预留了一位用作约定
        CircleArrayQueue circleArrayQueue = new CircleArrayQueue(4);//创建出一个队列
        char key = ' ';//接收用户输入的数据
        Scanner scanner = new Scanner(System.in);//控制台输入数据
        //在while循环中进行队列的操作
        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':
                    try {
                        circleArrayQueue.showQueue(); //打印出队列中的所有的数据
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'a':
                    System.out.println("请输入需要往队列中添加的元素:");
                    int value = scanner.nextInt(); //接收控制台输入的一个整形数据
                    circleArrayQueue.addQueue(value);
                    break;
                case 'g':
                    try {
                        circleArrayQueue.getQueue();//从队列中取出一个元素
                    } catch (Exception e) {
                        //处理从队列中取元素时的空队列跑出的异常
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        circleArrayQueue.getHeadQueue();//取出队列中的头元素
                    } catch (Exception e) {
                        //处理从队列中取元素时的空队列跑出的异常
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();//关闭控制台
                    loop = false;//结束循环
                    break;
                default:
                    System.out.println("请输入上面提示的字母！");
                    break;
            }
        }
        System.out.println("程序退出");
    }
}

class CircleArrayQueue{
    private int maxSize; //队列的容量
    //front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素
    //front 的初始值 = 0
    private int front;   //指向队列的头指针(队列的第一个元素)
    //rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
    // rear 的初始值 = 0
    private int rear;    //指向队列的最后一个元素的后一个位置
    private int[] arr;   //用于模拟队列存储数据

    /** @Description 初始化队列
     *  @Author zhalongxi
     *  @Date 22:50 2021/5/9
     *  @Param
     *  @return
     **/
    public CircleArrayQueue(int circleArrayMaxSize){
        maxSize = circleArrayMaxSize;
        arr = new int[maxSize];
        //这两行代码可以不写,因为默认值为0
        front = 0;
        rear = 0;
    }

    /** @Description 判断队列是否已满,因为是环形队列,所以考虑取模
     *  @Author zhalongxi
     *  @Date 22:51 2021/5/9
     *  @Param
     *  @return
     **/
    public boolean isFull(){
        return (rear + 1) % maxSize == front;
    }

    /** @Description 判断队列是否为空
     *  @Author zhalongxi
     *  @Date 22:52 2021/5/9
     *  @Param
     *  @return
     **/
    public boolean isEmpty(){
        return rear == front;
    }

    /** @Description 往数组中添加元素
     *  @Author zhalongxi
     *  @Date 22:55 2021/5/9
     *  @Param int n添加的值
     *  @return
     **/
    public void addQueue(int n){
        if(isFull()){
            System.out.println("队列已满,请勿再添加...");
            return;
        }
        //因为这个rear指正指向队列的后一个元素，所以不需要rear+1
        arr[rear] = n;
        //将rear后移,必须考虑到取模,否则会数组越界异常(因为是环形队列)
        rear = (rear + 1) % maxSize;
    }

    /** @Description 取出队列中的值
     *  @Author zhalongxi
     *  @Date 22:58 2021/5/9
     *  @Param
     *  @return
     **/
    public int getQueue(){
        if(isEmpty()){
            throw new RuntimeException("队列为空,无法取出元素...");
        }
        //1、先将front对应的值保留到一个临时变量中
        int value = arr[front];
        //2、将front后移,考虑取模,否则出现数组越界异常
        front = (front + 1) % maxSize;
        //3、将保存的临时变量进行返回
        return value;
    }

    public void showQueue(){
        if(isEmpty()){
            System.out.println("队列为空...");
            return;
        }
        for (int i = front; i < front + size(); i++) {
            System.out.printf("arr[%d] = %d\n",i%maxSize,arr[i%maxSize]);
        }
    }

    /** @Description 显示队列的头元素
     *  @Author zhalongxi
     *  @Date 23:03 2021/5/9
     *  @Param
     *  @return
     **/
    public int getHeadQueue(){
        System.out.println("队列的头元素为:"+arr[front]);
        return arr[front];
    }

    /** @Description 计算队列中有效数据的个数
     *  @Author zhalongxi
     *  @Date 23:01 2021/5/9
     *  @Param
     *  @return
     **/
    public int size(){
        return (rear + maxSize -front) % maxSize;
    }
}
qq_43179622
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++队列操作入队出队
10-22
简单队列操作，vc++实现。队列类实现，小弟新手，大神莫黑
JAVA使用数组创建《循环队列》满足判断队空，判断队满入队，出队
xwe_147jyz的博客
10-02 496
建立一个头指针tou，一个尾指针wei，并且让其初始化为-1，因为数组下标是从0开始的，队列先进先出，当进一个元素那么尾指针+1，出去一个元素头指针+1，判断队列为空，就是当头指针等于尾指针的时候；判断队列为满，就是尾指针等于数组最后一个下标的时候。 打印队列遍历数组的时候，开始的位置应该是从头指针开始的，并且是++tou，因为出队的时候元素已经出去了，目前头指针所指的位置为空，所以遍历数组的时候应该从当前头指针的下一个位置开始遍历因此是++tou,遍历的长度应该是尾指针的位置。 代码如下： pub
队列的基本操作 出队 入队 判断队列是否为空 .......
weixin_45220224的博客
10-30 4880
#include <stdio.h> #include <malloc.h> #include<stdlib.h> #define MAXQSIZE 100 //最大队列长度，实际使用 MAXQSIZE-1 #define OVERFLOW 0 typedef int ElemType; typedef int Status; //循环队列(少用一个存储单元) typedef struct { ElemType base[MAXQSIZE];//初始化的动态分配存储空间
【队列】c++使用数组实现队列
yizhizainulii的博客
04-11 3870
数组队列 基本概念 代码实现 1 数组队列的类 2 判断队列是否满 3 判断队列是否为空 4 向队列中添加元素 5 从队列中取出元素 6 获取队列元素个数 7 显示队列所有元素 8 显示队列头元素 9 数组队列全部代码 10 测试代码 结果与分析 1 操作结果 2 分析与待改进 基本概念 队列是一个有序列表，可以用数组或是链表来实现。 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 使用数组来实现队列的示意图 .
C++实现普通队列，循环队列的基本操作（初始化，入队，出队，获取队列首元素等）
热门推荐
多反思，多回顾，要坚持。
02-26 3万+
队列是一种先进先出（FIFO，First-In-First-Out）的线性表，通常用链表或者数组来实现。队列只能在队尾插入元素，只能在队首删除元素。 队列的一些性质： 1.出队方案唯一 2.队首元素先出 3.新元素插入队尾 线性队列的初始化： #include using namespace std; class Queue{ private: int *data;
PHP使用数组实现队列
10-28
在PHP中，实现队列的功能通常会借助数组及其内置函数来模拟队列的基本行为。队列是一种先进先出（First In First Out, FIFO）的数据结构，类似于现实生活中的排队等候系统，如银行的排号机，最先排在队伍中的人会...
数组实现队列
09-13
由数组实现队列，包括队列的创建、入队和出队。通过打印显示出队的结果。正在学习数据结构的童鞋可以参考。
JS使用数组实现的队列功能示例
10-17
在JavaScript中，数组是一种基本的数据结构，可以用来模拟队列。数组提供了一系列方法来处理元素的添加和删除，如`push`方法用于在数组末尾添加元素，`shift`方法用于移除数组的第一个元素。 #### 队列的定义和操作...
java数组实现队列及环形队列实现过程解析
08-25
Java数组实现队列是使用Java语言中数组来模拟队列的实现过程。队列是一种重要的数据结构，广泛应用于计算机科学和软件开发中。在Java中，可以使用数组来模拟队列的实现。 数组实现队列的基本概念 在Java中，数组是...
数据结构：队列链表，此代码有初始化、入队、出队、判断队是否为空
qq_41631679的博客
11-04 1088
数据结构队列链表，此代码有初始化、入队、出队、判断队是否为空，可以直接copy调试。 #include"stdio.h" #include"stdlib.h" typedef struct node * pointer; struct node{ int data; pointer next; }; typedef struct { pointer front,rear; }queu...
循环队列 创建队列 入队 出队 （C语言实现）
加油高同志
06-10 9155
# 下面给出的代码是循环队列的基础操作，代码注释写的还算详细，帮助大家理解，同时也有助我回忆 在这里插入代码片 #include<stdio.h> #define qsize 5 int qdata[5],i=0; struct cell///单个结点 { int data; }; struct queue///队列 { struct cell *base; int front; int rear; }; int Enqueue(struct queue *q,struct cell e)///
C语言 实现队列的创建，入队、出队、返回队首元素等操作
weixin_49061985的博客
08-27 2970
队列 （先进先出） //队列（新建，出队，入队等操作） typedef struct node { int data; struct node *next; }Node; typedef struct myQueue { int size; Node *front; Node *rear; }my_Queue; #include <stdio.h> #include <malloc.h> #include <string.h> my_Queue *crea.
建立一个顺序队列，实现队列的入队和出队操作
ab111996的博客
05-02 5878
头文件：  #ifndef seqqueue_H  #define seqqueue_H  const int queuesize=10;  class seqqueue   {      int rear,front;      int data[queuesize];  public:      seqqueue(){front=rear=queuesize-1;}      ~seqqu...
顺序队列的创建、初始化、判断空、入队、出队、读取队头元素、置空、求队长操作
一叶知秋
01-15 7546
顺序队列的创建、初始化、判断空、入队、出队、读取队头元素、置空、求队长操作 代码如下： //队列的顺序存储 #include #include #include #define MAXSIZE 100 //顺序队列的最大容量 typedef int DataType; //#define DataType int typedef struct{ DataType data[MAXSIZ
C语言实现循环队列基本操作（初始化、判断队空、入队、出队）
u012913936的博客
07-07 2万+
//循环队列的基本操作 #include #define MaxSize 50 typedef int ElemType; //定义循环队列结构体 typedef struct  { ElemType data[MaxSize]; int front,rear; }SqQueue; //初始化 void InitQueue(SqQueue &Q) { Q.
循环队列的实现（初始化、入队操作、出队操作、判满、判空、获取队头、队尾元素、销毁操作）
weixin_46153828的博客
03-15 3442
typedef struct { int* array; int front; int rear; int count; //用count++的方式判断循环队列是否满 int N; //总个数 } MyCircularQueue; //初始化 MyCircularQueue* myCircularQueueCreate(int k) { MyCircularQueue* myQueue=(MyCircularQueue*)malloc(sizeof(MyCircu...
5.队（创建，入队，出队，判断队列是否为空）
toby6666的博客
05-24 1005
1.创建：通过二级指针创建队 2.入队和出队：通过尾进头出逻辑 #include<stdio.h> #include<stdlib.h> //尾进头出 typedef struct node { int nValue; struct node* pNext; }QueueNode;//节点 typedef struct queuenode { ...
队列的入队、出队操作实现
KobeBryant0313的专栏
05-10 1246
C++代码如下： #include #include #include #include using namespace std; typedef struct student { int data; struct student *next; }node; typedef struct linkqueue //队列有两个节点，头节点和尾节点 { node *first,*
使用数组模拟队列，定义队列头和队列尾两个指针，队列为空时头尾指针相等且指向队列头部。 对于入队操作，判断队列是否已满，如果已满则无法入队；否则将元素加入队列尾部，队列尾指针后移。 对于出队操作，判断队列是否为空，如果为空则无法出队；否则返回队列头部元素并将头指针后移。 C语言代码
最新发布
04-02
#define MAX_SIZE 100 // 队列最大容量 int queue[MAX_SIZE]; // 队列数组 int front = 0, rear = 0; // 队列头和尾指针 // 判断队列是否为空 int is_empty() { return front == rear; } // 判断队列是否已满 int is_full() { return rear - front == MAX_SIZE; } // 入队操作 void enqueue(int x) { if (is_full()) { printf("Queue is full.\n"); return; } queue[rear++] = x; } // 出队操作 int dequeue() { if (is_empty()) { printf("Queue is empty.\n"); return -1; } return queue[front++]; }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值