循环队列 C++ 实现

已于 2022-07-26 17:14:54 修改
阅读量3.6k 收藏 41
点赞数 4
分类专栏： 数据结构与算法 文章标签： 数据结构 c++
于 2022-07-25 17:34:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52423355/article/details/125979861
版权

文章目录

循环队列

为解决假溢出问题，采用循环队列，循环队列即一种逻辑上的环状结构，但在物理空间上仍然为顺序存储，即数组

循环队列示例图
其中 f 为头指针，指向队列的第一个元素，r 为尾指针，指向队尾元素的下一个位置。


在这里插入图片描述

由于循环队列的处理有三种方法，此处先不给出具体结构体的定义；详细实现和采用的方式有关；

判断入队时队尾指针应该如何变化

一般情况，队尾指针简单后移 (rear + 1) 即可，队头指针不变

在这里插入图片描述

而当出现多次出队列以后，队尾指针到达数组最后一位时 (如下图)

在这里插入图片描述

简单的 rear + 1 将不会满足实际情况，此时，rear = (rear + 1) % MAX 将满足实际情况。并且此公式也适用于一般情况。因此可以得出结论，入队列时，在队列未满时，元素入队，队尾元素 rear = (rear + 1) % MAX ；

入队列前需要判断队列是否为满；

判断出队时队头指针应该如何变化

当队列非空时，队头元素出队列，队头指针移动；

出队列的指针变化和入队列一样 front = (front + 1) % MAX

在这里插入图片描述

出队需判断队列是否为空；

接下来讨论怎样判断队列的满或者空；

判断队列是否已满或已空

当队列已满时，有如下情况：

左图为一直入队列的情况，右图为出队列一次的情况

在这里插入图片描述

从图中可以看出，队满时，front = rear；是否能使用这个条件判断队列已满呢？再看队列为空时；

在这里插入图片描述

可见，在这种情况下不能使用 f = r 来判断队列为空，也不能判断队列已满；对此，有一些处理方式；

不同情况的实现方式

方式一

少使用一个存储单元，这样就可以避免队列满时 f = r，并且此时 f = r 可以判断队列为空；

在这里插入图片描述

此时，队满：(rear + 1) % MAX = front 队空：rear = front

结构体

typedef int Type;
#define MAX 20
typedef struct {
    Type data[MAX];
    int front, rear;
} SqQueue;

初始化

void InitQueue(SqQueue &Q) {
    Q.front = 0;
    Q.rear = 0;
}

入队列：(Q.rear + 1) % MAX == Q.front 为满

bool EnQueue(SqQueue &Q, Type x) {
    if((Q.rear + 1) % MAX == Q.front) {
        return false;
    }
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear + 1) % MAX;
    return true;
}

出队列：Q.front == Q.rear 时为空

bool DeQueue(SqQueue &Q, Type &x) {
    if(Q.front == Q.rear) {
        return false;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MAX;
    return true;
}

方式二

在结构体中设置一个表示队列大小的变量 size， 入队时加一，出队时减一，指针随之变化；

结构体

typedef struct {
    Type data[MAX];
    int front, rear;
    int size;
} SqQueue;

初始化

void InitQueue(SqQueue &Q) {
    Q.front = 0;
    Q.rear = 0;
    Q.size = 0;
}

入队列代码： size = MAX 时队列已满，不能入队列；

bool EnQueue(SqQueue &Q, Type x) {
    if(Q.size == MAX) {
        return false;
    }
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear + 1) % MAX;
    Q.size++;
    return true;
}

出队列：size = 0 为空，不能出队列；

bool DeQueue(SqQueue &Q, Type &x) {
    if(Q.size == 0) {
        return false;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MAX;
    return true;
}

方式三

在结构体中设置标志 tag， tag = 0 &&Q.front == Q.rear 表示队列为空， tag = 1 && Q.front == Q.rear 表示队列已满。初始时 tag 为 0，此后，若遇入队列后 Q.front == Q.rear 则表示队列必满，置 tag = 1;若遇到出队列后 Q.front == Q.rear 则表示队列必空；由此可写出其入队列和出队列代码；

结构体

typedef struct {
    Type data[MAX];
    int front, rear;
    int tag;
} SqQueue;

入队列：

Q.tag == 1 && Q.front == Q.rear 表示队列已满，若队列未满，则入队列，入队列后若 Q.front == Q.rear 则队列必满，此时置 tag 为 1；

bool EnQueue(SqQueue &Q, Type x) {
    if(Q.tag == 1 && Q.front == Q.rear) {
        return false;
    }
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear + 1) % MAX;
    if(Q.front == Q.rear) {			//若入栈后相等，此时队列必满
        Q.tag = 1;
    }
    return true;
}

出队列：

Q.tag == 0 && Q.front == Q.rear 表示队列已空，若队列未满，则入队列，出队列后若 Q.front == Q.rear 则队列必空，此时置 tag 为 0；

bool DeQueue(SqQueue &Q, Type &x) {
    if(Q.tag == 0 && Q.front == Q.rear) { //队列为空时
        return false;
    }
    x = Q.data[Q.front];
	Q.front = (Q.front + 1) % MAX;
    if(Q.front == Q.rear) {			//若出队列后相等，此时队列必空
        Q.tag = 0;
    }
    return true;
}

判空

  1. 空一个位置

    只有空的时候会出现 Q.front == Q.rear

    bool QueueEmpty(SqQueue Q) {
    if(Q.front == Q.rear) {
        return true;
    }
    return false;
}

  2. 设置 size

    bool QueueEmpty(SqQueue Q) {
    if(Q.size == 0) {
        return true;
    }
    return false;
}

  3. 设置 tag

    bool QueueEmpty(SqQueue Q) {
    if(Q.front == Q.rear && Q.tag == 0) {
        return true;
    }
    return false;
}

计算队列元素个数

  1. 方式一

    int length(SqQueue Q) {
    return (Q.rear + MAX - Q.front) % MAX;
}

  2. 方式二

    int length(SqQueue Q) {
    return Q.size;
}

  3. 方式三

    由于队列满时 Q.front == Q.rear，故需单独对队列满时进行处理

    int length(SqQueue Q) {
    if(Q.tag == 1 && Q.front == Q.rear) {
        return MAX;
    }
    return (Q.rear + MAX - Q.front) % MAX;
}

整体实现

由于有三种不同的循环队列处理方式，因此也使用三种不同方式

方式一

数组空一个位置

测试方案

测试方案：依次入队列至如下情况，此时将不能入队列， rear = 7，front = 0；

在这里插入图片描述

出队列四次，入队列两次，此时队头为 4，队尾指针为 1；

在这里插入图片描述

出队列置队列为空，进行判空

在这里插入图片描述

#include<iostream>
using namespace std;

typedef char Type;
#define MAX 8
typedef struct {
    Type data[MAX];
    int front, rear;
} SqQueue;


void InitQueue(SqQueue &Q) {
    Q.front = 0;
    Q.rear = 0;
}

bool EnQueue(SqQueue &Q, Type x) {
    if((Q.rear + 1) % MAX == Q.front) {
        return false;
    }
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear + 1) % MAX;
    return true;
}


bool DeQueue(SqQueue &Q, Type &x) {
    if(Q.front == Q.rear) {
        return false;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MAX;
    return true;
}


bool QueueEmpty(SqQueue Q) {
    if(Q.front == Q.rear) {
        return true;
    }
    return false;
}

int length(SqQueue Q) {
    return (Q.rear + MAX - Q.front) % MAX;
}


int main() {
    SqQueue queue;
    InitQueue(queue);
    char chs[7] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
    for(int i = 0; i < 7; i++) {
        EnQueue(queue, chs[i]);
    }
    if(!EnQueue(queue, 'x')) {
        cout << "队列已满，入队失败" << endl;
    }
    cout << queue.front << " " << queue.rear << endl;

    //出队四次
    Type x;
    DeQueue(queue, x);
    cout << x << endl;
    DeQueue(queue, x);
    cout << x << endl;
    DeQueue(queue, x);
    cout << x << endl;
    DeQueue(queue, x);
    cout << x << endl;

    cout << "队列元素个数为 " << length(queue) << endl;
    //入队两次
    EnQueue(queue, 'h');
    EnQueue(queue, 'i');
    cout << "队列元素个数为 " << length(queue) << endl;

    cout << queue.front << " " << queue.rear << endl;

    while(!QueueEmpty(queue)) {
        DeQueue(queue, x);
        cout << x << " ";
    }

    return 0;
}

/*
队列已满，入队失败
0 7
a
b
c
d
队列元素个数为 3
队列元素个数为 5
4 1
e f g h i
*/

通过结果分析，和手动模拟一致；

方式二

结构体中设置 size

由于此类情况可以使用全部空间，对此进行检验

测试方案

测试方案：依次入队列至如下情况，此时， rear = 7，front = 0；
在这里插入图片描述

出队列四次，入队列五次，此时队列已满；将不能继续入队，指针均为 4

在这里插入图片描述

出队列置队列为空，进行判空

#include<iostream>
using namespace std;

typedef char Type;
#define MAX 8
typedef struct {
    Type data[MAX];
    int front, rear;
    int size;
} SqQueue;


void InitQueue(SqQueue &Q) {
    Q.front = 0;
    Q.rear = 0;
    Q.size = 0;
}




bool EnQueue(SqQueue &Q, Type x) {
    if(Q.size == MAX) {
        return false;
    }
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear + 1) % MAX;
    Q.size++;
    return true;
}


bool DeQueue(SqQueue &Q, Type &x) {
    if(Q.size == 0) {
        return false;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MAX;
    Q.size--;
    return true;
}


bool QueueEmpty(SqQueue Q) {
    if(Q.size == 0) {
        return true;
    }
    return false;
}

int length(SqQueue Q) {
    return Q.size;
}


int main() {
    SqQueue queue;
    InitQueue(queue);
    char chs[7] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
    for(int i = 0; i < 7; i++) {
        EnQueue(queue, chs[i]);
    }
    cout << queue.front << " " << queue.rear << endl;

    //出队四次
    Type x;
    DeQueue(queue, x);
    cout << x << endl;
    DeQueue(queue, x);
    cout << x << endl;
    DeQueue(queue, x);
    cout << x << endl;
    DeQueue(queue, x);
    cout << x << endl;

    cout << "队列元素个数为 " << length(queue) << endl;
    //入队五次
    EnQueue(queue, 'h');
    EnQueue(queue, 'i');
    EnQueue(queue, 'j');
    EnQueue(queue, 'k');
    EnQueue(queue, 'l');
    cout << "队列元素个数为 " << length(queue) << endl;
    cout << queue.front << " " << queue.rear << endl;
    if(!EnQueue(queue, 'x')) {
        cout << "队列已满，入队失败" << endl;
    }

    while(!QueueEmpty(queue)) {
        DeQueue(queue, x);
        cout << x << " ";
    }

    return 0;
}
/*
0 7
a
b
c
d
队列元素个数为 3
队列元素个数为 8
4 4
队列已满，入队失败
e f g h i j k l
*/

方式三

此处和方式二使用同样的测试方案；

#include<iostream>
using namespace std;

typedef char Type;
#define MAX 8
typedef struct {
    Type data[MAX];
    int front, rear;
    int tag;
} SqQueue;


void InitQueue(SqQueue &Q) {
    Q.front = 0;
    Q.rear = 0;
    Q.tag = 0;
}

bool EnQueue(SqQueue &Q, Type x) {
    if(Q.tag == 1 && Q.front == Q.rear) {
        return false;
    }
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear + 1) % MAX;
    if(Q.front == Q.rear) {			//若入栈后相等，此时队列必满
        Q.tag = 1;
    }
    return true;
}


bool DeQueue(SqQueue &Q, Type &x) {
    if(Q.tag == 0 && Q.front == Q.rear) { //队列为空时
        return false;
    }
    x = Q.data[Q.front];
	Q.front = (Q.front + 1) % MAX;
    if(Q.front == Q.rear) {			//若出栈后相等，此时队列必空
        Q.tag = 0;
    }
    return true;
}


bool QueueEmpty(SqQueue Q) {
    if(Q.front == Q.rear && Q.tag == 0) {
        return true;
    }
    return false;
}
int length(SqQueue Q) {
    if(Q.tag == 1 && Q.front == Q.rear) {
        return MAX;
    }
    return (Q.rear + MAX - Q.front) % MAX;
}


int main() {
    SqQueue queue;
    InitQueue(queue);
    char chs[7] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
    for(int i = 0; i < 7; i++) {
        EnQueue(queue, chs[i]);
    }
    cout << queue.front << " " << queue.rear << endl;

    //出队四次
    Type x;
    DeQueue(queue, x);
    cout << x << endl;
    DeQueue(queue, x);
    cout << x << endl;
    DeQueue(queue, x);
    cout << x << endl;
    DeQueue(queue, x);
    cout << x << endl;

    cout << "队列元素个数为 " << length(queue) << endl;
    //入队五次
    EnQueue(queue, 'h');
    EnQueue(queue, 'i');
    EnQueue(queue, 'j');
    EnQueue(queue, 'k');
    EnQueue(queue, 'l');
    cout << "队列元素个数为 " << length(queue) << endl;
    cout << queue.front << " " << queue.rear << endl;
    if(!EnQueue(queue, 'x')) {
        cout << "队列已满，入队失败" << endl;
    }

    while(!QueueEmpty(queue)) {
        DeQueue(queue, x);
        cout << x << " ";
    }

    return 0;
}
/*
0 7
a
b
c
d
队列元素个数为 3
队列元素个数为 8
4 4
队列已满，入队失败
e f g h i j k l
*/
循环队列（C++）
12-18
利用template模板实现循环队列，队列入队、提取队首元素、删除队首元素。
循环队列 C++不同策略模板实现
12-11
4. **C++实现循环队列**：C++中，我们可以使用`std::array`或动态分配的数组来表示队列的存储空间，用两个指针分别表示队头和队尾的位置。为了实现循环，我们需要在进行进队和出队操作时处理边界条件，例如队头等于...
C++实现循环队列
qq_45139003的博客
11-16 6317
c++实现循环队列中的基本操作： 1、循环队列的初始化 2、循环队列的入队 3、循环队列的出队 4、循环队列的取值 5、循环队列的求长 6、循环队列的判空 7、循环队列的清空 8、循环队列的销毁 9、循环队列的打印 有了用C++实现顺序表和顺序栈的基础后，编写循环队列的代码就会容易很多，相应的链接如下： 代码实现： //Data：2021/11/16 #include <iostream> using namespace std; #define Maxsize 100 ..
C++：队列的实现和使用
最新发布
han2205277149的博客
10-01 1298
队列（Queue）是一种在队列的尾部，在队列的头部。因此，队列遵循（FIFO, First In First Out）的原则，即最早进入队列的元素最先被处理。
循环队列(C++)
weixin_73567058的博客
05-25 1245
顺序队列的主要瓶颈在于队首的位置不可变，出队后队列内其他元素必须整体向前移动一个位置，若处理大量数据时，则会带来较多时间复杂度为O(n)的操作。_k用于记录队列的最大容量。通常，循环队列使用固定长度的数组来表示队列元素，头和尾指针挂钩形成循环的维度感知队列长度，并提高队列操作效率，因为这种结构需要的内存量比链表数据结构更小。在循环队列中，所有元素都保存在一个连续的数组中，并且队列的两端都连接在数组的两端上。实际上这里使用了数组的一部分来表示队列，为了避免队列在完全满时和空时的判断异常，被留空的一个位置。
C++循环队列
万阁
12-29 363
文章目录C++循环队列自定义循环队列 C++循环队列 自定义循环队列 #pragma once template<class T> class ELoopQueue { private: int Size;//队列大小 int Count;//队列成员数量 int HeadId;//队首索引 T **Date;//队列 public: //循环队列 //size 循环队列大小(size >= 1) ELoopQueue(int s
循环队列C++ 实现方法
08-22
总结来说，C++实现的循环队列是一个高效的数据结构，通过巧妙地处理索引来实现在有限空间内的“循环”操作，适用于需要快速插入和删除操作的场景。在实际应用中，循环队列常用于实现缓冲区、任务调度等。
c++实现的无锁环形队列
11-05
1. c++实现的无锁环形队列，注释详细，讲解了环形队列的实现原理和操作技巧 2. 在linux服务器下，可以自己编译，运行，也可以修改参数后做测试 3. 编译的命令如下：g++ -std=c++11 -o test main.cpp ring_buffer.cpp...
C++实现循环队列和链式队列的示例
08-28
C++实现循环队列和链式队列的示例 本文将详细介绍C++语言中实现循环队列和链式队列的示例代码，包括循环队列的实现原理、链式队列的实现原理、测试代码等。 一、循环队列的实现原理 循环队列是一种特殊的队列，它...
c++循环队列
07-24
c++实现的一个可用的循环队列，性能非常好，测试可用，
循环队列-c++
ForeverCodingGuy的博客
12-07 448
队列是一种常用的数据结构，但我们平常实现的队列有一个缺陷。想象一下，假设一个已经填满的队列，我们开始不断弹出队头元素，这时候我们会发现，虽然队尾看上去是满了，但实际上前面许多空间并没有使用，造成极大浪费。那么我们该怎么解决这个问题呢？ 我们可以采用循环队列的方式。既然前面还没用，我们再绕回到前面不就好了吗。 具体看下图 如果能理解这一点，那么下面的代码也就很显然了。 #include<iostream> #include<cassert> using namespa..
C++ 循环队列
03-04 2561
出处：http://hi.baidu.com/qq0400/item/06b51ed6c780385ad63aae8f 循环队列     　为充分利用向量空间，克服"假上溢"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。 （1） 循环队列的基本操作     　循环队列中进行出队、入队操作时，头
C++ 循环队列实现与应用解析
"C++ 队列详解，包含循环队列的实现代码，包括构造函数、析构函数、入队、出队、获取队头元素以及判断队列是否为空等操作。" 在C++编程中，队列是一种线性数据结构，遵循“先进先出”（FIFO）原则，即最先插入的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值