02队列及代码实现

最新推荐文章于 2023-10-28 15:51:27 发布
最新推荐文章于 2023-10-28 15:51:27 发布
阅读量294 收藏
点赞数
分类专栏： Java数据结构 文章标签： 算法 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tian_baby/article/details/131218957
版权

队列介绍

  1. 队列是一个有序列表，可以用数组或是链表来实现。、
  2. 遵循先入先出的原则。 （先存入队列的数据，要先取出。后存入的要后取出）

在这里插入图片描述

数组模拟队列

  1. 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明图如下，其中maxSize是该队列的最大容量。

  2. 因为队列的输入、输出分别是前后端来处理，因此需要两个变量front及rear分别记录队列前后端的下标，front会随着数据输出而改变，而rear则是随着数据输入而改变，具体如图。
    在这里插入图片描述

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

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

第一版代码：

package com.queue;

import java.util.Scanner;

public class ArrayQueueDemo {
    public static void main(String[] args) {
        //创建一个队列
        ArrayQueue arrayQueue = new ArrayQueue(3);
        // 写一个循环控制用户操作

        char key = ' ';
        Scanner sc = new Scanner(System.in);
        boolean loop = true;
        //输出一个菜单列表
        while (loop){
            System.out.println("s:  显示队列");
            System.out.println("e:  退出程序");
            System.out.println("a:  添加元素到队列");
            System.out.println("g:  从队列取出数据");
            System.out.println("h:  获取队列头的数据");
            key = sc.next().charAt(0);
            switch (key){
                case 's':
                    arrayQueue.showQueue();
                    break;

                case 'a':
                    System.out.println("输入你要添加的数");
                    int num = sc.nextInt();
                    arrayQueue.addQueue(num);
                    break;
                case 'g':
                    try {
                        System.out.println("取出数据为"+ arrayQueue.getQueue());
                    }catch (Exception e){
                        //TODO 处理异常
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        System.out.println("该队列头数据为"+arrayQueue.peekQueue());
                    }catch (Exception e){
                        //TODO 处理异常
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    sc.close();
                    loop = false;
                    break;
            }
        }
        System.out.println("再见~~~");
    }
}

//使用数组模拟队列  编写一个类Queue
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[this.maxSize];
        //指向队列头部  分析指向队列头的前一个位置
        this.front = -1;
        //指向队列尾部  指向队列尾的数据（即包含队列最后一个数据）
        this.rear = -1;
    }

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

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

    //添加数据（进队列）
    public void addQueue(int element) {
        if (isFull()) {
            System.out.println("队列满，不能加入数据");
            return;
        }
        rear++;
        arr[rear] = element;
    }

    //获取数据（出队列）
    public int getQueue() {
        if (isEmpty()) {
            //如果为空抛出异常
            throw new RuntimeException("队列空，不能获取数据");
        }
        front++;
        return arr[front];
    }

    //展示当前队列
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列空，无遍历内容");
        }
        for (int i = front + 1; i < rear+1; i++) {
            System.out.printf("arr[%d]=%d\t", i, arr[i]);
        }
    }

    //获取队列第一个元素，和出队列不同
    public int peekQueue() {
        if (isEmpty()) {
            //如果为空抛出异常
            throw new RuntimeException("队列空");
        }
        return arr[front + 1];
    }
}

问题分析

  1. 当前的数组使用一次之后就不能使用了
  2. 将这个数组使用算法搞成环形数列

优化成环形数组

思路如下：（这只是一种思路，也可以根据自己的思路进行、宗旨就是将数组头尾连接成为一个环形。）

  1. front变量的含义有所调整：front就指向队列的第一个元素，也就是说arr[front] 就是队列的第一个元素
  2. rear变量的含义：rear指向队列的最后一个元素的后一个位置。希望空出一个空间作为一个约定。
  3. 当队列满时， (rear + 1) % maxSize == front。
  4. 当队列空时，rear == front（与原先没有变化）。
  5. 当这样规定以后队列中有效的数字个数为(rear - front + maxSize) % maxSize
  6. 根据这个思路我们可以在这个基础上进行修改，得到环形队列。
  7. front和rear的初始值都是0。

代码实现

import java.util.Scanner;

//通过取模的方式实现环形列表
public class CircleQueueDemo {
    public static void main(String[] args) {
        System.out.println("-------测试数组完成环形队列的案例--------");
        //创建一个队列 这里设置最大大小为4但是实际使用大小为3
        CircleQueue circleQueue = new CircleQueue(4);
        // 写一个循环控制用户操作
        char key = ' ';
        Scanner sc = new Scanner(System.in);
        boolean loop = true;
        //输出一个菜单列表
        while (loop) {
            System.out.println("s:  显示队列");
            System.out.println("e:  退出程序");
            System.out.println("a:  添加元素到队列");
            System.out.println("g:  从队列取出数据");
            System.out.println("h:  获取队列头的数据");
            key = sc.next().charAt(0);
            switch (key) {
                case 's':
                    circleQueue.showQueue();
                    break;

                case 'a':
                    System.out.println("输入你要添加的数");
                    int num = sc.nextInt();
                    circleQueue.addQueue(num);
                    break;
                case 'g':
                    try {
                        System.out.println("取出数据为" + circleQueue.getQueue());
                    } catch (Exception e) {
                        //TODO 处理异常
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        System.out.println("该队列头数据为" + circleQueue.peekQueue());
                    } catch (Exception e) {
                        //TODO 处理异常
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    sc.close();
                    loop = false;
                    break;
            }
        }
        System.out.println("再见~~~");
    }
}

class CircleQueue {
    private int maxSize;//表示数组的最大容量
    private int front;//头指针
    private int rear;//尾指针

    private int[] arr;//数组存放数据，完成队列结构

    public CircleQueue(int maxSize) {
        this.maxSize = maxSize;
        //todo 因为判断条件的改变这里在用户使用时传入的参数最好自行加1
        this.arr = new int[this.maxSize];
        //指向队列头部
        this.front = 0;
        //指向队列尾部  指向队列尾的数据  尾部的后面要空出一个空间作为约定
        this.rear = 0;
    }

    // 获取当前队列的有效元素个数。
    public int getSize() {
        return (rear - front + maxSize) % maxSize;
    }

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

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

    //添加数据（进队列）
    public void addQueue(int element) {
        if (isFull()) {
            System.out.println("队列满，不能加入数据");
            return;
        }
        arr[rear] = element;
        //rear后移一位所以要考虑是否需要重头开始的问题。
        rear = (rear + 1) % maxSize;
    }

    //获取数据（出队列）
    public int getQueue() {
        if (isEmpty()) {
            //如果为空抛出异常
            throw new RuntimeException("队列空，不能获取数据");
        }
        // 这里需要分析出front指向的是第一个元素，
        // 先把front对应的值存放在临时变量中，
        // 然后将front后移动  后移的时候要考虑移动位置
        int res = arr[front];
        front = (front + 1) % maxSize;
        return res;//不需要将原来的位置置空，后期的数据直接覆盖了就行了。
    }

    //展示当前队列
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列空，无遍历内容");
        }
        //这一部分的遍历方式是肯定不对了
        //for (int i = front + 1; i < rear + 1; i++) {
        //    System.out.printf("arr[%d]=%d\t", i, arr[i]);
        //}
        // 先思考 从？开始遍历，遍历？个有效元素
        for (int i = front; i < front + getSize(); i++) {
            System.out.printf("arr[%d] = %d\t", i % maxSize, arr[i % maxSize]);
        }
        System.out.println();

    }

    //获取队列第一个元素，和出队列不同
    public int peekQueue() {
        if (isEmpty()) {
            //如果为空抛出异常
            throw new RuntimeException("队列空");
        }
        return arr[front];
    }
}
黎丶辰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
用c语言写一个先入先出的队列排序程序，并且可以插入队列，提出队列
weixin_42599908的博客
02-14 216
下面是一个示例的 C 语言代码，实现了先入先出的队列排序，并且可以插入队列和提出队列。 #include <stdio.h> #include <stdlib.h> #define MAX_SIZE 100 // 队列结构体 struct Queue { int data[MAX_SIZE]; int front; int rear; }; /...
队列的介绍与代码实现
小辉的编程学习记录
01-05 320
跟着B站尚硅谷老韩的数据结构进行学习，所做的笔记。！我会持续更新。👊👊本文讲的是队列的介绍与代码实现等等，队列是遵循先进先出,相信读完这篇文章，对队列会有初步的概念。● 队列是一个有序列表，可以用数组或是链表来实现。遵循先入先出的原则。● 即：先存入队列的数据，要先取出。后存入的要后取出！！❤️❤️❤️❤️❤️。
数据结构-队列-队列的输入输出操作
Zou_Cuo的博客
10-28 458
【代码】数据结构-队列-队列的输入输出操作。
C语言队列实现
程序员大阳
07-06 1019
一，简介开发环境是VC6.0，实现了一个基于C语言的队列。 主要功能，入队、出队、显示当前队列元素。 二，代码实现//队列演示 #include #define QUEUE_LENGTH 100//仅能处理非负整数 struct Queue { int element[QUEUE_LENGTH]; int head; int tail; };int Que
Java 队列实现原理及简单实现代码
09-01
【Java 队列的简单实现代码】 以下是一个简单的Java队列实现，使用数组作为底层数据结构： ```java package 栈和队列; public class Queue { private int maxSize; private long[] queArray; private int ...
Java消息队列的简单实现代码
08-29
Java消息队列的简单实现代码 Java 消息队列是一种异步处理机制，主要目的是减少请求响应时间和解耦。消息队列的应用场景非常广泛，例如在用户注册时，服务端收到用户的注册请求后，可以将其他操作放入消息队列中，...
优先队列讲解及代码实现.zip
04-12
优先队列 优先队列（Priority Queue）是一种数据结构，它类似于常规的队列或栈，但每个元素都有与其关联的“优先级”。在优先队列中，元素的出队顺序是基于...下面是一个简单的基于数组和插入排序的优先队列实现示例：
解析C++无锁队列的实现代码
09-05
在C++中，实现无锁队列的关键在于利用原子操作（Atomic Operations）来保证数据在并发环境中的正确性。下面将详细解析给定的C++无锁队列实现。 首先，我们定义了一个模板类`LockFreeQueue`，它包含一个`std::list`...
C语言实现链队列代码
12-31
本文实例为大家分享了C语言实现链队列的具体代码，供大家参考，具体内容如下 #include /* 队列的结构体 */ typedef int DataType; #define NODE_LEN sizeof(NODE) /* 队列的节点 */ typedef struct stNode { ...
动态先入先出消息队列
10-02
本代码采用动态加载堆的空间，来进行动态分配内存，从而实现动态加载跟删除消息
数据结构之队列（顺序队和链队）（C语言附完整代码）
m0_62795460的博客
04-12 6034
队列简称队，它是一种操作受限的线性表，其限制为仅允许在表的一端进行插入操作，而在表的另一端进行删除操作。把进行插入的一端称为队尾，把进行删除的一端称为队头或队首。向队列中插入新元素称为进队或入队，从队列中删除元素称为出队或离队。由于队列的插入和删除操作分别是在各自的一端进行的，每个元素必然按照进入的次序出队，所以又把队列称为先进先出表。采用顺序存储结构的队列称为顺序队声明顺序队//存放队中元素 int front , rear;//队首和队尾指针 } SqQueue;采用链式存储结构的队列称为链队。
队列详解包含测试过的完整代码
分享学习的知识，记录我的技术成长道路
11-15 1098
文章目录零.前言1.队列的结构1.逻辑结构物理结构2.实现队列的基本操作1.队列的建立2.队列的初始化3.队列的销毁4.判断队列是否为空5.计算队列的大小3.队列的插入与删除1.队列的插入2.队列的删除4.得到队列的头尾1.得到队列的头2.得到队列的尾5.全部文件1.queue.h文件2.queue.c3.test.c文件6.测试7.总结 零.前言 栈和队列都是顺序表或者链表的特殊结构，栈由于是尾插尾删，所以我们使用顺序表来实现；而队列使用尾插头删，如果我们使用顺序表的话则正中其缺点，即插入删除数据的时候需
基于C语言的队列操作(包含完整代码)
weixin_43369883的博客
05-18 277
队列和链表,栈一样都属于线性表,队列的基本操作与链表类似,队列就是操作受限的链表,队列的特性是先进先出. 首先需要两个头文件#include 和#include
数据结构实验之队列（文末附完整代码）
2201_75867204的博客
09-02 598
数据结构----队列
队列、循环队列、双端队列详解（含完整代码）
m0_60284144的博客
04-24 2782
队列是一种操作受限的线性表。只允许在表的一端进行插入，在表的另一端进行删除。和日常生活中的队列一样 先入队的元素优先出队，即先进先出。
队列代码详解（C语言）
m0_74824254的博客
04-09 204
【代码】队列代码详解（C语言）
队列 的实现及代码
2301_77133703的博客
03-21 325
队列（Queue）与栈一样，是一种线性存储结构，它具有如下特点：队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构。在队尾添加元素，在队头删除元素队列的概念队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)1、只允许从一端添加元素，从另一端删除元素2、队头出元素，队尾进元素3、入列(push) 出列(pop)入队列：进行插入操作的一端称为队尾。
C语言/C++队列详细讲解教程及完整代码实现
qq_43884946的博客
06-30 2466
队列是一种常用的数据结构，具有先进先出的特点。在解决实际问题时，队列可以发挥重要作用。通过C语言的实现代码，我们可以更好地理解队列的概念和基本操作。希望本篇教程能对你理解队列有所帮助！
前端数据结构----队列
qq_47199913的博客
04-12 1561
前端数据结构 队列
循环队列c语言代码实现
最新发布
04-15
下面是一个简单的C语言代码实现循环队列的示例： ```c #include #define MAX_SIZE 5 typedef struct { int data[MAX_SIZE]; int front; int rear; } CircularQueue; void initQueue(CircularQueue *queue) { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

黎丶辰

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值