数据结构与算法之队列

最新推荐文章于 2024-10-12 13:42:32 发布
原创 最新推荐文章于 2024-10-12 13:42:32 发布 · 268 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

队列

队列的介绍

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

数组模拟队列

  • 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组声明如下图
    在这里插入图片描述
  • 因为队列的输出，输入是分别从前后端来处理的，因此需要两个变量fromt及rear分别记录队列前后端的下标，fromt会随着数据输出而改变，而rear则是随着数据输入而改变
  • 当我们将数据存入队列时称为"addQueue", addQueue的处理需要有两个步骤: 思路分析
    • 将尾指针往后移: rear+1 ，当front == rear [空]
    • 若尾指针 rear 小于队列的最大下标 maxSize-1 ，则将数据存入rear所指的数组元素中，否则无法存入数据。rear == maxSize-1[队列满]
  • 代码实现
  • 问题分析并优化
    1. rear 是队列最后
    2. front 是队列最前的元素

案例

package 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){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h': // 查看队列头
                    try{
                        int i = queue.headQueue();
                        System.out.printf("队列头的数据是:%d\n",i);
                    }catch (Exception e){
                        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++;
        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];
    }
}
  • 存在的问题
    • 数组使用一次就不能复用
    • 将这个数组使用算法，改进成一个环型数组 使用取模的方式实现

数组模拟环形队列

  • 对前面的数组模拟的队列的优化，充分利用数组，因此将数组看成是一个环形的。
  • 分析:
    • 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定，这个在做判断队列满的时候需要注意(rear+1)%maxSize==front满
    • rear == front[空]
    • (rear + maxSize - front)%maxSize
    • 我们就可以在原来的队列上修改，得到环形队列
package 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) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h': // 查看队列头
                    try {
                        int i = queue.headQueue();
                        System.out.printf("队列头的数据是:%d\n", i);
                    } catch (Exception e) {
                        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指向队列的最后一个元素的后一个位置，因为希望空出一个空间作为约定
    // 这里给个例子: 比如我一开始为 空数组的时候 front = 0 rear = 0
    // 当我加入一个元素的时候 rear为 1 然而只有 arr[0] 有值 
    // 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() {
        return (rear + maxSize - front) % maxSize;
    }

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

}

注意

在实践的时候要记住

  • (rear + maxSize - front) % maxSize; 代表队列的有效个数，这一个一定要想清楚
  • 在获
数据结构笔记（四）——队列（queue）
xitie8523的博客
03-26 540
个人学习笔记。 个人理解数据结构只是个概念，怎么实现完全看个人和项目 需求，可以用偏C语言的方式实现，也可以用C++中更偏向于类的方式，加上构造函数和析构函数等。看这些代码，和正常看C/C++代码一样看。因为之前有人问我一些问题，随便叨叨。 队列同样算是表，它的特点是先进先出（FIFO）。 一、数组实现队列 这里用循环数组，队首留一个位置不存数据。 QueueArray.h #pra...
Python实现的数据结构与算法之队列详解
12-25
本文实例讲述了Python实现的数据结构与算法之队列。分享给大家供大家参考。具体分析如下： 一、概述 队列（Queue）是一种先进先出（FIFO）的线性数据结构，插入操作在队尾（rear）进行，删除操作在队首（front）进行...
【源代码】C++算法（四）队列的基本操作 （用队列实现十进制转换十六进制）
03-30
【源代码】C++算法（四）队列的基本操作 （用队列实现十进制转换十六进制）
数据结构与算法学习笔记——队列ADT C++实现
weixin_46574339的博客
02-12 521
数据结构与算法学习笔记——队列ADT C++实现1 特点2 包含的操作3 实现方式4 队列与循环队列4.1 队列4.2 循环队列 1 特点 队列的数据结构为线性结构 队列只能在一端完成插入，在另一端完成删除。先进先出（FIFO），生活中的例子有买票排队、打印机的打印队列 2 包含的操作 入队列 出队列 3 实现方式 基于数组实现 4 队列与循环队列 4.1 队列 编程时主要考虑的是指针移动操作和数据操作的顺序，以及空间是否为满/空（相应的，不能入/出队列） 存在的缺点是空间越用越少 Quence.h
队列（数据结构）
shamansi99的博客
04-20 174
自己尝试写了一个队列。 采用递归定义。 #include<cstdio> #include<algorithm> #include<cstdlib> #include<iostream> using namespace std; struct stack { int v; //队列元素存储的值 stack *next; //队列下一个元...
数据结构篇——队列
weixin_40904220的博客
03-16 213
队列的特点：先入先出，就好像饭堂排队打饭的排的队一样，排第一的先拿到饭去打菜，跑得快，拿第一有饭吃，跑得慢。。。。 操作：插入，在队尾插入元素,就好像在饭堂打饭需要按序排队。 删除，删除队首的元素，就好像在饭堂拿到饭的人，不能老是在第一站着位置。 实现： class Queue{ List&lt;Integer&gt; list; int ...
数据结构与算法——队列
最新发布
2301_80888963的博客
10-12 1312
队列
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
JS数据结构与算法.pdf
11-01
JS 数据结构与算法.pdf 本书主要介绍了 JavaScript 语言的基础知识，包括数据结构和算法。以下是该书的详细知识点： 一、JavaScript 基础知识 * 变量和数据类型 * 运算符和控制结构 * 函数和对象 * 数组和字符串 ...
Python实现的数据结构与算法之双端队列详解
12-25
本文实例讲述了Python实现的数据结构与算法之双端队列。分享给大家供大家参考。具体分析如下： 一、概述 双端队列（deque，全名double-ended queue）是一种具有队列和栈性质的线性数据结构。双端队列也拥有两端：队...
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据...
实现数制转换的算法
知止不殆
12-18 1495
也是这次学习数据结构学到的，不过这个代码不是我的原创，我只是觉得不错，留在这里给大家分享。本例是10进制到7进制，如果改一下，可以成为10进制到任何进制的算法。void coversion(int num){ int k; while(num) {  push(num%7);  num=num/7; } while(!isempty()) {  k=pop();  printf("%d",k)
数据结构与算法之八皇后问题
Happy_Boy_z的博客
01-11 2943
八皇后问题八皇后问题介绍思路分析代码图文解析特别感谢 韩顺平 老师的教导 八皇后问题介绍 八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋手马克思.贝瑟尔与1848年提出: 在8x8格的国际象棋上摆放八个皇后，使其不能相互攻击，即: 任意两个皇后都不能处于同一行，同一列或同一斜线上，问有多少种摆法 思路分析 第一个皇后先放第一行第一列 第二个皇后放在第二行第一列，然后...
数据结构与算法之单链表
Happy_Boy_z的博客
01-04 1029
链表链表的介绍单链表(带头节点)添加（创建） 链表的介绍 链表是有序的列表，它在内存中的存储如下 链表是以节点的方式来存储，是链式存储 每个节点包含data域，next域：指向下一个节点 如图: 发现链表的个个节点不一定是连续存储 链表分带头节点的链表和没有头结点的链表，根据需求来确定 单链表(带头节点) 使用一个带head头的单向链表实现排行榜管理 完成对英雄人物的增删改查操作 ...
五邑大学数据结构第二章作业大题部分答案及解析
Happy_Boy_z的博客
05-08 856
五邑大学数据结构第二章作业答案及解析前言模板类顺序表单链表双链表后记 前言 由于很多同学都反应这一个作业很难做，在我看来应该跟不会使用C++语言创建模板并且测试方法。下面我将提供一些类方便同学们参考且使用 模板类 格式: class mytest2 //类名 { private: /* data */ // 放各种私有数据 public: //放各种私有方法 mytest2(/* args */); // 有参构造 ~mytest2(); // 无参构造 }; mytest2::mytest2
五邑大学数据结构第三章作业答案及解析
Happy_Boy_z的博客
05-09 712
五邑大学数据结构第三章作业答案及解析前言选择题大题部分第一与第二题第四题后记 前言 对于这一章作业的难点，我个人觉得老师有点太为难我们了。既然这么多同学想要我出博客，那我就给大家解析一下吧。 选择题 第十二题如果是直接百度的话，不难得出答案 D，该题其实就是逆波兰表达式的雏形。(有一些大厂的面试题中有出现过) 但是如果有同学想要深入学习的话，可以看看我java版本的数据结构与算法，里面有详细说明 起飞 大题部分 第一与第二题 由于此次作业可重用部分很多，所以我把第一跟第二题放在同一段代码里面展示 希望
数据结构与算法：队列的表示与应用
"该资源是针对数据结构与算法的课程讲解，特别关注队列这一主题。内容涵盖了顺序队列和链表队列的介绍，适合软件学院2010级本科生学习，旨在2011-2012学年的秋季学期进行教学。" 在计算机科学中，数据结构与算法是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值