数据结构 - 队列

最新推荐文章于 2022-11-18 18:41:34 发布
最新推荐文章于 2022-11-18 18:41:34 发布
阅读量95 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BottleOfWalking/article/details/112856251
版权

数据结构 - 队列

概念及特性

  • 有序列表
    • 数组实现
    • 链表实现
  • 先进先出 - FIFO

在这里插入图片描述

使用场景

  • 银行业务排队 等

数组实现

  • 初步单向队列
package cn.com;

import java.util.Scanner;

public class ArrayQueQue {

    // 队列最大容量
    private int maxSize;
    // 队头指针
    private int front;
    // 队尾指针
    private int rear;

    private int[] array;

    public ArrayQueQue(int maxSize){
        this.maxSize = maxSize;
        this.array = new int[maxSize];
        // 起始指针下表也可以是0
        // front是队列头的前一位
        this.front = -1;
        // rear 是 队列尾的数据(注意理解：这里是队列尾的数据，没有前一位哦)
        this.rear = -1;
    }

    public boolean isEmpty(){
        return rear == front;
    }

    public boolean isFull(){
        return rear == maxSize-1;
    }

    public void add(int ele){
        if(isFull()){
            System.out.println("队列已满, 不能再添加数据");
            return;
        }
        rear ++;
        array[rear] = ele;
    }

    public int get(){
        if(isEmpty()){
            throw new RuntimeException("队列为空");
        }
        front ++;
        return array[front];
    }

    public int peek(){
        if(isEmpty()){
            throw new RuntimeException("队列为空");
        }
        return array[front + 1];
    }

    public void show(){
        for (int i = 0; i < array.length; i ++){
            System.out.printf("array[%d]=%d\n", i, array[i]);
        }
    }

    // 主函数测试
    public static void main(String[] args) {
        ArrayQueQue arrayQueQue = new ArrayQueQue(3);
        System.out.println("操作菜单：");
        System.out.println("show : 展示队列数据");
        System.out.println("add : 增加数据到队列");
        System.out.println("get : 从队列取数据");
        System.out.println("peek : 查看当前队列头数据");
        System.out.println("exit : 退出");
        boolean flag = true;
        while (flag){
            System.out.println("请输入操作：");
            Scanner scanner = new Scanner(System.in);
            String operate = scanner.nextLine();
            switch (operate){
                case "show":
                    arrayQueQue.show();
                    break;
                case "add":
                    System.out.println("请输入数字：");
                    arrayQueQue.add(scanner.nextInt());
                    break;
                case "get":
                    try {

                        System.out.println("get 数据为："+ arrayQueQue.get());
                    }catch (Exception e){
                        e.printStackTrace();
                        System.out.println(e.getMessage());
                    }
                    break;
                case "peek":
                    try {

                        System.out.println("peek 的数据为：" + arrayQueQue.peek());
                    }catch (Exception e){
                        e.printStackTrace();
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    flag = false;
                    break;

            }
        }
        System.out.println("已退出···");
    }

}

以上队列存在的问题：

​ 队列只能使用一次，不能循环使用，故需要修改为循环队列

  • 循环队列 - 队列满的时候没有空值的数组表示
package cn.com;

import java.util.Scanner;

public class CycleArrayQueue {

    private int front;

    private int rear;

    private int[] cycleArr;

    private int maxSize;

    private boolean isFull;

    public CycleArrayQueue(int maxSize){
        this.maxSize = maxSize;
        cycleArr = new int[maxSize];
        // 指针初始值 - 0
        // 这个下表如果不赋值 也是默认为零，可以在此不进行赋值
        this.front = 0;
        this.rear = 0;
        this.isFull = false;
    }

    public boolean isEmpty(){
        return !isFull && front == rear;
    }

    public boolean isFull(){
        return isFull;
    }

    public int get(){
        if(isEmpty()){
            throw new RuntimeException("队列为空");
        }
        if(isFull){

            this.isFull = false;
        }
        int temp = cycleArr[front];
        front = (front + 1 + maxSize) % maxSize;
        return temp;
    }

    public void add(int a){
        if(isFull()){
            System.out.println("队列已满");
            return;
        }
        cycleArr[(this.rear + maxSize) % maxSize] = a;
        this.rear = (rear + 1 + maxSize) % maxSize;
        if(front == rear){
            this.isFull = true;
        }

    }

    public int peek(){
        return cycleArr[front];
    }


    public void show(){
        int len = maxSize;
        if(!isFull){
            len = (rear + maxSize - front) % maxSize;
        }
        for(int i = 0; i < len; i ++){
            System.out.printf("cycleArr[%d]=%d\n", (front + i) % maxSize, cycleArr[(front + i) % maxSize]);
        }
    }


    public static void main(String[] args) {
        CycleArrayQueue arrayQueQue = new CycleArrayQueue(3);
        System.out.println("操作菜单：");
        System.out.println("show : 展示队列数据");
        System.out.println("add : 增加数据到队列");
        System.out.println("get : 从队列取数据");
        System.out.println("peek : 查看当前队列头数据");
        System.out.println("exit : 退出");
        boolean flag = true;
        while (flag){
            System.out.println("请输入操作：");
            Scanner scanner = new Scanner(System.in);
            String operate = scanner.nextLine();
            switch (operate){
                case "show":
                    arrayQueQue.show();
                    break;
                case "add":
                    System.out.println("请输入数字：");
                    arrayQueQue.add(scanner.nextInt());
                    break;
                case "get":
                    try {

                        System.out.println("get 数据为："+ arrayQueQue.get());
                    }catch (Exception e){
                        e.printStackTrace();
                        System.out.println(e.getMessage());
                    }
                    break;
                case "peek":
                    try {

                        System.out.println("peek 的数据为：" + arrayQueQue.peek());
                    }catch (Exception e){
                        e.printStackTrace();
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    flag = false;
                    break;

            }
        }
        System.out.println("已退出···");
    }
}
  • 循环队列 - 队列满的时候存在一个空值的数组表示
package cn.com;

import java.util.Scanner;

public class CycleArrayQueue2 {

    // 最大队列数量
    private int maxSize;

    // 队列取值 指针 - 前指针
    private int front;

    // 队列赋值 指针 - 后指针
    private int rear;

    private int[] cycleArray;

    public CycleArrayQueue2(int maxSize){
        // 初始值
        this.maxSize = maxSize;
        this.cycleArray = new int[maxSize];
        // 前指针默认指向的初始位置：当然可以是任意的值(在maxSize指定的数组的长度范围即可)
        this.front = 0;
        // 后指针 默认指向后当前赋值的后一个下标，
        // 当没有开始没有任何一个值的, 初始应与front一样, 即当front = 2,的时候,rear = 2就行
        this.rear = 0;
        // 特别说明：
        // 这里的 front 和 rear 的赋值只是0.所以可以不写，因为int型，默认为0
    }

    // 判断是否为空
    public boolean isEmpty(){
        // 如果正常的情况下，这个判断可以判断为空，同样也符合，队列数组满的情况，因为满的时候，rear指向的是下一个，即rear 等于 front
        // 所以 这里当满的时候需要空一个位置，即 只有最后一个空的位置的时候，判定为满，以此区分空和满的判断条件
        return front == rear;
    }

    public boolean isFull(){
        return (rear + 1 + maxSize) % maxSize == front;
    }

    public void add(int a){
        if(isFull()){
            System.out.println("队列已满");
            return;
        }
        cycleArray[rear % maxSize] = a;
        rear = (rear + 1) % maxSize;
    }

    public int get(){
        if(isEmpty()){
            throw new RuntimeException("队列为空");
        }
        int temp = cycleArray[front];
        front = (front + 1) % maxSize;
        return temp;
    }

    public int peek(){
        return cycleArray[front];
    }

    public void show(){
        for(int i = 0; i < (rear + maxSize - front)% maxSize; i++){
            System.out.printf("cycleArray[%d]=%d\n", (front + i) % maxSize, cycleArray[(front + i) % maxSize] );
        }
    }


    public static void main(String[] args) {
        CycleArrayQueue2 arrayQueQue = new CycleArrayQueue2(3);
        System.out.println("操作菜单：");
        System.out.println("show : 展示队列数据");
        System.out.println("add : 增加数据到队列");
        System.out.println("get : 从队列取数据");
        System.out.println("peek : 查看当前队列头数据");
        System.out.println("exit : 退出");
        boolean flag = true;
        while (flag){
            System.out.println("请输入操作：");
            Scanner scanner = new Scanner(System.in);
            String operate = scanner.nextLine();
            switch (operate){
                case "show":
                    arrayQueQue.show();
                    break;
                case "add":
                    System.out.println("请输入数字：");
                    arrayQueQue.add(scanner.nextInt());
                    break;
                case "get":
                    try {

                        System.out.println("get 数据为："+ arrayQueQue.get());
                    }catch (Exception e){
                        e.printStackTrace();
                        System.out.println(e.getMessage());
                    }
                    break;
                case "peek":
                    try {

                        System.out.println("peek 的数据为：" + arrayQueQue.peek());
                    }catch (Exception e){
                        e.printStackTrace();
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    flag = false;
                    break;

            }
        }
        System.out.println("已退出···");
    }
}
java数据结构之环形队列（二）
m0_46172449的博客
01-10 254
java数据结构之环形队列（二） 前言 在上一个小结中，整理了环形队列出现的原因，接下来就如何使用环形队列做一下阐述。 1.对环形队列中指针的要求 1.1 指针的初始化问题 （1）为了方便起见，默认初始化的值都为0 即：front = 0；rear = 0； （2）含义 front：表示的是永远指向队列的第一个元素 rear：表示永远指向队列最后一个元素的后一个位置。 （3）约定数组的长度比队列的...
4.C-数据结构-队列
最新发布
09-15
4.C_数据结构_队列
java版实现环形队列
10-18
java实现的队列，通过图的方式来演示环形队列的结构和原理，通过图从感官上了解队列的形式，从逻辑上更好的明白环形队列的实质。
环形队列——Java数据结构
qq_45629699的博客
09-28 254
对队列进行入队操作时，队头指针不变，队尾指针后移一位，对队列进行出队操作时，队头指针后移一位，队尾指针不变，通过这样的操作过后，很有可能某些数据域空闲，导致空间浪费，此时循环队列能很好的解决这一问题，当队尾指针到达数组的最后一个位置，且数组还有空闲的数据域时，队尾指针可以再次到达数组的起始位置，从而使得数组可以重复使用。
Java数据结构与算法-环形队列
Buggggggg
08-23 126
队列介绍 队列是一个有序列表，可以用数组或是链表来实现 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的数据要后取出 数组模拟环形队列 分析说明： 尾索引rear的下一个为头索引时表示队列满，即将队列容量空出一个作为约定，这个在做判断队列满的时候需要注意(rear + 1) % maxSize = front (满) rear ...
622. 设计循环队列
weixin_39590058的博客
09-29 135
class MyCircularQueue { final int[] nums; int len = 0, front = 0, rear = -1; /** Initialize your data structure here. Set the size of the queue to be k. */ public MyCircularQueue(int k) { nums = new int[k]; } /** Insert
数据结构-队列的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 队列的部分实现代码，详细介绍参考数据结构--队列的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
嵌入式常用数据结构------队列操作简介
08-21
队列是一种特殊的数据结构，它遵循“先进先出”（First In First Out，简称FIFO）的原则，类似于现实生活中的排队购票场景。在嵌入式软件开发中，队列被广泛应用于处理顺序执行的任务，例如任务调度、数据传输、消息...
基于C语言的数据结构-队列queue
06-25
在本主题“基于C语言的数据结构-队列queue”中，我们将深入探讨如何在C语言中实现队列的数据结构。 队列的基本操作包括： 1. **入队**（Enqueue）：将元素添加到队列的末尾。 2. **出队**（Dequeue）：移除并返回...
漫话数据结构-队列的定义.pptx
11-03
在众多的数据结构中，队列是一种基本且重要的类型，尤其在处理顺序访问和优先级的问题时显得尤为关键。 队列的定义基于一个简单的理念：“先进先出”(First In First Out, FIFO)。它是一种线性数据结构，允许在结构...
环形队列-Java
CL_1822SX的博客
10-28 228
环形队列 队列的概念： 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 特点 先进先出 front变量含义:front就指向队列的第一个元素，也就是说arr[front]就是队列的第一个元素，front的初始值为0。 rear变量含义:rear指向最后一个元素的后一个位置，因为希望空出一个空间做为约定，rear的初始值为0。
Java环形队列
小风架构师博客
01-29 181
package com.design.java; import java.util.Arrays; /** * @author Lxz * @Data 2019/1/29 * @description CicularQueue Easy Implementation */ public class MyCircularQueue { private int head; ...
环形队列_JAVA
imxlw00的专栏
09-06 192
普通顺序队列存在的问题 在普通顺序队列中,入队的操作就是先将尾指针rear右移一个单位，然后将元素值赋值给rear单位。出队时，则是头指针front后移一个单位。像这样进行了一定数量的入队和出队操作后，可能会出现这样的情况： 尾指针rear已指到数组的最后有一个元素，即rear==MaxLen-1，此时若再数组的前面部分可能还有很多闲置空间，即这种溢出并非是真的没有可用的存储空间，故称这种溢出现象...
环形队列（Java实现）
qq_41687961的博客
07-14 514
环形队列（Java实现） 基本概念 队列是有序的线性结构，可用顺序表（即数组）实现 队列满足先进先出，即从尾部 rear 加入，从头部 front 弹出 队列容量记为 maxSize，表示数量，是一个物理逻辑 普通队列和环形队列的比较 普通队列和环形队列的比较 普通队列每取出一个元素，头指针 rear 只能往后移动，则顺序表（数组）前面的位置无法重复使用，造成资源浪费。 同时，若尾指针指向队列最后，当首尾指针重合时，说明队列为空，由于无法重复使用前面位置，因此该队列报废。 环形队列实现方式 数据
使用Java实现环形队列
weixin_52033496的博客
06-18 576
使用Java实现环形队列 在这里我使用的是创建一个类，然后new出来就行，使用的时候直接调用类里面的方法即可。 思路： 1：front变量的含义做一个调整：front就指向队列的第一个元素，也就是说arr[front]就是队列的第一元素，当然front的初始值=0 2：rear变量的含义做一个调整：rear指向队列的第一个元素的后一个位置，因为我们希望空出一个空间作为一个约定，当然rear的初始值=0 3：当队列排满时，条件就是（rear+1）%maxSize=front【满】当然也可以是（front+.
环形队列 - java实现
wangdeqiang2007的博客
02-06 235
public class LoopQueue { private byte[] _buf; private int _head; private int _tail; private int _size; private int _capacity; public LoopQueue(int capacity){ _capacity
环形队列的java实现
secret2316352792的博客
09-04 162
数组模拟环形队列 分析说明 1.尾索引的下一个为头索引时表示队列满，即将队 列容量空出一个作为约定,这个在做判断队列满的 时候需要注意 (rear + 1) % maxSize == front 满 2.rear == front 空 环形队列数组的实现 /** * @author zl * @create 2020--09--03--9:02 */ public class CicleArrayQueueDemo { public static void main(String[] ar
Java实现环形队列
qq_43726119的博客
11-18 236
java实现环形队列
数据结构-队列的应用
07-28
回答: 队列是一种常见的数据结构，它遵循先进先出（FIFO）的原则。队列的应用非常广泛。其中一种应用是在操作系统中进行进程调度。操作系统使用队列来管理进程的执行顺序，确保每个进程按照一定的规则得到执行的机会。另一个应用是在计算机网络中进行数据传输。数据包在网络中按照队列的方式进行传输，以确保数据的有序性和可靠性。此外，队列还可以用于实现缓冲区，任务调度，消息传递等场景。总之，队列作为一种简单而有效的数据结构，在计算机科学和软件工程中有着广泛的应用。\[2\]\[3\] #### 引用[.reference_title] - *1* *2* *3* [算法与数据结构-队列的详解以及应用](https://blog.csdn.net/qq_53283658/article/details/122463796)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值