数据结构（C语言）——第三章、栈与队列（2）队列

最新推荐文章于 2023-08-21 23:47:46 发布
最新推荐文章于 2023-08-21 23:47:46 发布
阅读量121 收藏
点赞数
分类专栏： 数据结构 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_43416592/article/details/120101463
版权

循环队列 链式队列 空间优化 入队 出队
关键词由CSDN通过智能技术生成

目录

循环队列

方式1：队头队尾为0（浪费一个空间）
//
// @Author: Brisa
// @Date: 2021/8/27
// @Description: 循环队列（顺序存储） 队头队尾：0
//
#include<stdio.h>
#define MaxSize 10  //定义队列中元素的最大个数
#define ElemType int

//顺序队列类型定义
typedef struct {
    ElemType data[MaxSize];  //静态数组存放队列元素
    int front, rear;  //队头指针、队尾指针
}SqQueue;

/*函数声明*/
void InitQueue(SqQueue &Q);  //1.初始化队列
bool QueueEmpty(SqQueue Q);  //2.判空
bool EnQueue(SqQueue &Q, ElemType e);  //3.入队
bool ExQueue(SqQueue &Q, ElemType &e); //4.出队
bool GetHead(SqQueue Q, ElemType &e);  //5.获取队头元素


/*具体函数*/
//1.初始化队列
void InitQueue(SqQueue &Q){
    /*初始时，队头队尾指针都指向0*/
    Q.front = 0; //队头指针指向队头元素
    Q.rear = 0;  //队尾指针指向队尾元素的最后一个位置，即【下一个要插入的位置】
}

//2.判空
bool QueueEmpty(SqQueue Q){
    return (Q.front==Q.rear);
}

//3.入队
bool EnQueue(SqQueue &Q, ElemType e){
    if((Q.rear+1) % MaxSize == Q.front)  //【队满】，报错
        return false;
    Q.data[Q.rear] = e;  //新元素插入队尾
    Q.rear = (Q.rear + 1) % MaxSize;  //队尾指针+1取模
    // 用模运算将存储空间在逻辑上变成“环状”，这也是叫循环队列的原因
    return true;
}

//4.出队
bool ExQueue(SqQueue &Q, ElemType &e){
    if(Q.front == Q.rear)  //【队空】，报错
        return false;
    e = Q.data[Q.front]; //返回队头元素的值
    Q.front = (Q.front + 1) % MaxSize;  //队头指针+1取模，指向下一个元素
    return true;
}

//5.获取队头元素
bool GetHead(SqQueue Q, ElemType &e){
    if(Q.front == Q.rear)  //【队空】，报错
        return false;
    e = Q.data[Q.front]; //返回队头元素的值
    return true;
}

int main(){
    //声明一个循环队列
    SqQueue Q;

    //初始化循环队列
    InitQueue(Q);

    //判空
    printf("当前循环队列是否为空：%s \n", QueueEmpty(Q)?"是":"否");

    //入队
    ElemType e1;
    printf("请输入你想要入队的值：");
    scanf("%d", &e1);
    if(EnQueue(Q,e1))
        printf("新元素入队成功！\n");
    else
        printf("队列已满，新元素入队失败！\n");

    //读取队头元素
    ElemType e2;
    if(GetHead(Q,e2))
        printf("队头元素读取成功，当前队头元素为：%d\n", e2);
    else
        printf("队列为空，队头元素读取成功失败！\n");

    //出队
    ElemType e3;
    if(ExQueue(Q,e3))
        printf("队头元素出队成功，出队元素值为：%d\n", e3);
    else
        printf("队列为空，队头元素出队失败！\n");

    //读取队头元素
    ElemType e4;
    if(GetHead(Q,e4))
        printf("队头元素读取成功，当前队头元素为：%d\n", e4);
    else
        printf("队列为空，队头元素读取成功失败！\n");

    return 0;
}
方式2：新增一个size变量，表示当前队列长度（不浪费空间）
//
// @Author: Brisa
// @Date: 2021/8/27
// @Description: 循环队列（顺序存储） 队头队尾：0
//               新增一个size变量，表示当前队列长度
//               为判空判满提供方便且节省一个队列单元
//
#include<stdio.h>
#define MaxSize 10  //定义队列中元素的最大个数
#define ElemType int

//顺序队列类型定义
typedef struct {
    ElemType data[MaxSize];  //静态数组存放队列元素
    int front, rear;  //队头指针、队尾指针
    int size;  //【引入辅助变量size表示队列当前长度，为判空判满提供方便且节省一个队列单元】
}SqQueue;

/*函数声明*/
void InitQueue(SqQueue &Q);  //1.初始化队列
bool QueueEmpty(SqQueue Q);  //2.判空
bool EnQueue(SqQueue &Q, ElemType e);  //3.入队
bool ExQueue(SqQueue &Q, ElemType &e); //4.出队
bool GetHead(SqQueue Q, ElemType &e);  //5.获取队头元素


/*具体函数*/
//1.初始化队列
void InitQueue(SqQueue &Q){
    /*初始时，队头队尾指针都指向0*/
    Q.front = 0; //队头指针指向队头元素
    Q.rear = 0;  //队尾指针指向队尾元素的最后一个位置，即【下一个要插入的位置】
    Q.size = 0;  //队列初始化长度为0
}

//2.判空
bool QueueEmpty(SqQueue Q){
    return (Q.size == 0);  //队列中元素个数为0则为空
}

//3.入队
bool EnQueue(SqQueue &Q, ElemType e){
    if(Q.size == MaxSize)  //【队满】，报错
        return false;
    Q.data[Q.rear] = e;  //新元素插入队尾
    Q.rear = (Q.rear + 1) % MaxSize;  //队尾指针+1取模
    // 用模运算将存储空间在逻辑上变成“环状”，这也是叫循环队列的原因
    Q.size++;  //队列长度+1
    return true;
}

//4.出队
bool ExQueue(SqQueue &Q, ElemType &e){
    if(Q.size == 0)  //【队空】，报错
        return false;
    e = Q.data[Q.front]; //返回队头元素的值
    Q.front = (Q.front + 1) % MaxSize;  //队头指针+1取模，指向下一个元素
    Q.size--;  //队列长度-1
    return true;
}

//5.获取队头元素
bool GetHead(SqQueue Q, ElemType &e){
    if(Q.size == 0)  //【队空】，报错
        return false;
    e = Q.data[Q.front]; //返回队头元素的值
    return true;
}

int main(){
    //声明一个循环队列
    SqQueue Q;

    //初始化循环队列
    InitQueue(Q);

    //判空
    printf("当前循环队列是否为空：%s \n", QueueEmpty(Q)?"是":"否");

    //入队
    ElemType e1;
    printf("请输入你想要入队的值：");
    scanf("%d", &e1);
    if(EnQueue(Q,e1))
        printf("新元素入队成功！\n");
    else
        printf("队列已满，新元素入队失败！\n");

    //读取队头元素
    ElemType e2;
    if(GetHead(Q,e2))
        printf("队头元素读取成功，当前队头元素为：%d\n", e2);
    else
        printf("队列为空，队头元素读取成功失败！\n");

    //出队
    ElemType e3;
    if(ExQueue(Q,e3))
        printf("队头元素出队成功，出队元素值为：%d\n", e3);
    else
        printf("队列为空，队头元素出队失败！\n");

    //读取队头元素
    ElemType e4;
    if(GetHead(Q,e4))
        printf("队头元素读取成功，当前队头元素为：%d\n", e4);
    else
        printf("队列为空，队头元素读取成功失败！\n");

    return 0;
}
方式3：新增tag变量表示最后一次操作是入队还是出队 0:出队 1:入队（不浪费空间）
//
// @Author: Brisa
// @Date: 2021/8/27
// @Description: 循环队列（顺序存储） 队头队尾：0
//               新增tag变量表示最后一次操作是入队还是出队 0:出队 1:入队
//               为判空判满提供方便且节省一个队列单元
//

#include<stdio.h>
#define MaxSize 10  //定义队列中元素的最大个数
#define ElemType int

//顺序队列类型定义
typedef struct {
    ElemType data[MaxSize];  //静态数组存放队列元素
    int front, rear;  //队头指针、队尾指针
    int tag;  //【引入辅助变量tag表示最后一次入队出队，为判空判满提供方便且节省一个队列单元】
}SqQueue;

/*函数声明*/
void InitQueue(SqQueue &Q);  //1.初始化队列
bool QueueEmpty(SqQueue Q);  //2.判空
bool EnQueue(SqQueue &Q, ElemType e);  //3.入队
bool ExQueue(SqQueue &Q, ElemType &e); //4.出队
bool GetHead(SqQueue Q, ElemType &e);  //5.获取队头元素


/*具体函数*/
//1.初始化队列
void InitQueue(SqQueue &Q){
    /*初始时，队头队尾指针都指向0*/
    Q.front = 0; //队头指针指向队头元素
    Q.rear = 0;  //初始化时【队尾指针指向队头指针的前一个元素】，这样在之后的操作中队尾指针始终指向队尾元素
    Q.tag = 0;  //初始化最后一次操作为删除，因为当前队空
}

//2.判空
bool QueueEmpty(SqQueue Q){
    return (Q.front==Q.rear && Q.tag==0);
    //队尾+1=队头 且 最后一次进行是出队操作则队空
}

//3.入队
bool EnQueue(SqQueue &Q, ElemType e){
    //队尾=队头 且 最后一次进行是入队操作则队满
    if(Q.rear==Q.front && Q.tag == 1)  //【队满】，报错
        return false;
    // 用模运算将存储空间在逻辑上变成“环状”，这也是叫循环队列的原因
    Q.data[Q.rear] = e;  //新元素插入队尾
    Q.rear = (Q.rear + 1) % MaxSize;  //队尾指针+1取模
    Q.tag = 1;  //标识此次进行的是入队操作
    return true;
}

//4.出队
bool ExQueue(SqQueue &Q, ElemType &e){
    if(Q.rear==Q.front && Q.tag == 0)  //【队空】，报错
        return false;
    e = Q.data[Q.front]; //返回队头元素的值
    Q.front = (Q.front + 1) % MaxSize;  //队头指针+1取模，指向下一个元素
    Q.tag = 0;  //标识此次进行的是出队操作
    return true;
}

//5.获取队头元素
bool GetHead(SqQueue Q, ElemType &e){
    if(Q.rear==Q.front && Q.tag == 0)  //【队空】，报错
        return false;
    e = Q.data[Q.front]; //返回队头元素的值
    return true;
}

int main(){
    //声明一个循环队列
    SqQueue Q;

    //初始化循环队列
    InitQueue(Q);

    //判空
    printf("当前循环队列是否为空：%s \n", QueueEmpty(Q)?"是":"否");

    //入队
    ElemType e1;
    printf("请输入你想要入队的值：");
    scanf("%d", &e1);
    if(EnQueue(Q,e1))
        printf("新元素入队成功！\n");
    else
        printf("队列已满，新元素入队失败！\n");

    //本段代码仅用作测试-循环入队直至队满
    /*ElemType e1;
    printf("初始rear为：%d\n", Q.rear);
    int n=1;
    while (!(Q.rear== Q.front && Q.tag == 1)) {	//队不满则一直入队
        printf("请输入第%d个元素的值：",n);
        scanf("%d", &e1);
        EnQueue(Q, e1);
        printf("当前rear为：%d\n", Q.rear);		//查看入队后的rear变化
        n++;
    }*/


    //读取队头元素
    ElemType e2;
    if(GetHead(Q,e2))
        printf("队头元素读取成功，当前队头元素为：%d\n", e2);
    else
        printf("队列为空，队头元素读取成功失败！\n");

    //出队
    ElemType e3;
    if(ExQueue(Q,e3))
        printf("队头元素出队成功，出队元素值为：%d\n", e3);
    else
        printf("队列为空，队头元素出队失败！\n");


    /*本段代码仅用作测试-循环入队直至队满*/
    /*ElemType e3;
    printf("初始front为：%d\n", Q.rear);
    n=1;
    while (!(Q.rear== Q.front && Q.tag == 0)) {	//队不空则一直出队
        ExQueue(Q, e3);
        printf("出队元素值为：%d，当前front为：%d，\n", e3, Q.front);		//查看入队后的rear变化
        n++;
    }*/

    //读取队头元素
    ElemType e4;
    if(GetHead(Q,e4))
        printf("队头元素读取成功，当前队头元素为：%d\n", e4);
    else
        printf("队列为空，队头元素读取成功失败！\n");

    return 0;
}

链队列

1.带头结点
//
// @Author: Brisa
// @Date: 2021/8/28
// @Description: 链式队列（带头结点）
//
#include<stdio.h>
#include <stdlib.h>

#define ElemType int

//链式队列结点
typedef struct LinkNode{
    ElemType data;  //数据域
    struct LinkNode *next;  //指针域
}LinkNode;
//链式队列
typedef struct {
    LinkNode *front, *rear; //队列的队头和队尾指针
}LinkQueue;

/*函数声明*/
void InitQueue(LinkQueue &Q);              //1.初始化队列（带头结点）
bool EmptyQueue(LinkQueue Q);              //2.判空
bool EnQueue(LinkQueue &Q, ElemType e);    //3.入队
bool ExQueue(LinkQueue &Q, ElemType &e);   //4.出队
bool GetTop(LinkQueue Q, ElemType &e);     //5.获取队头元素


/*具体函数*/
//1.初始化队列（带头结点）
void InitQueue(LinkQueue &Q){
    //初始化时，front和rear都指向头结点
    Q.front = Q.rear = (LinkNode *)malloc(sizeof(LinkNode));
    Q.front->next = NULL;  //头结点初始化为NULL
}

//2.判空
bool EmptyQueue(LinkQueue Q){
    return (Q.front == Q.rear);
    // 或者 Q.front->next==NULL;
}

//3.入队
bool EnQueue(LinkQueue &Q, ElemType e){
    LinkNode *p = (LinkNode *)malloc(sizeof(LinkNode));
    if(p == NULL)
        return false;//内存不足，分配失败
    p->data = e;
    p->next = NULL;
    Q.rear->next = p;  //新结点插入到rear
    Q.rear = p;  //修改表尾指针
    return true;
}

//4.出队
bool ExQueue(LinkQueue &Q, ElemType &e){
    if(Q.front == Q.rear)  //队空
        return false;
    LinkNode *q = Q.front->next;  //q结点指向front之后的结点
    e = q->data;  //用e返回队头元素的值
    Q.front->next = q->next; //更改头结点的next
    if(Q.rear == q)  //【若是最后一个结点出队，则rear要修改】
        Q.rear = Q.front;
    free(q);
    return true;
}
//5.获取队头元素
bool GetTop(LinkQueue Q, ElemType &e){
    if(Q.front == Q.rear)  //队空
        return false;
    LinkNode *q = Q.front->next;  //q结点指向front之后的结点
    e = q->data;  //用e返回队头元素的值
    return true;
}

int main(){
    //声明一个链式队列
    LinkQueue Q;
    //1.初始化队列（带头结点）
    InitQueue(Q);
    //2.判空
    printf("当前链式队列（带头结点）是否为空：%s \n", EmptyQueue(Q)?"是":"否");

    //3.入队
    ElemType e1;
    printf("请输入你想要入队的值：");
    scanf("%d", &e1);
    if(EnQueue(Q, e1)){
        printf("新元素入队成功！\n");
    }else{
        printf("内存不足，分配失败！\n");
    }

    //4.获取队头元素
    ElemType e2;
    if(GetTop(Q, e2)){
        printf("获取队头元素成功，队头元素为：%d\n", e2);
    } else{
        printf("队列为空，获取队头元素失败！\n");
    }
    //5.出队
    ElemType e3;
    if(ExQueue(Q, e3)){
        printf("出队成功，出队队头元素为：%d\n", e3);
    } else{
        printf("队列为空，出队失败！\n");
    }

    //6.获取队头元素
    ElemType e4;
    if(GetTop(Q, e4)){
        printf("获取队头元素成功，队头元素为：%d\n", e4);
    } else{
        printf("队列为空，获取队头元素失败！\n");
    }
    return 0;
}
2.不带头结点
//
// @Author: Brisa
// @Date: 2021/8/28
// @Description: 链式队列（不带头结点）
//

#include<stdio.h>
#include<stdlib.h>


#define ElemType int

//链式队列结点
typedef struct LinkNode{
    ElemType data;  //数据域
    struct LinkNode *next;  //指针域
}LinkNode;
//链式队列
typedef struct {
    LinkNode *front, *rear; //队列的队头和队尾指针
}LinkQueue;

/*函数声明*/
void InitQueue(LinkQueue &Q);              //1.初始化队列（带头结点）
bool EmptyQueue(LinkQueue Q);              //2.判空
bool EnQueue(LinkQueue &Q, ElemType e);    //3.入队
bool ExQueue(LinkQueue &Q, ElemType &e);   //4.出队
bool GetTop(LinkQueue Q, ElemType &e);     //5.获取队头元素


/*具体函数*/
//1.初始化队列（带头结点）
void InitQueue(LinkQueue &Q){
    //初始化时，front和rear都指向NULL
    Q.front = NULL;
    Q.rear = NULL;  //头结点初始化为NULL
}

//2.判空
bool EmptyQueue(LinkQueue Q){
    return (Q.front == NULL);
}

//3.入队
bool EnQueue(LinkQueue &Q, ElemType e){
    LinkNode *p = (LinkNode *)malloc(sizeof(LinkNode));
    if(p == NULL)
        return false;//内存不足，分配失败
    p->data = e;
    p->next = NULL;
    if(Q.front ==NULL){  //在空队列中插入第一个元素，【不带头结点的队列，第一个元素入队要特别处理】
        //修改队头队尾指针
        Q.front = p;
        Q.rear = p;
    } else{
        Q.rear->next = p;  //新结点插入到rear
        Q.rear = p;  //修改表尾指针
    }

    return true;
}

//4.出队
bool ExQueue(LinkQueue &Q, ElemType &e){
    if(Q.front == NULL)  //队空
        return false;
    LinkNode *q = Q.front;  //q结点指向front的结点
    e = q->data;  //用e返回队头元素的值
    Q.front = q->next; //更改头结点的next
    if(Q.rear == q) { //【若是最后一个结点出队，则front，rear要修改为NULL】
        Q.rear = NULL;
        Q.front = NULL;
    }
    free(q);
    return true;
}
//5.获取队头元素
bool GetTop(LinkQueue Q, ElemType &e){
    if(Q.front == NULL)  //队空
        return false;
    LinkNode *q = Q.front;  //q结点指向front之后的结点
    e = q->data;  //用e返回队头元素的值
    return true;
}

int main(){
    //声明一个链式队列
    LinkQueue Q;
    //1.初始化队列（不带头结点）
    InitQueue(Q);
    //2.判空
    printf("当前链式队列（不带头结点）是否为空：%s \n", EmptyQueue(Q)?"是":"否");

    //3.入队
    ElemType e1;
    printf("请输入你想要入队的值：");
    scanf("%d", &e1);
    if(EnQueue(Q, e1)){
        printf("新元素入队成功！\n");
    }else{
        printf("内存不足，分配失败！\n");
    }

    //4.获取队头元素
    ElemType e2;
    if(GetTop(Q, e2)){
        printf("获取队头元素成功，队头元素为：%d\n", e2);
    } else{
        printf("队列为空，获取队头元素失败！\n");
    }
    //5.出队
    ElemType e3;
    if(ExQueue(Q, e3)){
        printf("出队成功，出队队头元素为：%d\n", e3);
    } else{
        printf("队列为空，出队失败！\n");
    }

    //6.获取队头元素
    ElemType e4;
    if(GetTop(Q, e4)){
        printf("获取队头元素成功，队头元素为：%d\n", e4);
    } else{
        printf("队列为空，获取队头元素失败！\n");
    }
    return 0;
}

参考来源：
数据结构代码参考博客
《王道数据结构》

Brisa56
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-链队的基本操作函数的实现（含全部代码）
关注网络安全、云原生安全
09-18 6671
主要包含以下函数：        InitQueue(LinkQueue &amp;Q) 参数：链队Q 功能：初始化  时间复杂度O(1)     EnQueue(LinkQueue &amp;Q,QElemType e) 参数：链队Q,元素e 功能：将e入队 时间复杂度:O(1)     DeQueue(LinkQueue &amp;Q,QElemType &amp;e) 参数：链队Q,元...
数据结构与算法学习笔记——数据结构（五）：队列
最初的模样
08-10 251
1、介绍 队列是一个有序列表，可以用数组或是链表来实现。遵循先入先出的原则。 2、思路分析 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图，其中 maxSize 是该队列的最大容量。 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front 及 rear 分别记录队列前后端的下标， front 会随着数据输出而改变，而 rear 则是随着数据输入而改变，如图所示： 当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤
数据结构(四)--队列
weixin_30470643的博客
12-27 217
数据结构(四)--队列 本文主要讲解了队列的定义和队列主要功能实现的算法。最后会列举一些队列在程序设计当中常见的应用实例！相信了解了队列对你理解数据结构和程序设计会更加有益处！ 1. 队列的定义 队列 (Queue)是一种先进先出(first in first out : FIFO)的线性表。它只允许在表的一端进行插入，在另一端进行删除元素。这和我们平时战队买票很一样。最早进入队列的元素...
数据结构———队列
champ_的博客
08-21 169
因为只有入队操作才可能导致队列为满，只有出队操作才可能导致队列为空。当变量表示入队时，在这种条件下，如果数据的数量==10，则队列为满当变量表示出队时，在这种条件下，如果数据的数量==0 ，则队列为空那么这时候怎么表示数据的个数呢？还是用num++ num--吗？这时候有一个固定公式：（rear+MAX-front）%MAX ==数据的个数。
C++常用数据结构---------------队列
L_smartworld的博客
04-29 339
队列: 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 STL中的方法使用: 1.back() 返回一个引用，指向最后一个元素 2.empty() 如果队列空则返回真 3.front() 返回第一个元素 4.pop() 删除第一...
数据结构（C语言版） 栈与队列 迷宫问题
06-10
在C语言版的数据结构课程中，第三章深入探讨了两种基础但非常重要的数据结构——栈和队列，并应用它们解决实际问题，如迷宫问题。 栈是一种后进先出（LIFO）的数据结构，类似于我们日常生活中的叠放物品。它主要...
数据结构：第3章栈和队列B.ppt
06-12
在本章中，我们将重点讨论两种重要的数据结构——栈和队列。 栈是一种后进先出（LIFO，Last In First Out）的数据结构，它的主要特点是只能在一端进行插入和删除操作，通常称为栈顶。栈在计算机科学中有多种应用，...
数据结构第五章-树与二叉树 二叉树的C语言实现代码
最新发布
05-22
该资源中为【数据结构】专栏——C语言实现二叉树篇章中涉及到的代码 代码中包含以下内容： 1. 二叉树相关头文件： - 二叉链表的数据类型声明 - 链队列结点类型声明 - 链队列类型声明 - 二叉树基本功能（二叉树的...
数据结构——基于C语言实现杨辉三角
08-11
总的来说，这个项目提供了学习和实践C语言、数据结构（特别是循环队列）、以及理解杨辉三角如何在实际编程中应用的机会。通过这种方式，我们可以增强对算法和数据结构的理解，这对于任何想要深入计算机科学的人来说...
第三章：程序的灵魂-算法_C语言与数据结构PPT3_
10-01
在本节“第三章：程序的灵魂-算法”中，我们将深入探讨C语言与数据结构中的核心概念——算法。算法是程序设计的灵魂，是解决问题或执行特定任务的精确步骤序列。在计算机科学中，理解并掌握算法是提升编程能力的关键...
SqQueue.cpp
10-29
SqQueue.cpp
数据结构(Java)---队列
I_am_fine_的博客
02-27 1257
简述队列的使用以及一些概念
队列整理笔记
weixin_45889436的博客
10-07 196
队列基本概念 定义：操作受限的线性表，允许一端（队头）删除（出队），另一端（队尾）插入（入队） 特点：FIFO（先进先出） 基本操作 初始化:initQueue(&q) 初始化头尾指针 队列判断空：QueueEmpty（q）:判断空条件 入队：EnQueue(&q,key):若不满，入队成为队尾 出队：DeQueue（&q,&key）非空，队头出队 读取对头元素：GetQueue(1,&key)非空，读取 队列的顺序存储 定义：利用连续的一块存储.
数据结构-循环队列的基本操作函数实现（含全部代码）
关注网络安全、云原生安全
09-17 1万+
主要包含以下函数： InitQueue(SqQueue &Q) 参数：循环队列Q 功能：初始化循环队列Q 时间复杂度：O(1) QueueEmpty(SqQueue Q) 参数：循环队列Q 功能：判断队空与否 时间复杂度：O(1) EnQueue(SqQueue &Q,QElemType e)...
数据结构——队列（Quene）（小白入门第三天）
qq_50645064的博客
07-18 2953
小白自学进阶道路
队列数据结构
Jeffxu_lib的博客
09-02 465
一、队列：一种可以实现先进先出的存储结构 1、队列可以分为： 链式队列（动态）：用链表来实现 静态队列（顺序队列）：用数组来实现（静态队列通常都必须是循环队列） 2、链式队列结构如下图： 3、静态队列一般都是循环队列，其目的是为了能重复使用数组的内存，减少内存的浪费。 （1）、如下图所示的循环队列： front = 0 ，rear = 5 ，此时循环队列已满。如下图的队列...
数据结构：循环队列（C语言实现）
热门推荐
lpp0900320123的专栏
03-07 12万+
生活中有很多队列的影子，比如打饭排队，买火车票排队问题等，可以说与时间相关的问题，一般都会涉及到队列问题；从生活中，可以抽象出队列的概念，队列就是一个能够实现“先进先出”的存储结构。队列分为链式队列和静态队列；静态队列一般用数组来实现，但此时的队列必须是循环队列，否则会造成巨大的内存浪费；链式队列是用链表来实现队列的。这里讲的是循环队列，首先我们必须明白下面几个问题 一、循环队列的基础知识 1
数据结构学习笔记——队列
qq_45212020的博客
04-04 303
队列的顺序实现 顺序队列的定义 typedef struct//顺序队列的定义 { int data[Maxsize];//静态数组 int front, rear;//队头指针 队尾指针 }SqQueue; 顺序队列的初始化 队尾指针指向队尾元素的下一个位置 void InitQueue(SqQueue& Q)//初始化队列 { Q.rear = Q.front = 0;//初始时队列的队头队尾指向0 } 判断顺序队列是否为空 队列为空的条件：Q.rear==Q.fro
顺序队列
qq_32113889的博客
07-20 465
#include <stdio.h> #include <stdbool.h> #include <stdlib.h> #define MaxSize 10 typedef struct { char name[20]; }ElemType; typedef struct { ElemType data[MaxSize]; int front,rear; // int size; 这种方法可以不浪费那个多出来的空间，不过却多了一.
C语言数据结构：初学者必修——栈与队列详解
首先，在第3章“栈和队列”中，着重介绍了以下内容： 1. **栈（Stack）**：栈是一种特殊类型的线性表，只允许在一端进行插入和删除操作，遵循“后进先出”（LIFO）原则。课程中通过叠放盘子的例子帮助理解其概念，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值