【数据结构】队列（queue）-循环队列（动态图解、c++、java）

原创 已于 2022-06-07 11:41:27 修改
· 3.5k 阅读 · 24 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c++ #java #队列 #图解法

于 2022-01-19 12:52:04 首次发布

文章目录

GitHub同步更新（已分类）：Data_Structure_And_Algorithm-Review

公众号：URLeisure 的复习仓库
公众号二维码见文末

提示：以下是本篇文章正文内容，下面案例可供参考

循环队列概述（图解）

  • 如图，模拟循环队列。

循环队列

  1. 队空：无论队头和队尾在什么位置，只要 Q.rear 和 Q.front 指向同一个位置，就认为是队空。
  2. 队满：当队尾 Q.rear 的下一个位置是 Q.front 时，就认为是队满。

如何判断循环条件下 Q.rear 的下一个位置是 Q.front ？

  • 队列的最大空间设为 Maxsize 。

  • 想要在循环中判断，我们只要在 Q.rear 移动和运算时，添加取模运算（%）操作即可。

  • 即队满条件为
    ( Q . r e a r + 1 ) % M a x s i z e = Q . f r o n t (Q.rear + 1) \% Maxsize = Q.front (Q.rear+1)%Maxsize=Q.front

循环队列的基本操作

  • 首先定义一个结构体（内部类），包含基地址和头尾索引。

c++代码如下（示例）：

struct SqQueue {
    int *base;//基地址
    int front, rear;//头索引 尾索引
};

java代码如下（示例）：

public static class SqQueue {
    int[] base;
    int front, rear;
}

1.初始化

  • 顺序队列定义好了之后，还要先定义一个最大的分配空间，顺序结构都是如此，需要预先分配空间。

空队

c++代码如下（示例）：

bool InitQueue(SqQueue &Q) {
    Q.base = new int[Maxsize];//分配空间
    if (!Q.base) {//创建失败
        return false;
    }
    Q.front = Q.rear = 0;
    return true;
}

java代码如下（示例）：

public static boolean initQueue(SqQueue q) {
    q.base = new int[maxsize];
    if (q.base == null) {
        return false;
    }
    q.front = q.rear = 0;
    return true;
}

2.入队

  • 判断队列是否已满。

  • 元素放入队尾 Q.rear 所指空间，然后 Q.rear 后移一位。

  • Q.rear 后移时，判断是否属于临界条件，需要进行加1后的取模运算。
    Q . r e a r = ( Q . r e a r + 1 ) % M a x s i z e Q.rear = (Q.rear + 1)\%Maxsize Q.rear=(Q.rear+1)%Maxsize
    入队动画
    c++代码如下（示例）：

bool EnQueue(SqQueue &Q, int e) {
    if ((Q.rear + 1) % Maxsize == Q.front) {//队满
        return false;
    }
    Q.base[Q.rear] = e;
    Q.rear = (Q.rear + 1) % Maxsize;//循环往复
    return true;
}

java代码如下（示例）：

public static boolean enQueue(SqQueue q, int e) {
    if ((q.rear + 1) % maxsize == q.front) {
        return false;
    }
    q.base[q.rear] = e;
    q.rear = (q.rear + 1) % maxsize;
    return true;
}

3.出队

  • 判断队列是否为空。

  • 元素出队，然后队头front后移一位。

  • Q.front 后移时，判断是否属于临界条件，需要进行加1后的取模运算。
    Q . f r o n t = ( Q . f r o n t + 1 ) % M a x s i z e Q.front = (Q.front + 1)\%Maxsize Q.front=(Q.front+1)%Maxsize
    出队

c++代码如下（示例）：

bool DeQueue(SqQueue &Q, int &e) {//出队元素e
    if (Q.rear == Q.front) {//队空
        return false;
    }
    e = Q.base[Q.front];
    Q.front = (Q.front + 1) % Maxsize;
    return true;
}

java代码如下（示例）：

public static int deQueue(SqQueue q) {
    if (q.rear == q.front) {
        return -1;
    }
    int e = q.base[q.front];
    q.front = (q.front + 1) % maxsize;
    return e;
}

4.查看队头元素

  • 注意判断队列是否有元素就行。

c++代码如下（示例）：

int GetHead(SqQueue Q) {
    if (Q.rear == Q.front) {
        return -1;
    }
    return Q.base[Q.front];
}

java代码如下（示例）：

public static int getHead(SqQueue q) {
    if (q.rear == q.front) {
        return -1;
    }
    return q.base[q.front];
}

5.队列长度

  • 因为是循环队列，判断队长时直接做差可能会有负数。需要经过取模运算处理。
    ( Q . r e a r − Q . f r o n t + M a x s i z e ) % M a x s i z e (Q.rear - Q.front + Maxsize)\%Maxsize (Q.rear−Q.front+Maxsize)%Maxsize
    c++代码如下（示例）：
int QueueLength(SqQueue Q) {
    return (Q.rear - Q.front + Maxsize) % Maxsize;
}

java代码如下（示例）：

public static int queueLength(SqQueue q) {
    return (q.rear - q.front + maxsize) % maxsize;
}

完整代码

c++代码如下（示例）：

#include<iostream>

using namespace std;
#define Maxsize 7

struct SqQueue {
    int *base;
    int front, rear;
};

bool InitQueue(SqQueue &Q) {
    Q.base = new int[Maxsize];
    if (!Q.base) {
        return false;
    }
    Q.front = Q.rear = 0;
    return true;
}

bool EnQueue(SqQueue &Q, int e) {
    if ((Q.rear + 1) % Maxsize == Q.front) {
        return false;
    }
    Q.base[Q.rear] = e;
    Q.rear = (Q.rear + 1) % Maxsize;
    return true;
}

bool DeQueue(SqQueue &Q, int &e) {
    if (Q.rear == Q.front) {
        return false;
    }
    e = Q.base[Q.front];
    Q.front = (Q.front + 1) % Maxsize;
    return true;
}

int GetHead(SqQueue Q) {
    if (Q.rear == Q.front) {
        return -1;
    }
    return Q.base[Q.front];
}

int QueueLength(SqQueue Q) {
    return (Q.rear - Q.front + Maxsize) % Maxsize;
}

int main() {
    SqQueue Q;
    int n, x;
    if (InitQueue(Q)) {
        cout << "循环队列初始化成功！" << endl;
    } else {
        cout << "循环队列初始化失败！" << endl;
        return 0;
    }
    cout << "请输入元素个数n：" << endl;
    cin >> n;
    if (n > Maxsize - 1) {
        cout << "溢出" << endl;
        return 0;
    }
    cout << "请依次输入元素" << endl;
    while (n--) {
        cin >> x;
        EnQueue(Q, x);
    }
    cout << endl;
    cout << "队列元素个数" << QueueLength(Q) << endl;
    cout << "对头元素：" << GetHead(Q) << endl;
    cout << "元素依次出队：" << endl;
    while (DeQueue(Q, x)) {
        cout << x << " ";
    }
    cout << endl;
    cout << "队列元素个数" << QueueLength(Q) << endl;
}

java代码如下（示例）：

import java.util.Scanner;

public class A {
    private static final int maxsize = 7;

    public static boolean initQueue(SqQueue q) {
        q.base = new int[maxsize];
        if (q.base == null) {
            return false;
        }
        q.front = q.rear = 0;
        return true;
    }

    public static boolean enQueue(SqQueue q, int e) {
        if ((q.rear + 1) % maxsize == q.front) {
            return false;
        }
        q.base[q.rear] = e;
        q.rear = (q.rear + 1) % maxsize;
        return true;
    }

    public static int deQueue(SqQueue q) {
        if (q.rear == q.front) {
            return -1;
        }
        int e = q.base[q.front];
        q.front = (q.front + 1) % maxsize;
        return e;
    }

    public static int getHead(SqQueue q) {
        if (q.rear == q.front) {
            return -1;
        }
        return q.base[q.front];
    }

    public static int queueLength(SqQueue q) {
        return (q.rear - q.front + maxsize) % maxsize;
    }

    public static void main(String[] args) {
        SqQueue q = new SqQueue();
        Scanner sc = new Scanner(System.in);
        int n, x;
        if (initQueue(q)) {
            System.out.println("循环队列初始化成功！");
        } else {
            System.out.println("初始化失败！");
        }
        System.out.println("元素个数n：");
        n = sc.nextInt();
        System.out.println("请依次输入每个元素");
        while (n-- > 0) {
            x = sc.nextInt();
            enQueue(q, x);
        }
        System.out.println("元素个数：" + queueLength(q));
        System.out.println("循环队列头元素：" + getHead(q));
        System.out.println("依次出队！");
        while (true) {
            x = deQueue(q);
            if (x != -1) {
                System.out.println(x + " ");
            } else {
                break;
            }
        }
        System.out.println("元素个数：" + queueLength(q));
    }

    public static class SqQueue {
        int[] base;
        int front, rear;
    }
}

总结

  • 以上便是今天的复习内容了，记着判断队满、队空时要进行模运算。
关注公众号，感受不同的阅读体验

请添加图片描述

下期预告： 链队列

真香！20张图揭开「队列」的迷雾，一目了然
李肖遥的专栏
09-15 547
关注、星标公众号，直达精彩内容ID：技术让梦想更伟大作者:李肖遥队列的概念首先我们联想一下链表，在单链表中，我们只能对他的链表表尾进行插入，对链表的表头进行结点的删除，这样强限制性的链表...
《画解数据结构》十张动图，画解双端队列
热门推荐
英雄哪里出来
02-25 1万+
十张动图，画解双端队列
循环队列
weixin_34360651的博客
01-27 165
循环队列类似栈，但是有两个口，一个专门用来入队，一个专门用来出队。由于入队出队不在一个端口，因此如果不适用循环队列，随着队列的使用，存储空间马上就被耗光了。在循环队列中，一个主要的知识点，就是如何判断队列为空，或者队列满。 这里主要有两个方法： 1 设置一个标记位，初始时，队列为空，我们设置flag=0;随着数据的使用，如果队满，设置flag=1; 2 使用一个空的数据位，这样rear指针永...
超全面Java中的队列（Queue）
最新发布
LL_break的博客
05-09 1553
本文图文并茂试图将抽象的概念以现实生活中的实例，具象队列旨在方便更好的理解队列，此外，还介绍了循环队列和双端队列（Deque）的概念及其实现方法，展示了如何用队列实现栈以及用栈实现队列 只有你知道什么是你的幸福 ------- 二十二 加油赶路人
数据结构——循环队列（GIF图解）
weixin_43294413的博客
12-17 4184
一、循环队列 数组队列的出队操作的复杂度是O(n)，性能很差，解决方法就是使用循环队列（Loop Queue） 在循环队列中，需要对队为空和队为满的时候进行判断，为了区分队空和队满两个条件，需要浪费capacity一个空间，让rear指针一直指向一个空的位置； 当 rear= =front 时，队为空； 当 (rear+1)%n= =front (n为数字角标的最大值)时，队为满. 示意图如下...
c++之数据结构——队列(queue)
weixin_45726901的博客
07-07 3116
关于队列的基本概念以及基本操作的c++实现队列的定义队列的基本理论队列的图解队列的基本操作队列的三种形式及其c++实现(以整型为例)-顺序队列 队列的定义 队列是一种最基本的数据结构，是一种只能在一端插入，另一端删除的特殊的线性表。 队列的基本理论 进行插入操作的一端称为队尾(rear)，进行删除操作的端称为队头(front)。 队列的插入操作叫做入队，删除操作叫做出队。 队列的特点：先进先出，故队列又称为先进先出（FIFO—first in first out）线性表。 队列的图解 每次出队时，队头
【C++】解析stack和queue底层数据结构 - - - - deque
宫瑞阳的博客
02-07 3501
stack和queue底层数据结构解析 deque源码解析
图解数据结构C++版源码
01-13
《图解数据结构》是一本深受程序员喜爱的书籍，它以直观易懂的方式介绍了各种重要的数据结构及其在C++中的实现。源码是学习和理解数据结构的关键辅助工具，能够帮助读者更深入地掌握每种数据结构的工作原理。在这个...
优先级队列--priority_queue
duchenlong的博客
05-15 740
了解下priority_queue优先级队列的底层实现，还有适配器以及仿函数的作用，最后回忆一下数据结构中的堆
队列 -- 循环队列
小神兵之技术篇
07-09 4621
实现队列的方法有很多，比如链表，动态数组等，这里主要介绍一下循环队列，首先我们用静态数组做个简单的队列：从上图很显然可以看出，全部出队后，将无法继续入队，这样的情况也叫做“假溢出”，即使数组中，明明还有空间可以利用，但是却无法使用。为了解决这样的问题，就引入了一个叫“循环队列”这
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

扑腾的江鱼

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

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

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

打赏作者

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

抵扣说明：

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

余额充值