数据结构与算法-02（队列与环形队列）

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

队列

应用场景和介绍

  • 队列是一个有序列表，可以用数组或是链表来实现
  • 遵循先入先出的原则。 即：先存入队列的数据，要先取出，后存入的要后取出
  • 示意图：（使用数组模拟队列示意图）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6J4xsKDY-1635813370672)(C:\Users\鲜芳\AppData\Roaming\Typora\typora-user-images\1635561488287.png)]
![在这里插入图片描述](https://img-blog.csdnimg.cn/85618beba2e04652b888c9be821de7c6.png#pic_center

![在这里插入图片描述](https://img-blog.csdnimg.cn/d6606d2780ea4f28a948728b76369227.png#pic_center

  • 队列本身是有序列表，若是使用数组的结构来存储队列的数据，则队列数组的声明如下图，其中maxSize是该队列的最大容量
  • 因为队列的输出，输入是分别从前后端来处理，因此需要两个变量front及rear分别记录前后端的下标，front会随着数据的输出而改变，而rear则是随着数据输入而改变，如图

在这里插入图片描述

思路分析

  • 当我们将数据存入队列时 称为 addQueue，addQueue的处理需要有两个步骤

    1.将尾指针向后移 rear+1,当front==rear【空】

    2.若尾针rear小于队列的最大下标maxSize-1,则将数据存入rear所指的数组元素中 否则无法存入数据，rear==maxSize-1 【队列满】

代码实现

package ojbk;

import java.util.Scanner;

/**
 * @author 使用数组模拟队列
 */
public class ArrQueue {
    public static void main(String[] args) {
        /**测试*/
        ArrayQueue arrQueue = new ArrayQueue(3);
        char key=' ' ;
        Scanner sc = 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=sc.next().charAt(0);
            switch (key){
                case 's':
                    arrQueue.showQueue();
                    break;
                case 'a':
                    try{
                        System.out.println("输入一个数");
                        int value = sc.nextInt();
                        arrQueue.addQueue(value);
                    }catch (Exception e){

                    }
                    break;
                case 'g':
                    try{
                        int queue = arrQueue.getQueue();
                        System.out.println("取出的数据为："+queue);
                    }catch (Exception e){

                    }
                    break;
                case 'h':
                    try{
                        int i = arrQueue.headQueue();
                        System.out.println("头数据为："+i);
                    }catch (Exception e){

                    }

                    break;
                case 'e':
                    loop=false;
                    break;
                default:
                    throw new IllegalStateException("Unexpected value: " + key);
            }

        }

    }
}

/**使用数组模拟队列  - 编写一个ArrayQeueu*/
class ArrayQueue{
    /**表示数组的最大容量*/
    private int maxSize;
    /**队列头指针*/
    private int front;
    /**队列尾指针*/
    private int rear;
    /**该数组用于存放数据，模拟队列*/
    private int[] arr;


    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        this.arr=new int[maxSize];
        this.front=-1;
        this.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++;
        arr[rear]=n;
    }
    /**获取数据的数据，出队列*/
    public int getQueue(){
        /**判断队列是否为空*/
        if(isEmpty()){
            throw new RuntimeException("队列为空，不能取数据");
        }
        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];
    }
}

问题分析与优化：

  1. 就是当取出数据后，所在的数组下标的空间不可以复用
  2. 将这个数组使用算法，改进成一个环形数组 %

使用数组模拟环形队列

  • 对前面的数组模拟队列的优化，充分利用数组，因此将数组看做是一个环形的（通过%来实现即可）
  • 分析说明
    1. 尾索引的下一个头索引时表示队列满，即将队列的容量空出一个作为约定，这个在做判断队列满的时候需要注意（rear+1） % maxSize==front 满
    2. rear==front [空]
    3. 代码演示
    4. 将front 想像成一个指针 当队列满的时候 取出头部元素 然后新增的元素会插入到头部，指针随着插入元素而移动 这里就体现出了取模的妙用。
    5. rear是指向最后一个预留空间（目的是当rear满的时候 rear可以判断是否是满 还是空的两种情况 也就是说 如果这个数组长度为3，那么只能存两个元素 预留一个空间来做判断。。。。），比如当队列满（size+1）的时候 最后一个空间为空，此时再添加元素 会将该元素添加到rear指向的最后一个空间 （我具体不知道为什么要预留一个空间，知道的大佬可以在评论区留言，谢谢）
/**
 * @author 使用数组模拟队列
 */
public class ArrQueue {
    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];
    }

}
一只 Tomcat
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构与算法 - 环形队列】
04-18
环形队列是一种特殊形式的线性数据结构，它在物理结构上表现为一个首尾相接的循环序列，常用于解决需要高效处理入队和出队操作的问题。在环形队列中，当队列满时，新的元素将替换掉队首的元素，而不是像普通队列那样...
日期处理工具
MamboTango的博客
01-15 200
package com.kingxunlian.purchase.suppliermanagement.util; import org.apache.commons.lang3.StringUtils; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList;...
零基础学Java语言课后习题——浙江大学翁恺
weixin_53401658的博客
10-09 1224
本着学习java的想法，学习了该课程。写了一些简单的代码，仅供参考。如果也有在学习此课程的同学，对题目的代码有更好的想法，还请不吝赐教。 代码会不断更新，敬请期待......
Java数据结构与算法02——队列
12-21
Java中的数据结构与算法是编程领域中至关重要的概念，它们为高效地处理和组织数据提供了...对于初学者来说，从简单的数组模拟开始，逐步深入到链表、环形队列以及更高级的队列实现，是学习数据结构与算法的有效路径。
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
java数据结构与算法.pdf
01-04
在编程领域，数据结构与算法是核心组成部分，它们直接影响到程序的效率和性能。Java作为广泛应用的编程语言，其在实现数据结构和算法时有着丰富的库支持和优秀的可读性。下面将对标题和描述中提到的一些关键知识点...
【数据结构】顺序表和链表——链表（包含大量经典链表算法题）
2301_80191662的博客
09-03 1502
数据结构链表的相关知识以及相关算法题
【数据结构】单链表
2401_82759674的博客
08-30 815
大家是否记得我们在顺序表中留下的几个问题？对于顺序表的空间浪费和插入耗时过长，我们的解决方法就是使用新的数据结构——链表。这篇博客讲述了链表的概念和结构，对链表的最简单的结构——单链表，实现了它的增删查改，最后补充了链表的分类，让大家对链表有个整体了解。
数据结构-栈和队列
weixin_74312694的博客
08-30 1115
栈（Stack）是一种特殊的线性表，其只允许在表的进行插入和删除操作。栈顶：进行插入数据和删除数据的一端。栈底：相对于栈顶的另一端。原则：栈的数据元素遵循LIFO( Last In First Out )的原则通过图也能明显看出栈的特点只有当栈顶元素出栈后，才能出后面的元素，有点类似于手枪的弹夹，用的时候先一个一个把子弹压进去，最后压进去的子弹最先打出，所以有的进栈也称为压栈。
经典数据结构-栈计算逆波兰表达式
一个好学的低级程序猿
09-05 247
栈计算逆波兰表达式
滑动窗口系列(不定长滑动窗口长度) 9/2
2301_78191305的博客
09-02 1167
移动right的时候，需要更新costK，costK=(nums[right]-nums[right-1])*(right-left);逆向思维就是：题目中是否存在一段子串满足字符出现最多的次数为:count[0]-k,count[1]-k,count[2]-k。每次遍历到一个字符，就将出现的次数-1(还可以出现多少次)，如果出现<0的情况，左边界就要改变了。每次操作的时候，移除左边和右边的元素，使得移除元素之和=x。给定一个数组nums,求子数组中删除k个元素后，所有元素都相等，返回相同元素的最大个数。
Java-数据结构-ArrayLis与线性表 (๑╹◡╹)ﾉ“““
2303_80388948的博客
08-30 1636
我们可以看到这个图片的最左边呢就是我们List，这个List继承了 Collection 接口，Collection接口又继承了 Iterable，接口，所以我们的 List 接口就有了这两个接口的所有方法。在我们站在数据结构的角度来看呢，List 接口就是一个线性表，就是n个具有相同类型的元素的有限序列 ，在这个序列上可以进行增删查改的操作。注意我们的List是一个接口，不能实例化，要是使用的话，只能去实例化List的实现类。
【数据结构】单链表功能的实现
2302_81312180的博客
09-03 963
图中指针变量 plist保存的是第一个节点的地址，我们称plist此时“指向”第一个节点，如果我们希望plist“指向”第二个节点时，只需要修改plist保存的内容为0x0012FFA0。链表中每个节点都是独立申请的（即需要插入数据时才去申请一块节点的空间），通过指针变量保存下一个节点位置才能从当前节点找到下一个节点。且每节车厢都有车门，假设每节车厢的车门都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带一把钥匙的情况下。与顺序表不同的是，链表里的每节"车厢"都是独立申请下来的空间，我们称之为“链表中每个
Redis高级----五种数据结构及其底层实现
m0_73171073的博客
08-30 1442
底层结构：在redis3.2之前list的实现主要使用了LinkecList和ZipList来使用的，当数据量数据量小于512个或者大小小于64字节的时候使用的是ZipList，当数据量较大的时候使用的使用LinkedList来进行储存，因为ZipList底层使用的数组来模拟的双向链表的形式。需要连续的空间，申请代价较大。注意如果一开始set创建时使用的是intset作为底层的数据结构（即一开始初始化时储存的值是整形），那么当我们要存储字符串时，这是后就会将其底层的类型进行改变，改编成使用Dict类型。
【数据结构】Map的使用与注意事项
Yeeear的博客
09-02 5501
Map的概念，Map中各种方法的用法（put、get、getOrDefault、remove、keySet、entrySet）以及注意事项
数据结构---循环队列---树的基本概念
m0_65301172的博客
08-30 858
循环队列的循环思想很重要，也要知道为啥要使用循环队列，循环队列是如何实现循环的，如何判断队空，对满；树呢，二叉树是用的最多的，其中要分清满二叉树和完全二叉树；还有就是满二叉树中的节点个数的计算。
【数据结构】归并排序
最新发布
Demon___1的博客
09-05 435
主要讲解了归并算法的基础思路和实现
二叉树（数据结构）
2302_79712403的博客
08-30 974
1.一棵二叉树，如果。也就是说，。2.完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。2二叉树的性质1.若规定，则一棵2.若规定只有，则(k>=0)3.对任何一棵二叉树如果其4.具有5.对于具有，如果按照，则对于若i>0；，无双亲结点和。常见是类似于链表的链式存储。
数据结构与算法：队列的表示与应用
"该资源是针对数据结构与算法的课程讲解，特别关注队列这一主题。内容涵盖了顺序队列和链表队列的介绍，适合软件学院2010级本科生学习，旨在2011-2012学年的秋季学期进行教学。" 在计算机科学中，数据结构与算法是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值