《Java数据结构与算法》入门篇：队列

最新推荐文章于 2022-09-28 19:57:07 发布
最新推荐文章于 2022-09-28 19:57:07 发布
阅读量328 收藏
点赞数
分类专栏： Java数据结构与算法 文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/supre_authority/article/details/114320328
版权

队列

介绍

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

数组实现队列

思路分析

  • 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如上图，其中maxSize是该队列的最大容量。
  • 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量front和rear分别记录队列前后端的下标，front会随着数据的输出而改变，rear则是随着数据的输入而改变（如上图所示）
  • 当我们将数据存入队列时称为“addQueueu”，addQueue的处理需要两个步骤：
    1. 将尾指针往后移动：rear = rear + 1，当front == rear时，则表示当前队列为空
    2. 若尾指针rear小于队列的最大下标maxSize-1，则将数据存入rear所指的数组元素中，否则无法存入数据。当rear == maxSize - 1时，则表示当前队列已满

代码实现

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("p(pop): 从队列取出数据");
            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 'p':
                    try {
                        int res = queue.popQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }

            System.out.println();
            System.out.println();
            System.out.println();
        }

        System.out.println("程序退出~~");
    }

}


/**
 * 队列对象
 */
class ArrayQueue {

    /**
     * 队列的最大容量
     */
    private int maxSize;

    /**
     * 队列头
     */
    private int front;

    /**
     * 对列尾
     */
    private int rear;

    /**
     * 存放数据的队列
     */
    private int[] arr;

    /**
     * 创建队列构造器
     *
     * @param maxSize
     */
    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        this.arr = new int[maxSize];

        // 指向队列头部，根据前面的分析，front是指向队列头的前一个位置
        this.front = -1;

        // 指向队列尾部，也就是队列最后一个数据，初始情况下与front一致
        this.rear = -1;
    }

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

    /**
     * 判断队列是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return this.front == this.rear;
    }

    /**
     * 向对列中添加数据
     *
     * @param n
     */
    public void addQueue(int n) {
        // 先判断队列是否已满
        if (isFull()) {
            System.out.println("队列满，不能添加数据~~~~~~~~~~~~~~~~~~~~");
            return;
        }

        // 队列未满，则添加数据

        // 先将尾部指针向后移动1位
        rear++;

        // 赋值
        this.arr[rear] = n;
    }

    /**
     * 从队列中取出数据
     *
     * @return
     */
    public int popQueue() {
        // 先判断队列是否为空
        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]);
        }

    }

    /**
     * 显示队列的头数据，注意不是取出数据
     *
     * @return
     */
    public int headQueue() {
        // 判断队列是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列空，不能取出数据~~~~~~~~~~~~~~~~~~~~");
        }

        // 注意：此处并没有移动"front"，要看清和"popQueue"中的区别
        return this.arr[front + 1];
    }

}

问题分析并优化

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

数组实现环形队列

分析说明

  1. 尾索引的下一个位头索引时表示队列已满，即将队列容量空出一个作为约定，这个在做判断队列满的时候需要注意：(rear + 1) % maxSize == front，即表示为队列已满
  2. 判断队列为空的方式仍然是 rear == front

思路分析

  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
  6. 我们可以在原来队列的基础上进行修改，得到一个环形队列

代码实现

public class CircleArrayQueueDemo {

    public static void main(String[] args) {

        // 创建一个队列
        // 注意：这里设置为4，队列中有效数据个数最大是3
        CircleArray queue = new CircleArray(4);

        // 接收用户输入
        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("p(pop): 从队列取出数据");
            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 'p':
                    try {
                        int res = queue.popQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }

            System.out.println();
            System.out.println();
            System.out.println();
        }

        System.out.println("程序退出~~");
    }

}


class CircleArray {


    /**
     * 队列的最大容量
     */
    private int maxSize;

    /**
     * 队列头
     */
    private int front;

    /**
     * 对列尾
     */
    private int rear;

    /**
     * 存放数据的队列
     */
    private int[] arr;


    /**
     * 创建队列构造器
     *
     * @param maxSize
     */
    public CircleArray(int maxSize) {
        this.maxSize = maxSize;
        this.arr = new int[maxSize];

        // front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素
        this.front = 0;

        // rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置
        this.rear = 0;
    }


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

    /**
     * 判断队列是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return this.front == this.rear;
    }


    /**
     * 向对列中添加数据
     *
     * @param n
     */
    public void addQueue(int n) {
        // 先判断队列是否已满
        if (isFull()) {
            System.out.println("队列满，不能添加数据~~~~~~~~~~~~~~~~~~~~");
            return;
        }

        // 队列未满，则添加数据

        // 先赋值
        this.arr[rear] = n;

        // 再将尾部指针向后移动1位，需要进行取模
        rear = (rear + 1) % maxSize;
    }


    /**
     * 从队列中取出数据
     *
     * @return
     */
    public int popQueue() {
        // 先判断队列是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列空，不能取出数据~~~~~~~~~~~~~~~~~~~~");
        }

        // 队列中存在数据，则可以取出

        // 这里需要分析出：front指向队列中的第一个元素

        // 1. 先把front对应的值取出来保存到一个临时变量
        int temp = arr[front];

        // 2. 将front向后移动1位，同样需要考虑取模
        front = (front + 1) % maxSize;

        // 3. 将临时保存的值返回
        return temp;
    }


    /**
     * 求出当前队列有效数据的个数
     *
     * @return
     */
    public int size() {
        return (rear + maxSize - front) % maxSize;
    }

    /**
     * 展示队列中的所有数据
     */
    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]);
        }

    }

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

}
一生都在战斗
关注
专栏目录
【数据结构与算法 一】基本概念、结构和学习方法
MaoLin Tian's Blog
03-21 263
算法与数据结构一直是我感觉难以迈过去的坎，后悔大学的时候没有好好学习，导致造成了内心的阴影，每次都有逃避的情绪在里面，这次决定通过学习和实践王争的《数据结构与算法之美》来帮助自己迈过去。按照这门课程的学习路线划为四个阶段： 入门篇：掌握时间、空间复杂度的概念，大 O 表示法的由来，各种复杂度分析技巧，以及最好、最坏、平均、均摊复杂度分析方法，掌握 基础篇：掌握最基础、最常用的数据结构和算法，例如数组、链表、栈、队列、二叉树等。这部分我感觉类似于二八原则，可以用20%的世界快速获得性价比最高的80%的基础内
阿里P9整理出千页笔记：Java程序设计与数据结构基础+进阶
lt_xiaodou的博客
08-13 407
全面整合了Java 8的特性，采用“基础优先，问题驱动”的教学方式，循序渐进地介绍了程序设计基础、解决问题的方法、面向对象程序设计、图形用户界面设计、异常处理、/O和递归等内容。此外，本书还全面且深入地覆盖了一些高级主题，包括算法和数据结构、多线程、网络、国际化、高级GUI等内容。主要特点+作者简介​。...
java队列
04-19
NULL 博文链接：https://hoochiang.iteye.com/blog/1858476
java中queue的使用
Beyond_the_Limits的专栏
06-04 796
[size=medium]java中queue的使用 Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接 口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的...
java队列 同步_JUC-队列Queue-同步队列入门
weixin_39717026的博客
02-21 152
/**@Author: CYW@Date: 2020/11/19 22:41SynchronousQueue:同步队列继承于BlockingQueue,和其他的队列不同,它不存储元素,put进一个值就必须取出来才能再次put*/public class SynchronousQueueTest {public static void main(String[] args) {BlockingQue...
Java 实例 - 队列（Queue）入门用法
ych0108的博客
11-23 460
队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。 LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。 以下实例演示了队列（Queue）的用法： 队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。 LinkedList类实现了Queue接口，因此我们可以把LinkedList...
队列java代码完整版，适合小白的数据结构入门篇
貔貅
07-15 287
队列 队列的介绍 队列是一个有序列表 ，可以用数组和链表来实现 遵循先入先出的原则，即先存进队列的数据，要先取出，后存入的数据要后取出 队列示意图：
新星计划Day4【数据结构与算法】 稀疏数组与队列
qq_46272491的博客
04-28 2081
新星计划Day4【数据结构与算法】 稀疏数组与队列 👩‍💻博客主页：京与旧铺的博客主页 ✨欢迎关注🖱点赞🎀收藏⭐留言✒ 🔮本文由京与旧铺原创，csdn首发！ 😘系列专栏：java学习 💻首发时间：🎞2022年4月28日🎠 🎨你做三四月的事，八九月就会有答案，一起加油吧 🀄如果觉得博主的文章还不错的话，请三连支持一下博主哦 🎧最后的话，作者是一个新人，在很多方面还做的不好，欢迎大佬指正，一起学习哦，冲冲冲 🛒导航小助手🎪 文章目录新星计划Day4【数据结构与算法】 稀疏数组与队列在这里插入图片描述🛒导
初探数据结构与算法：从入门到应用
### 一、 数据结构与算法的基础概念 数据结构和算法是计算机科学中非常重要的基础概念，对于程序员来说，它们是必备的核心知识。本章将介绍数据结构和算法的基本概念，帮助读者建立起扎实的基础。首先我们将会讨论...
JAVA的队列学习
shuyan745294340的博客
03-06 249
队列:就是先进先出表 public class sq{ //创建一个数组 private int[] a; //队列的最大长度 private int maxsize; //队列的前端 private int front; //队列的后端 private int rear; public sq(int size){ maxsize = size; front = 0; rear = -1; ite...
JAVA 简单队列讲解
杉 言
04-17 272
队列(Queue)在基本上来说它就相当于简单的模拟了人类排队的一个过程，它是遵循了先入先出的数据结构，Queue接口与List、Set接口是同一级别的,它们都是继承了Collection接口，并且Queue使用LinkedList类来实现Deque接口。 ...
Java基础 - 队列
fkidi的博客
03-30 1223
title: Java基础 - 队列 date: 2022-03-24 13:32:11 tags: Java 队列 是 先进先出( FIFO，First In, First Out) 的线性表。在具体应用中通常用链表或者数组来实现，用数组实现的队列叫作 顺序队列 ，用链表实现的队列叫作 链式队列 。 队列的操作在两端进行，即 在后端（rear）进行插入操作也就是 入队 enqueue，在前端（front）进行删除操作也就是出队 dequeue 在队列中，删除的数据还保留着内存中，但头指针已不再指.
JAVA基础（66）---队列
11onhook的博客
11-20 212
队列 是一种先进先出（FIFO）的线性表，只能在表的一端（队尾）进行插入，在另一端（队头）进行删除运算的线性表。 逻辑结构：与线性表相同，仍为一对一关系 存储结构：用顺序队列或链队存储均可 运算规则：先进先出（FIFO） 实现方式：关键是编写入队和出队的函数，具体实现 依顺序对或链队的不同而不同 实现 线性表有顺序存储和链式存储，队列是一种特殊的线性表，同样也存在这两种存储方式。...
Java-队列的基本操作
qq_51537858的博客
09-28 2729
队列是数据结构中比较重要的一种类型（是一种数据结构），它支持 FIFO，尾部添加、头部删除（先进队列的元素先出队列），跟我们生活中的排队类似。队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。
JAVA基础:用Java实现HTTP文件队列下载
涅 磐
01-10 491
 序言　　许多用户可能会遇到这样的情况：在网站上发现一个很好的资源，但是这个资源是分成了很多个文件存放的，如果想把它保存到本地，只有靠用户点击另存来完成保存，如果资源分了几百甚至上千上万，那简直是个灾难。 　　在Internet上很多的资源分成多个文件存放时，它的文件命名是有一定的规则的；正因如此，我们就可以用程序来完成这个资源的完全下载。　　1. 基础知识　　在Internet上，我们要下载
JAVA消息队列之ActiveMQ入门
热门推荐
赵庆春
04-16 1万+
消息中间件前言本文只适合初级入门，阐述了消息中间件的基础概念，和部分实践，理论性比较强。为什么要使用消息中间件有一家专业做保险的大公司，他有一套保险系统，记录着保险销售的所有信息，他在全国有38家分公司，每一家分公司都有自己的保险系统，总公司与分公司之间有着保单数据共享的关系，总公司每销售一份保险都要向分公司提供该保单的基本信息，而分公司每销售一份保险也需要向总公司和其他分公司提供该保单的基本信息...
Java中队列的基本使用
qq_36719861的博客
03-20 8875
队列是一个典型的先进先出的容器，Java中LinkedList提供了方法以支持队列的行为，并且它实现了Queue接口，因此LinkedList可以用作Queue的一种实现。下面举例说明： import java.util.*; public class Main { public static void main(String[] args) { Queue<I...
Java版数据结构与算法详解：入门到实践
"《数据结构与算法分析 (Java版)》是由Robert Lafore所著的一本面向Java程序员的数据结构与算法入门教材。该书出版于1998年，由Sams出版社发行，共617页，适合有一定编程基础，尤其是熟悉Java或C++语言的读者学习。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值