02 数据结构与算法之队列、循环队列及代码实现

最新推荐文章于 2023-03-25 17:22:45 发布
最新推荐文章于 2023-03-25 17:22:45 发布
阅读量121 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 队列 数据结构 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44781238/article/details/106043246
版权

队列

1. 队列介绍

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

2. 数组模拟队列

​ 在这里插入图片描述

  1. MaxSize 是该队列的最大容量。

  2. front 和 rear 分别记录队列前后端的下标，初始值为 front = rear = -1。

  3. 队空：front == rear。

  4. 队满：rear == MaxSize - 1。

  5. 入队：

    • 将尾指针往后移：rear + 1;
    • 若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear 所指的数组元素中，否则无法存入数据。

  6. 出队：

    • 先判断队列是否为空，为空则无法取出数据;
    • 将头指针往后移：front + 1;
    • 将数据从 front 所指的数组元素中取出。

3. 代码实现

import java.util.Scanner;

/**
 * 测试队列
 */
public class TestArrayQueue {
    public static void main(String[] args) {
        ArrayQueue queue = new ArrayQueue(3);
        Scanner in = new Scanner(System.in);
        char key = ' ';
        boolean loop = true;
        while (loop) {
            System.out.println("a(add)：数据入队");
            System.out.println("g(get)：数据出队");
            System.out.println("h(head)：显示队头数据");
            System.out.println("s(show)：显示整个队列的数据");
            System.out.println("e(exit)：退出程序");
            key = in.next().charAt(0);
            switch (key) {
                case 'a':
                    System.out.println("请输入数据:");
                    int num = in.nextInt();
                    queue.add(num);
                    break;
                case 'g':
                    try {
                        System.out.println("取出的数据是：" + queue.get());
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    System.out.print("队头元素是:");
                    queue.showHead();
                    System.out.println();
                    break;
                case 's':
                    System.out.print("队列为:");
                    queue.show();
                    System.out.println();
                    break;
                case 'e':
                    loop = false;
                    break;
            }
        }
        System.out.println("程序退出！");
    }
}


/**
 * 数组队列类
 */
class ArrayQueue {
    private int[] arrayQueue;
    private int maxSize;
    private int front;  // 指向队首元素的前一个位置
    private int rear;  // 指向队尾元素

    /**
     * 初始化队列
     * @param size 队列的最大容量
     */
    public ArrayQueue(int size) {
        arrayQueue = new int[size];
        maxSize = size;
        front = -1;
        rear = -1;
    }

    /**
     * 判断队是否为空
     * @return true为空
     */
    private boolean isEmpty() {
        return front == rear;
    }

    /**
     * 判断队是否为满
     * @return true为满
     */
    private boolean isFull() {
        return rear == (maxSize - 1);
    }

    /**
     * 数据入队
     * @param num 要添加的数据
     */
    public void add(int num) {
        if (isFull()) {
            System.out.println("队列满了，无法添加数据！");
            return;
        }
        arrayQueue[++rear] = num;
    }

    /**
     * 数据出队
     * @return 返回出队的数据
     */
    public int get() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空，无法获取数据！");
        }
        return arrayQueue[++front];
    }

    /**
     * 显示队头信息
     */
    public void showHead() {
        if (isEmpty()) {
            System.out.println("队列为空，无法获取数据！");
            return;
        }
        System.out.printf("%d", arrayQueue[front + 1]);
    }

    /**
     * 显示整个队列信息
     */
    public void show() {
        if (isEmpty()) {
            System.out.println("队列为空，无法获取数据！");
            return;
        }
        for (int i = front + 1; i <= rear; i++) {
            System.out.printf("%d\t", arrayQueue[i]);
        }
    }
}

4. 数组模拟循环队列

  1. 普通队列会出现假溢出现象，使用循环队列解决。

在这里插入图片描述

  1. 队满：(rear + 1) % maxSize == front。
  2. 队空：rear == front。
  3. 初始值：front = rear = 0。
  4. 元素个数：(rear + MaxSize - front) % MaxSize。

5. 代码实现

import java.util.Scanner;

/**
 * 测试循环队列
 */
public class TestCircleArrayQueue {
    public static void main(String[] args) {
        CircleArrayQueue queue = new CircleArrayQueue(4);
        Scanner in = new Scanner(System.in);
        char key = ' ';
        boolean loop = true;
        while (loop) {
            System.out.println("a(add)：数据入队");
            System.out.println("g(get)：数据出队");
            System.out.println("h(head)：显示队头数据");
            System.out.println("s(show)：显示整个队列的数据");
            System.out.println("e(exit)：退出程序");
            key = in.next().charAt(0);
            switch (key) {
                case 'a':
                    System.out.println("请输入数据:");
                    int num = in.nextInt();
                    queue.add(num);
                    break;
                case 'g':
                    try {
                        System.out.println("取出的数据是：" + queue.get());
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    System.out.print("队头元素是:");
                    queue.showHead();
                    System.out.println();
                    break;
                case 's':
                    System.out.print("队列为:");
                    queue.show();
                    System.out.println();
                    break;
                case 'e':
                    loop = false;
                    break;
            }
        }
        System.out.println("程序退出！");
    }
}

/**
 * 循环队列类
 */
class CircleArrayQueue {
    private int[] arrayQueue;
    private int maxSize;
    private int front;  // 指向队首元素
    private int rear;  // 指向队尾元素的后一个位置

    /**
     * 初始化队列
     * @param size 队列的最大容量
     */
    public CircleArrayQueue(int size) {
        arrayQueue = new int[size];
        maxSize = size;
    }

    /**
     * 判断队是否为空
     * @return true为空
     */
    private boolean isEmpty() {
        return front == rear;
    }

    /**
     * 判断队是否为满
     * @return true为满
     */
    private boolean isFull() {
        return (rear + 1) % maxSize == front;
    }

    /**
     * 数据入队
     * @param num 要添加的数据
     */
    public void add(int num) {
        if (isFull()) {
            System.out.println("队列满了，无法添加数据！");
            return;
        }
        arrayQueue[rear] = num;
        rear = (rear + 1) % maxSize;
    }

    /**
     * 数据出队
     * @return 返回出队的数据
     */
    public int get() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空，无法获取数据！");
        }
        int temp = arrayQueue[front];
        front = (front + 1) % maxSize;
        return temp;
    }

    /**
     * 显示队头信息
     */
    public void showHead() {
        if (isEmpty()) {
            System.out.println("队列为空，无法获取数据！");
            return;
        }
        System.out.printf("%d", arrayQueue[front]);
    }

    public int getLength() {
        return (rear - front + maxSize) % maxSize;
    }

    /**
     * 显示整个队列信息
     */
    public void show() {
        if (isEmpty()) {
            System.out.println("队列为空，无法获取数据！");
            return;
        }
        for (int i = front; i < front + getLength(); i++) {
            System.out.printf("%d\t", arrayQueue[i % maxSize]);
        }
    }

}
朱古力...
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《数据结构》之循环队列及代码
weixin_45217677的博客
04-22 1559
一.引入 队列的顺序实现指内存中分配一片连续的存储单元用来存放数据，再设两个指针：队头指针front指向队头元素，队尾指针rear指向队尾元素或者队尾元素的下一个位置此处采用指向队尾元素下一个位置为例。如图： 队列的存储类型可如此描述： #define MAXSIZE 10 typedef struct{ elemType data[MAXSIZE];//存放队列元素 ...
循环队列work
qq_36560939的博客
05-16 900
循环队列 //定义循环队列 typedef struct CircleIntQueue { int data[TOTAL_SPACE]; int head; int tail; } *CircleIntQueuePtr; /生成循环链表 CircleIntQueuePtr initQueue() { CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(struct CircleIntQueue)); resultPt
【数据结构】队列的实现及循环队列的实现详解（c语言）
最新发布
m0_72532428的博客
03-25 3263
通过下图可以看到定义了两个结构体，第一个结构就是我们常用的节点，而第二结构体中的成员可以理解为head指针是用来指向队头的tail指针是用来指向队尾的size用来反应队列中的元素个数，看到这肯定会有一些疑问，为什么要这样定义呢，这样定义的好处是什么1.这样定义的好处上文我们说了实现队列要用尾插头删来实现当入队的时候尾插需要找到队列的尾，这样就需要把队列遍历一遍，此时入队列的时间复杂度为O（n）而我们使用tail指针指向尾，在尾插的时候就可以不用再遍历队列了，这时入队列的时。
【数据结构】循环队列的完整代码实现
维欣~fighting✔
04-16 776
代码实现 Queue.h typedef int ElemType; #define MAX_SIZE 10 typedef struct Queue { ElemType arr[MAX_SIZE]; int front;//队头指针，存的是下标 int rear;//队尾指针 }Queue,*pQueue; void init(pQueue pqu); int full(pQueu...
数据结构代码01----循环队列
weixin_43481880的博客
06-07 439
总结 1. 循环队列是队列的一种，都属于逻辑结构。 2. 空队列时为frontrear，满队列时为:（rear+1）%MaxSizefront; 3. 进队时rear移动，（rear+1）%MaxSize; 4. 出队时front移动，（front+1）%MaxSize; 5. 循环队列为了区分空队列和满队列，所以存储时牺牲一个大小，所以所存储的大小为MaxSize-1; 6. 队列长度公式为：(rear+MaxSize-front)%MaxSize; #include<stdio.h> #de
详解数据结构C语言实现之循环队列
12-31
本文讲的是循环队列，首先我们必须明白下面几个问题 循环队列的基础知识 1.循环队列需要几个参数来确定 循环队列需要2个参数，front和rear 2.循环队列各个参数的含义 （1）队列初始化时，front和rear值都为零；...
数据结构与算法C++实现 循环顺序队列的初始化，求长度，入队，出队
06-04
数据结构与算法C++实现 循环顺序队列的初始化，求长度，入队，出队 适合大二初学数据结构与算法 程序有详细备注，可直接运行 顺序表
C++数据结构之实现循环顺序队列
12-31
数据结构–用C++实现循环顺序队列 队列的操作特性：先进先出 队列中元素具有相同类型 相邻元素具有前驱和后继关系 设置队头、队尾两个指针，以改进出队的时间性能 约定：队头指针front指向队头元素的前一个位置...
Java数据结构与算法02——队列
12-21
Java中的数据结构与算法是编程领域中至关重要的概念，它们为高效地处理和组织数据提供了...对于初学者来说，从简单的数组模拟开始，逐步深入到链表、环形队列以及更高级的队列实现，是学习数据结构与算法的有效路径。
数据结构——循环队列【c语言版】
clear-ninghongkang的博客
11-21 2046
队列（quque）简称队，只允许在表的一端输入，在表的另一端删除(操作受限制的线性表)， 把进行插入的一段叫做队尾（表尾），把进入删除的一端叫做队首或队头（表头）。 队列最主要的特点：先进先出，FIFO（first in first out） 队列有其实有三种：顺序队列、循环队列、链式队列 为了避免顺序队列中出现的假溢出现象，我们只需要把数组的前后端连接起来，形成一个环形数组，在逻辑上把这个环称为环形队列或者循环队列。 下面是循环队列的实现过程： ...
数据结构之循环队列C语言实现（详细）
ck8719的博客
05-25 1万+
队列的一些说明 队列的定义 队列，一种特殊的线性表 特点：只允许在一端输入，在另一端输出。输入端称为队尾，输出端称为队头 因此，队列，又称为先进先出表（FIFO），类似于生活中的排队，先来的排在前头，后来的排在后头，一个一个办理业务。 队列有两种，一种叫做循环队列（顺序队列），另一种叫做链式队列。 这一篇讲的是循环队列，链式队列在另外一篇文章中 循环数组 循环队列使用的是数组，但是这个数组比较特别，为循环数组。为什么要使用循环数组呢？ 可以想象一下，假如我们使用通常的数组。 那么在使用过程中，我们是从后面加
循环队列基本操作代码(C语言)
weixin_46503238的博客
05-16 2963
#include <stdio.h> #include <stdlib.h> #include<stdbool.h> #define MaxSize 50 typedef int ElemType; typedef struct SqQueue { ElemType data[MaxSize]; int front;//定义头指针 int rear; //定义尾指针 } SqQueue; //初始化队列 bool InitQueue(Sq
循环队列数据结构代码（C语言）
m0_51512094的博客
04-28 1106
利用顺序队列（循环队列）数据结构实现一组数据的存储，并利用简单的交互实现队列的入队和出队。 //ADT 队列（Queue） 顺序存储结构 SqQueue #include <stdio.h> #include <stdlib.h> #define MAXSIZE 50 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType; typedef int Status; //定义顺序
数据结构与算法（C语言）——循环队列代码小合集
m0_46625346的博客
07-20 463
欢迎阅读 罡罡同学 的文章 (记得点赞关注哈) 还在为代码无法正常运行而烦恼，关注罡罡同学不迷路，解决你的烦恼。 如果你觉得，本文章对你有那么一丢丢的帮助，记得点赞关注转发，罡罡同学非常感谢哈！ 后续文章是关于数据结构一些基础实验，本人都已经成功运行，如果有问题，欢迎在评论区留言。 您的支持是罡罡同学前进的最大动力！ （疯狂暗示 点赞 ！关注！转发 ！！！ 点赞 ！关注！转发 ！！！） 关于循环队列的代码小合集 1.队列初始化 2.销毁队列 3.入队 4.出队 5.打印 6.清队 7.取队头元素并打印 8
数据结构：设计循环队列（C语言代码实现）详细·解读代码
qq_56870066的博客
02-06 961
设计循环队列
数据结构：循环队列（C语言实现）
热门推荐
lpp0900320123的专栏
03-07 12万+
生活中有很多队列的影子，比如打饭排队，买火车票排队问题等，可以说与时间相关的问题，一般都会涉及到队列问题；从生活中，可以抽象出队列的概念，队列就是一个能够实现“先进先出”的存储结构。队列分为链式队列和静态队列；静态队列一般用数组来实现，但此时的队列必须是循环队列，否则会造成巨大的内存浪费；链式队列是用链表来实现队列的。这里讲的是循环队列，首先我们必须明白下面几个问题 一、循环队列的基础知识 1
数据结构-循环队列的基本操作函数实现（含全部代码）
关注网络安全、云原生安全
09-17 1万+
主要包含以下函数： InitQueue(SqQueue &Q) 参数：循环队列Q 功能：初始化循环队列Q 时间复杂度：O(1) QueueEmpty(SqQueue Q) 参数：循环队列Q 功能：判断队空与否 时间复杂度：O(1) EnQueue(SqQueue &Q,QElemType e)...
循环队列的两种实现方法
cprimesplus的博客
03-30 2438
循环队列的两种实现方法 顺序存储结构   示意图参考严蔚敏版《数据结构》。 顺序存储为何宜选循环队列？   队列的顺序表存储中，除了数据域datadatadata，还应附设两个坐标frontfrontfront和rearrearrear用来记录头结点和尾结点的位置。对于poppoppop操作，依靠 front+1front+1front+1 这样的上移操作来进行。假设队列中已经有一些元素，经过几次...
数据结构与算法：队列的顺序表示和实现解析
"队列的示意图，数据结构教材讲义，循环队列，顺序队列，数据结构，信息表示，信息处理，数据结构定义，数据的逻辑结构，物理结构，运算" 队列是一种基础且重要的数据结构，它遵循先进先出（FIFO，First In First ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值