C语言 数据结构 循环队列的表示和实现

已于 2022-11-04 18:31:34 修改
阅读量1.9k 收藏 33
点赞数 5
分类专栏： 数据结构与算法 文章标签： 数据结构 c语言 队列
于 2022-01-12 21:40:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57345774/article/details/122463050
版权

数据结构课程设计专栏指路

数据结构课程设计（C语言版）
包括顺序表、链表、栈、循环队列、二叉树、图

定义顺序存储的循环队列存储结构
编写循环队列的各种基本操作实现函数

文章目录

队列是先进先出的结构
front指向队头，元素出队
rear指向队尾，元素入队

1 循环队列结构

typedef struct LoopQueue
{
    DataType data[MAXSIZE];
    int front; //队头索引，指向队列第一个数据所在位置
    int rear;  //队尾索引，指向队列最后一个数据后一个位置
} LoopQueue;

2 基本操作函数

  1. 初始化队列
    返回一个结构体指针，指向一个空的循环队列
LoopQueue *InitLQueue()
{
    LoopQueue *Q = (LoopQueue *)malloc(sizeof(LoopQueue));
    Q->front = Q->rear = 0;
    return Q;
}
  1. 计算队列长度
int LQueueGetLenth(LoopQueue *Q)
{
    return (Q->rear - Q->front + MAXSIZE) % MAXSIZE;
}
  1. 元素入队
  • 定义枚举类型bool，其中false=0,true=1。
typedef enum
{
    false,
    true
} bool;

bool LQueueInsert(LoopQueue *Q, DataType dt)
{
    //这里牺牲掉了一个储存位置，用rear+1来和队头索引相比较以判断是否为满，
    //是为了和队列判空条件相区分

    //判断队列是否 满，如果已满，返回false
    if ((Q->rear + 1) % MAXSIZE == Q->front)
        return false;

    Q->data[Q->rear] = dt;
    Q->rear = (Q->rear + 1) % MAXSIZE;
    return true;
}
  1. 元素出队，返回其值
DataType LQueueDelete(LoopQueue *Q)
{
    //判断队列是否为空,若空报错
    if (Q->rear == Q->front)
    {
        printf("列表为空\n");
        return 0;
    }

    DataType dt = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAXSIZE;
    return dt;
}
  1. 销毁队列
    销毁队列,也是由于该循环队列基于数组，不需要分配内存
    只需重置队头和队尾索引即可

int LQueueDestroy(LoopQueue *Q)
{
    Q->front = Q->rear = 0;
    return true;
}
  1. 打印队列
void LQueuePrint(LoopQueue *Q)
{
    if (Q->rear == Q->front)
        printf("队列为空\n");
    else
    {
        //只要队列不为空 ，就从队头开始打印
        int p = Q->front;
        printf("从队头开始:\t");
        while (p != Q->rear)
        {
            printf("%d\t", Q->data[p]);
            p = (p + 1) % MAXSIZE;
        }
        printf("\n");
    }
}
  1. 取队头元素
DataType LQueuePeek(LoopQueue *Q)
{
    if (Q->rear == Q->front)
        printf("队列为空\n");
    else
        return Q->data[Q->front];
    return 0;
}

3 整体代码

该程序分为两个文件，“LQueue.h"与"test4.c”
将数据结构类型定义（typedef）部分与基础操作函数放在头文件LQueue.h
主函数以及其他部分放在test4.c 中

test4.c

  • 为检验代码可行性，设计main()函数验证
  • 功能：
    • 可以选择元素入队，出队，销毁和打印
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


#define DataType int
#define MAXSIZE 100

#include "LQueue.h"


int main()
{    
    //测试部分
    LoopQueue *Q;

    Q = InitLQueue();
   
    //定义一个选择变量
    int choice;

    //插入元素
    DataType e;

    //出队返回值
    DataType back;
    do
    {
        printf("===========循环队列操作==========\n");
        printf("1.元素入队\n");
        printf("2.元素出队\n");
        printf("3.销毁队列\n");
        printf("4.打印队列\n");
        printf("0.退出\n");
        printf("=====================\n");
        printf("请输入您的选择：");
        scanf("%d", &choice);
        switch (choice)
        {
        case 1:
            
            printf("请输入循环队列元素（输入-1结束）:");
            scanf("%d", &e);
            while (e != -1)
            {
                LQueueInsert(Q, e);
                scanf("%d", &e);
            }
            break;
        case 2:

            back = LQueueDelete(Q);
            back ? printf("------------\n 元素: %d 出队，还剩%d个元素\n", back, LQueueGetLenth(Q)) : printf("------------\n队列为空，无法出队！\n");
            free(&back); //回收内存，防止内存泄露
            break;
        case 3:
            LQueueDestroy(Q) ? printf("------------\n队列销毁成功！\n") : printf("------------\n队列销毁失败！\n");
            break;
        case 4:
            LQueuePrint(Q);
            break;
        case 0:
            printf("\n-->> 退出\n");
            exit(0);
            break;
        default:
            break;
        }
    } while (choice);


    return 0;
}

LQueue.h




typedef enum
{
    false,
    true
} bool;

//循环队列结构
typedef struct LoopQueue
{
    DataType data[MAXSIZE];
    int front; //队头索引，指向队列第一个数据所在位置
    int rear;  //队尾索引，指向队列最后一个数据后一个位置
} LoopQueue;

LoopQueue *InitLQueue()
{
    LoopQueue *Q = (LoopQueue *)malloc(sizeof(LoopQueue));
    Q->front = Q->rear = 0;
    return Q;
}

//返回长度
int LQueueGetLenth(LoopQueue *Q)
{
    return (Q->rear - Q->front + MAXSIZE) % MAXSIZE;
}

//元素入队
bool LQueueInsert(LoopQueue *Q, DataType dt)
{
    //这里牺牲掉了一个储存位置，用rear+1来和队头索引相比较以判断是否为满，
    //是为了和队列判空条件相区分

    //判断队列是否 满，如果已满，返回false
    if ((Q->rear + 1) % MAXSIZE == Q->front)
        return false;

    Q->data[Q->rear] = dt;
    Q->rear = (Q->rear + 1) % MAXSIZE;
    return true;
}

//元素出队，返回其值
DataType LQueueDelete(LoopQueue *Q)
{
    //判断队列是否为空
    if (Q->rear == Q->front)
    {
        printf("列表为空\n");
        return 0;
    }
    DataType dt = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAXSIZE;
    return dt;
}

//销毁队列,也是由于该循环队列基于数组，不需要分配内存
//只需重置队头和队尾索引即可
int LQueueDestroy(LoopQueue *Q)
{
    Q->front = Q->rear = 0;
    return true;
}

//打印队列
void LQueuePrint(LoopQueue *Q)
{
    if (Q->rear == Q->front)
        printf("队列为空\n");
    else
    {
        //只要队列不为空 ，就从队头开始打印
        int p = Q->front;
        printf("从队头开始:\t");
        while (p != Q->rear)
        {
            printf("%d\t", Q->data[p]);
            p = (p + 1) % MAXSIZE;
        }
        printf("\n");
    }
}

//取队头元素
DataType LQueuePeek(LoopQueue *Q)
{
    if (Q->rear == Q->front)
        printf("队列为空\n");
    else
        return Q->data[Q->front];
    return 0;
}

4 运行结果

  • 示例：
    • 先入队，进行两次出队，打印队列
    • 再次入队一些元素，再打印队列
      在这里插入图片描述

在这里插入图片描述

5 附加题

  • 舞伴匹配问题

  • 编写程序，实现舞伴问题：假设在周末舞会上，男士们和女士们进入舞厅时，各自排成一队，跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴，若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。现要求设计一个函数void partner()，模拟上述舞伴配对问题。

  • 基本要求:

    1. 由键盘输入数据，每对数据包括姓名和性别；
    2. 输出结果包括配成舞伴的女士和男士的姓名，以及未配对者的队伍名称和队头者的姓名；
    3. 要求利用LQueue.h中已实现的顺序循环队列的基本操作函数来实现。函数void partner() 添加到文件test4.c中，在主函数中进行调用测试。

  • 步骤

    • 由于该问题存储的数据元素是字符串，所以需要改变，文件修改保存为LQueuePlus.h和test4Plus
    • 创建两个队列，分别储存男人和女人
    • 一个一个出队匹配，直到其中一个队列为0

LQueuePlus.h

typedef enum
{
    false,
    true
} bool;

//循环队列结构
typedef struct LoopQueue
{
    char data[MAXSIZE][5];
    int front; //队头索引，指向队列第一个数据所在位置
    int rear;  //队尾索引，指向队列最后一个数据后一个位置
} LoopQueue;

LoopQueue *InitLQueue()
{
    LoopQueue *Q = (LoopQueue *)malloc(sizeof(LoopQueue));
    Q->front = Q->rear = 0;
    return Q;
}

//返回长度
int LQueueGetLenth(LoopQueue *Q)
{
    return (Q->rear - Q->front + MAXSIZE) % MAXSIZE;
}

//插入元素
bool LQueueInsert(LoopQueue *Q, char *dt)
{
    //这里牺牲掉了一个储存位置，用rear+1来和队头索引相比较以判断是否为满，
    //是为了和队列判空条件相区分

    //判断队列是否 满，如果已满，返回false
    if ((Q->rear + 1) % MAXSIZE == Q->front)
        return false;

    strcpy(Q->data[Q->rear], dt);
    Q->rear = (Q->rear + 1) % MAXSIZE;
    return true;
}

//元素出队，返回其值
char *LQueueDelete(LoopQueue *Q)
{
    //判断队列是否为空
    if (Q->rear == Q->front)
        return NULL;

    char *dt = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAXSIZE;
    return dt;
}

//销毁队列,也是由于该循环队列基于数组，不需要分配内存
//只需重置队头和队尾索引即可
int LQueueDestroy(LoopQueue *Q)
{
    Q->front = Q->rear = 0;
    return true;
}

//打印队列
void LQueuePrint(LoopQueue *Q)
{
    if (Q->rear == Q->front)
        printf("队列为空\n");
    else
    {
        //只要队列不为空 ，就从队头开始打印
        int p = Q->front;
        printf("从队头开始:\t");
        while (p != Q->rear)
        {
            printf("%s\t", Q->data[p]);
            p = (p + 1) % MAXSIZE;
        }
        printf("\n");
    }
}

//取队头元素
char *LQueuePeek(LoopQueue *Q)
{
    if (Q->rear == Q->front)
        printf("队列为空\n");
    else
        return Q->data[Q->front];
    return 0;
}

test4Plus.h

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


#define MAXSIZE 100

#include "LQueuePlus.h"

bool partner()
{
    //创建两个队列，分别储存男女两队
    LoopQueue *M = InitLQueue();
    LoopQueue *F = InitLQueue();

    //传入人名
    char str1[5],str2[2];
    printf("请输入跳舞者的姓名和性别(男为M，女为F)（以“# #”结束）:\n");
    scanf("%s%s", str1, str2);
    getchar();
    while (strcmp(str1 ,"#") && strcmp(str2 ,"#"))
    {
        if (!strcmp(str2 ,"M"))
        {
            LQueueInsert(M, str1);
        } 
        else if(!strcmp(str2 ,"F"))
        {
            LQueueInsert(F, str1);
        }
        else
        {
            printf("输入不合法");
            return false;
        }

        //printf("请输入跳舞者的姓名和性别(男为M，女为F)（以“# #”结束）:");
        scanf("%s%s", str1, str2);   
        getchar();     
    }


    //配对
    int num, i;
    printf("配对的舞伴是：\n");
    num = LQueueGetLenth(M)<LQueueGetLenth(F)?LQueueGetLenth(M):LQueueGetLenth(F);
    for (i = 0; i < num; i++)
    {
        printf("%s %s" , LQueueDelete(M), LQueueDelete(F));   
        printf("\n");
    }


    //M剩余或F剩余或都不剩余
    if (LQueueGetLenth(M)) 
    {
        //还有男的
        printf("男队还有人等待下一轮舞曲。\n");
        printf("%s将是下一轮得到舞伴的第一人\n", LQueuePeek(M));
    }
    else if (LQueueGetLenth(F)) 
    {
        //还有女的
        printf("女队还有人等待下一轮舞曲。\n");
        printf("%s将是下一轮得到舞伴的第一人\n", LQueuePeek(F));
    }
    else
        printf("无人剩余，全部匹配成功！\n");
    
    return true;
}


int main()
{
    //舞伴问题
    partner();
    
    return 0;
}
  • 运行结果
    在这里插入图片描述
丸丸丸子w
关注
  • 5
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
实验二 堆栈和队列基本操作的编程实现
02-09
【实验目的】 堆栈和队列基本操作的编程实现 要求： 堆栈和队列基本操作的编程实现（2学时，验证型），掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现，存储结构可以在顺序结构或链接结构中任选，也可以全部实现。也鼓励学生利用基本操作进行一些应用的程序设计。 【实验性质】 验证性实验（学时数：2H） 【实验内容】 内容： 把堆栈和队列的顺序存储（环队）和链表存储的数据进队、出队等运算其中一部分进行程序实现。可以实验一的结果自己实现数据输入、数据显示的函数。 利用基本功能实现各类应用，如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。
详解循环队列（C语言版）
k2865155467的博客
10-28 662
C语言版的代码
数据结构：链式队列的基本操作及实现
m0_58311374的博客
05-05 981
一、队列的结构定义 #define MaxSize 200 #define ElemType int typedef struct { ElemType data[MaxSize]; int front, rear; }SqQueue, *PSqQueue; 二、基本操作的实现 //队列初始化 PSqQueue Init_Queue() { PSqQueue Q; Q = (PSqQueue)malloc(sizeof(SqQueue)); if (Q) { Q->front
循环队列及链队列的基本操作
qq_62949330的博客
05-07 2152
循环队列及链队列的基本操作
数据结构-循环队列详解（c语言版）
m0_55698213的博客
10-27 2173
本文主要介绍了循环队列的一些概念特点和C语言代码实现以及一些应用场景。
【数据结构】队列的实现及循环队列的实现详解（c语言）
m0_72532428的博客
03-25 2300
通过下图可以看到定义了两个结构体，第一个结构就是我们常用的节点，而第二结构体中的成员可以理解为head指针是用来指向队头的tail指针是用来指向队尾的size用来反应队列中的元素个数，看到这肯定会有一些疑问，为什么要这样定义呢，这样定义的好处是什么1.这样定义的好处上文我们说了实现队列要用尾插头删来实现当入队的时候尾插需要找到队列的尾，这样就需要把队列遍历一遍，此时入队列的时间复杂度为O（n）而我们使用tail指针指向尾，在尾插的时候就可以不用再遍历队列了，这时入队列的时。
循环队列的各种基本运算
热门推荐
Paradox
12-04 1万+
循环队列的各种基本运算 码文不易，如果帮助到您，希望您可以帮我刷一下点击量，与您无害，与我有益谢谢 支持原创 。   欢迎大家阅读我的博客，如果有错误请指正，有问题请提问，我会尽我全力改正错误回答问题。在次谢谢大家。下面开始正式内容      队列，又称为伫列（queue），是先进先出（FIFO, First-In-First-Out）的线性表。在具体应用中通常用链表或...
循环队列work
qq_36560939的博客
05-16 847
循环队列 //定义循环队列 typedef struct CircleIntQueue { int data[TOTAL_SPACE]; int head; int tail; } *CircleIntQueuePtr; /生成循环链表 CircleIntQueuePtr initQueue() { CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(struct CircleIntQueue)); resultPt
数据结构-循环队列（C语言描述）
weixin_44731936的博客
04-09 1302
前言 座右铭：talk is easy,show me the code. 我们生活在幸福的时代，我们都站在巨人的肩膀上看世界 队列队列队列的分类循环队列定义循环队列的结构体队列为空或者为满的情况用代码实现队列队列的初始化入队出队遍历队列结果演示结语 队列 我们可以把队列想象成一个排队的过程，先去排队的先服务，也即是“先进先出”。 队列的分类 1.链式队列 2.循环队列 也就是队列的实现可以用...
【C语言数据结构】循环队列
W1024201的博客
03-25 1808
目录 前言 一、循环队列 1.循环队列头文件及函数声明 2.初始化 3.入队 4.获取队头元素 5.出栈 6.清空与销毁 1.清空 2.销毁 8.循环队列源文件及整体函数实现 总结 前言 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 循环队列，实际本身是一个顺序表，但是因为顺序表进行删除非尾部...
详解数据结构C语言实现之循环队列
09-01
在我们生活中有很多队列的影子，可以说与时间相关的问题，一般都会涉及到队列问题；本文详细介绍了如何使用C语言实现循环队列，下面一起来看看。
数据结构循环队列的C语言实现
01-24
数据结构循环队列的C语言实现
C语言循环队列的表示与实现实例详解
09-04
主要介绍了C语言循环队列的表示与实现,对于数据结构与算法的研究很有帮助,需要的朋友可以参考下
【数据结构】二叉树（带图详解）
最新发布
Z1tai的博客
04-27 1547
链表和数组都是线性结构，而树是非线性的结构。树是依靠分支关系定义出的一种层次结构。社会亲缘关系和组织结构图都可以用树来形象地表示。
数据结构系列-二叉树之前序遍历
in_seattle的博客
04-26 509
这篇文章，我们主要的内容是对二叉树当中的前历的算法进行讲解，二叉树中的算法所要求实现的是 从根到左子树再到右子树的遍历顺序，可能这样不太好理解，我们拿一张图片进行解释，我们先来分析一下这个的实现逻辑是什么，按照根节点，左子树，右子树的顺序，我们先来判断一下这个应该实现的结果是什么。在这里，我们将空也表现了出来，那下面，我们就讲解一下怎么用代码实现这个过程。假设在这个二叉树当中，我们要实现二叉树遍历当中的前历，我们应该怎么做呢。这些代码我们在前面就详细的进行了展开，在这里我们就不进行详细的讲解。
【数据结构】第二章 线性数据结构.线性表.顺序表
KX_52517的博客
04-26 1350
线性数据结构章节
【数据结构】图（Graph）
2201_75475240的博客
04-24 1306
本文章介绍数据结构中的图的基本知识，包括概念、邻接表、邻接矩阵、深度遍历和广度遍历，且还包含408习题（附有解析）。此外，含有关于邻接表和两种遍历全部具体实现代码。
数据结构练习：链表扩容
2301_80369371的博客
04-25 342
一：创建一个新链表，遍历原链表的同时，将原链表的值复制给新链表。二：将新链表插入到原链表中（大致如下）3.*&是c++的写法，等同于c中的*2.记得malloc后要free。1.头结点是不存有数据的。
数据结构(八)——排序
señoritaw的博客
04-25 1232
排序(Sort)，就是重新排列表中的元素，使表少的元素满足按关键字有序的过程。输入∶n个记录R1,R2...., Rn，对应的关键字为k1, k2,... , kn输出:输入序列的一个重排R1',R2'....,Rn'，使得有k1'≤k2'≤...≤kn'(也可递减)算法的稳定性。若待排序表中有两个元素R,和R，其对应的关键字相同即key = keyj，且在排序前R;在R,的前面，若使用某一排序算法排序后，R仍然在R的前面，则称这个排序算法是稳定的，否则称排序算法是不稳定的。
循环队列实现杨辉三角C语言数据结构
06-10
以下是使用C语言实现循环队列生成杨辉三角的代码： ```c #include #include #define MAX_SIZE 100 // 定义循环队列 typedef struct { int front; // 队首指针 int rear; // 队尾指针 int items[MAX_SIZE]; /...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

丸丸丸子w

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

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

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

打赏作者

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

抵扣说明：

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

余额充值