学习笔记-队列

最新推荐文章于 2023-01-08 00:46:51 发布
最新推荐文章于 2023-01-08 00:46:51 发布
阅读量131 收藏
点赞数
分类专栏： 数据结构 文章标签： java 数据结构 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39595769/article/details/121455261
版权

队列的一个使用场景

银行排队的案例:

在这里插入图片描述

队列介绍

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

数组模拟队列思路

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

当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤：
思路分析

1) 将尾指针往后移：rear+1 , 当 front == rear 【空】 
2) 若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear 所指的数组元素中，否则无法存入数据。 rear == maxSize - 1[队列满]

代码实现

package com.eistert.java.datastructure.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]);
        }
    }

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

问题分析并优化

  1. 目前数组使用一次就不能用， 没有达到复用的效果
  2. 将这个数组使用算法，改进成一个环形的队列 取模：%

数组模拟环形队列

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

  1. 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定,这个在做判断队列满的 时候需要注意 (rear + 1) % maxSize == front 满]
  2. rear == front [空]
  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. 我们就可以在原来的队列上修改得到，一个环形队列

代码实现

package com.eistert.java.datastructure.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];
    }
}

内容来源

B站尚硅谷Java数据结构与Java算法
https://www.bilibili.com/video/BV1E4411H73v?from=search&seid=6092841764380950204&spm_id_from=333.337.0.0

本内容只用于本人学习与复习用，涉及到版权问题，联系我，立即删除。

GitHub地址，欢迎关注，不定期更新内容，点亮技能树。

Java数据结构与Java算法模块地址

环形队列代码地址

Eistert
关注
专栏目录
队列的实现（JAVA）
wodengniyujiul的博客
03-19 2920
数据结构(JAVA) 中队列的实现
java实现队列
u011723409的博客
07-10 2889
java实现队列
java队列实现（顺序队列、链式队列、循环队列）
07-27
java队列实现（顺序队列、链式队列、循环队列）
JAVA算法-队列
qq_42913729的博客
11-02 444
队列的一个使用场景 银行排队的案例: 队列介绍 队列是一个有序列表，可以用数组或是链表来实现。 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 示意图：(使用数组模拟队列示意图) - 数组模拟队列思路 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队 列的最大容量。 因为队列的输出、输入是分别从前后...
java 队列实现
热门推荐
张凡的专栏
03-05 1万+
队列其实 所指生活中排队的现象，去商场购物，付款时需要排队， 买饭时需要排队， 好多事情都是需要排队， 排在第一位的则先处理，结束后， 后面的人都像前移动一位，在开发中也有好多这样的事情需要处理，如文件的下载，短信的发送功能， 等这些都是需要队列方式实现。好了， 废话不多说， 详情见下面代码！ package com.fanzhang; class Queue   //队列类   
学习笔记-栈与队列,包括单调栈和单调队列
最新发布
08-20
学习笔记-栈与队列,包括单调栈和单调队列
Redis全套学习笔记-带章节目录-114页.pdf
06-13
Redis全套学习笔记 Redis是一种基于内存的NoSQL数据库，具有高性能、可扩展性和灵活性等特点。以下是Redis的详细知识点： 安装和启动 * 安装Redis可以通过下载软件包或使用yum、apt-get等安装工具进行安装。 * ...
算法数据结构学习笔记-C语言.zip
06-14
《算法数据结构学习笔记-C语言》是一份专为新手设计的C语言学习资源，它将带你深入探索C语言的世界，并逐步掌握算法与数据结构的基本概念和应用。在C语言这个强大的编程工具下，理解并运用算法和数据结构是提升编程...
Java实现队列
m0_62404808的博客
01-08 2607
队列也是常见的数据结构，是一种线性数据结构，队列的主要特点：“先进后出”。队列有队头和队尾，一般在队尾进行插入操作，队头进行删除操作。
队列（Java实现）
weixin_44720982的博客
04-18 2062
Java数据结构之队列的实现
用Java实现一个队列
01-10
用Java实现一个队列
队列的Java实现
机械工程跑路哥
02-17 2415
一.概述 队列是一种基于先进先出(FIFO)的数据结构，是一种只能在一端进行插入, 在另一端进行删除的特殊线性表， 它按照先进先出的原则存储数据，先进入的数据，在读取数据时先读被读出来。 插入元素时：每次直接插到末尾即可（尾插法），新插入的元素即为新的尾结点last。（区别于栈的头插法） 取出元素时：返回首结点指向的下一个元素即可。（先进先出），此时和弹栈一样。 总结：队列为尾插头取，栈为头插头取 二.用链表实现队列 public class Queue<T> implements Ite
Java队列实现
分外蓝
03-21 324
队列简单介绍 队列是一种常用的数据结构之一，与之前的栈类似，不过队列是“先进先出”。队列有队头（front）和队尾（rear），数据从队尾进入队列，从队头出队列，队头（front）指向队列的第一个数据，队尾（rear）指向队列中的最后一个数据。 队列实现 队列有很多种，这里只是介绍最基本的实现，采用链式存储，也就是链式队列，与之前的链表存储形式一样，通过结点对象描述一个数据，结点对象包含具体数据...
有序队列（Java版）
A_bad_horse的专栏
03-13 1345
public class PriorityQ { private long[] queArray; private int maxSize; private int nItems; public PriorityQ(int size) { maxSize = size; queArray = ne...
队列的java实现
weixin_53148080的博客
08-21 164
用Java实现顺序队列 队列简介 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。 队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in firs
Java数据结构：有序优先队列
Just For Learning
07-28 1129
优先队列可以解决操作系统中cpu处理优先级进程的问题例如小明在做菜在这是小明当前最高级别的进程，但是突然老妈喊他出来帮忙，处理老妈的进程就变为了比做菜更高一级的进程，那么这个时候就用到优先队列数据结构处理这样的一个变化。...
java队列的实现_java 队列的实现
weixin_36035900的博客
02-20 315
List list = new LinkedList<>();Queue queue = new LinkedList();queue.offer("a");queue.offer("b");offer，add 区别：一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，多出的项就会被拒绝。这时新的 offer 方法就可以起作用了。它不是对调用 add() 方法抛出一个 unch...
Linux驱动与G-Sensor学习笔记
工作队列（workqueue）是Linux内核中的一个调度机制，用于将工作从中断上下文移动到进程上下文执行，这在处理非紧急但需要延迟执行的任务时非常有用，比如g-sensor的数据处理和上报。 在HAL（Hardware Abstraction ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值