数据结构与算法：队列

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

前言

本文主要讲解队列，使用数组模拟单向队列和环形队列

数据结构与算法文章列表

数据结构与算法文章列表: 点击此处跳转查看

目录

在这里插入图片描述

（一）队列介绍

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

（二）数组模拟队列思路分析图

队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中maxSize 是该队列的最大容量。
因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front及rear分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear则是随着数据输入而改变，如图所示:
刚开始初始化的时候，rear（后端）和front（前端）都是-1，
如果往队列里面添加数据，则rear（后端）增加， front（前端）不变
如果往队列里面获取数据，则front（前端）增加，rear（后端）不变

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

（三）数组模拟队列代码实现

package com.lzacking.queue;
import java.util.Scanner;
public class ArrayQueueDemo {
     public static void main(String[] args) {
          // 创建一个队列
          ArrayQueue queue = 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':
                   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) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                   }
                   break;
              case 'h': // 查看队列头的数据
                   try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                   } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                   }
                   break;
              case 'e': //退出
                   scanner.close();
                   loop = false;
                   break;
              default:
                   break;
              }
          }
          
          System.out.println("程序退出~~");
     }
}

// 使用数组模拟队列-编写一个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;
     }

     // 判断队列是否为空
     public boolean isEmpty() {
          return 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]);
          }
     }

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

结果：

s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
s
队列空的，没有数据~~
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
a
输出一个数
1
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
a
输出一个数
21
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
s
arr[0]=1
arr[1]=21
arr[2]=0
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
g
取出的数据是1
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
h
队列头的数据是21
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
s
arr[0]=1
arr[1]=21
arr[2]=0
s(show): 显示队列
e(exit): 退出程序
a(add): 添加数据到队列
g(get): 从队列取出数据
h(head): 查看队列头的数据
e
程序退出~~

该代码的问题是数组只能使用一次，不能达到复用的效果
例如向队列添加3个数据（队列最多添加3个数据），取出其中一个，如果再添加一个就不能添加了

（四）数组模拟环形队列思路分析图

在这里插入图片描述
思路如下:

  1. front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素 front 的初始值 = 0
  2. rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定. rear 的初始值 = 0
  3. 当队列满时，条件是 (rear + 1) % maxSize == front 【满】
  4. 对队列为空的条件， rear == front 空
  5. 当我们这样分析， 队列中有效的数据的个数 (rear + maxSize - front) % maxSize // rear = 1 front = 0
  6. 我们就可以在原来的队列上修改得到，一个环形队列

总结：例如向队列添加3个数据（队列最多添加3个数据），取出其中一个，如果再添加一个仍然可以继续添加

取模补充：
mod的解释是这样的：
A Mod B = A - (A div B) * B （div含义为整除）
（如果A小于等于B，则A % B = A）

举例1： 11 mod 2 （11 % 2）
11 div 2 = 5 因为11除以2等于5.5，取整为5
11 % 2 = 11 - （11 div 2）* 2 = 11 - 5 * 2 = 1

举例1： 1 mod 10 （1 % 10）
1 div 10 = 0 因为1除以10等于0，取整为0
1 % 10 = 1 - （1 div 10）* 1 = 1 - 0 * 1 = 1

（五）数组模拟环形队列代码实现

package com.lzacking.queue;
import java.util.Scanner;
public class CircleArrayQueueDemo {
     public static void main(String[] args) {
          
          //测试一把
          System.out.println("测试数组模拟环形队列的案例~~~");
          
          // 创建一个环形队列
          CircleArray queue = new CircleArray(4); //说明设置4, 其队列的有效数据最大是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':
                   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) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                   }
                   break;
              case 'h': // 查看队列头的数据
                   try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                   } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                   }
                   break;
              case 'e': // 退出
                   scanner.close();
                   loop = false;
                   break;
              default:
                   break;
              }
          }
          System.out.println("程序退出~~");
     }
}

class CircleArray {
     private int maxSize; // 表示数组的最大容量
     //front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素
     //front 的初始值 = 0
     private int front;
     //rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
     //rear 的初始值 = 0
     private int rear; // 队列尾
     private int[] arr; // 该数据用于存放数据, 模拟队列
     
     public CircleArray(int arrMaxSize) {
          maxSize = arrMaxSize;
          arr = new int[maxSize];
     }
     
     // 判断队列是否满
     public boolean isFull() {
          return (rear  + 1) % maxSize == front;
     }
     
     // 判断队列是否为空
     public boolean isEmpty() {
          return 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
          // front = 1
          // maxSize = 3
          return (rear + maxSize - front) % maxSize;   
     }
     
     // 显示队列的头数据， 注意不是取出数据
     public int headQueue() {
          // 判断
          if (isEmpty()) {
              throw new RuntimeException("队列空的，没有数据~~");
          }
          return arr[front];
     }
     
}

（六）总结

（1）为什么第一种数组模拟队列当数据满时，即使取出数据也不能继续添加？
第一种数组模拟队列：
添加数据：

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

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

当rear == maxsize - 1时，即数据满时就不能继续添加

（2）但是第二种即使数据满了，只需要删除队列前面的数据，仍然可以继续添加数据？
第二种数组模拟队列：
添加数据：

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

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

关键就是rear = (rear + 1) % maxSize;
其中maxsize = 4
rear = 0，1，2，3，4，5，7，8，9，10，11
rear = 1，2，3，0，1，2，0，1，2，3，0

只需要删除队列前面的数据，仍然可以继续添加数据

LZacking.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
《数据结构与算法：Java语言描述》源码.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
JavaScript中数据结构与算法(二)：队列
10-24
主要介绍了JavaScript中数据结构与算法(二)：队列,队列是只允许在一端进行插入操作,另一个进行删除操作的线性表,队列是一种先进先出（First-In-First-Out，FIFO）的数据结构,需要的朋友可以参考下
队列的实现
weixin_46573014的博客
03-15 366
队列 应用场景 银行排队叫号 队列介绍 队列是一个有序列表，可以用数组(顺序存储)或者是链表(链式存储)来实现 遵循先入先出的原则。即：先存入队列的数据，要先取出，后存入的要后取出 rear：代表队列的尾部 front：代表队列的头部 取数据在队列的头部取，存数据在队列的尾部存。 数组模拟队列 当我们将数据存入队列时成为"addQueue"，addQueue的处理需要有两个步骤 将指针往...
循环队列的相关计算公式
smile4lee的博客
04-17 2万+
· 设front为队首指针，rear为队尾指针，m为队列最大容量。 入队： rear = (rear + 1) % m出队： front = (front + 1) % m队空： front = rear队满： front = (rear + 1) % m当前队列中的元素数目： n = (rear - front + m) % m
数据结构循环队列，数组实现，循环队列中如果不使用数据项计数字段items，而是通过front和rear计算队列是否为空或满或队列个数，那会很复杂
梦想巅峰
04-12 2041
package none002; //循环队列。。。 //循环队列中如果不使用数据项计数字段items，而是通过front和rear计算队列是否为空或满或队列个数，那会很复杂。而且在同一时间里， //当队列为空时与队列为满时，front和rear呈现相同的线性关系，所以有可能是满也有可能是空。 public class QueueApp { /** * @param args */
循环队列和树的计算公式
u012197749的博客
09-20 1403
2018/9/20 19:56:17 循环队列的计算公式： 设front为队首指针，rear为队尾指针，m为队列最大容量。 入队： rear = (rear + 1) % m 出队： front = (front + 1) % m 队空： front = rear 队满： front = (rear + 1) % m 当前队列中的元素数目： n = (rear - front +...
【Java数据结构与算法】队列
01-20
队列本身是个有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如图，其中5是该队列的最大容量（只代表我这个图） 因为队列的输出，输入都是分别从前后端来处理的，因此需要两个变量（头部）及（尾部）...
数据结构与算法&队列
12-23
因为队列的基本操作是入队和出队，因此需要两个变量front和rear分别记录队列前后端的下标，一开始front和rear都一同指向队列第一个元素的前一个位置，front会随着数据出队而改变，而rear则会随着数据的入队而改变。...
恋上数据结构与算法课件.rar
11-23
主要针对复杂度、链表、栈、队列、二叉树、B树、红黑树、集合。课件包含图片展示，容易理解，爱，就码上行动。
(rear + maxSize - front) % maxSize 公式的理解(文图详解,手把手)
m0_52475295的博客
04-05 2305
(rear + maxSize - front) \% maxSize 为了更加深入的了解这个算式为什么是这样,从而窥探算法的大门，于是我思考了一下，并且发现解法看完这个保证细致到位,各种算式计算例题一步到位
数据结构——图解循环队列长度计算问题
weixin_43914272的博客
03-06 1万+
队列定义是这样的 #define MAXSIZE 10 typedef struct{ ElemType data[MAXSIZE]; int front,rear; } SeqQueue; 一个队列 = 一个存放元素的数组 + 一个队头指针 + 一个队尾指针 front：控制出队 rear：控制入队 初始我们让rear = front = data[0] 元素出队：front++ 元素入队：rear++ 一直rear++便到达索引最大的位置，这个时候队列就满了不能再入队元素了吗？ 并不，如果同时也一
计算机二级front和rear什么意思,关于计算机二级考试内容
weixin_28739079的博客
07-12 2930
为了让大家更好的备考计算机二级考试，练习往年真题很重要，下面由出国留学网小编为你准备了“计算机二级考试内容office真题”，仅供参考，持续关注本站将可以持续获取更多的内容资讯！计算机二级考试内容office真题【一】选择题1.下列叙述中错误的是()。A.对于各种特定的输入，算法的时间复杂度是固定不变的B.算法的时间复杂度与使用的计算机系统无关C.算法的时间复杂度与使用的程序设计语言无关D.算法的...
数据结构（java版）--队列
weixin_43729563的博客
10-16 155
队列介绍 队列是一个有序列表，可以使用数组或者链表来实现。 遵循先入先出的原则，即：先存入队列的数据，先取出 示意图： 数组模拟队列 代码实现： package com.atguigu.queue; import java.util.Scanner; public class ArrayQueueDemo { public static void main(String[] args...
【数据结构】循环队列的front，rear指针以及队列满的条件、计算队列长度
热门推荐
技术斋
09-04 2万+
循环队列满时，数组中还有一个空的单元。如图4-12-8所示，我们认为，队列已经满了，也就是说，我们不允许出现4-12-7的右图情况出现。   队列满的条件是： (rear+1)%QueueSize == front 通用的计算队列长度的公式为： (rear - front+ QueueSize)%QueueSize
数据结构学习笔记-队列长度的计算
weixin_43727767的博客
06-30 1万+
 1.通用计算公式：l=(rear-front+n)%n   其中：l为当前队列的长度      rear为队列尾指针      front为队列头指针      n为队列可容纳的元素总数（即队列大小）  2.公式解析   队列中存在一种特殊情况：循环队列，一般定义循环队列的头指针front和尾指针rear均指向队列下标为0的位置，此时front=rear&l=0;在循环队列中插入元素，若队列未满（l<n）尾指针后移一位（rear++）;若队列已满（l==n）,则不能继续插入元素，应返回错误提
数据结构笔记3 队列（队列的顺序存储、链式存储）
Lora青蛙的博客
08-08 1174
队列(Queue)：具有一定操作约束的线性表 插入和删除操作：只能在一端插入，而在另一端删除。可进行插入的一端称为队尾（Rear），可进行删除的一端称为队头（Front）。 数据插入：入队列（AddQ） 数据删除：出队列（DeleteQ） 先来先服务 先进先出：FIFO
使用队列来获取数据
火星辉
08-11 723
参看：线程和队列 - TensorFlow 官方文档中文版 - 极客学院Wikihttp://wiki.jikexueyuan.com/project/tensorflow-zh/how_tos/threading_and_queues.html 我认为：每次训练时，从队列中取一个batch送到网络进行训练，然后又有新的图片从训练库中注入队列，这样循环往复。队列相当于训练库到网络模型间数...
【2011年全国试题3】已知循环队列存储在一维数组A[0…n-1]，且队列非空时，front和rear分别指向队头元素和队尾元素。若初始时队列为空，且
Anthony_4926
10-05 1万+
【2011年全国试题3】已知循环队列存储在一维数组A[0…n-1]，且队列非空时，front和rear分别指向队头元素和队尾元素。若初始时队列为空，且要求第一个进入队列的元素存储在A[0]处，则初始时front和rear的值分别是（B） A. 0, 0 B. 0, n-1 C. n-1, 0 D. n-1, n-1 首先理解"队列非空时，front和rear分别指向队头元素和队尾元素"。当队列中有一个元素时，front与rear都需要指向A[0...
数据结构与算法 - 队列
最新发布
09-12
队列（Queue）是一种先进先出（FIFO）的数据结构，类似于现实生活中排队的概念。它有两个基本操作：入队（enqueue）和出队（dequeue）。 入队操作将元素添加到队列的末尾，出队操作则从队列的头部移除元素并返回它...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值