数据结构 队列（C语言）

最新推荐文章于 2023-04-16 13:21:19 发布
最新推荐文章于 2023-04-16 13:21:19 发布
阅读量565 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 队列 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46499906/article/details/106109610
版权

数据结构 队列

一、队列
1.队列是一种操作受限制的线性表，具有两个特殊的属性。第一，新项只能添加到表的末尾（称为入队）。第二，只能从表的开头移除项（称为出队）。因此队列是一种“先进先出”的数据形式。

二、链队列
1.因为入队和出队操作分别在链表的两端进行，所以使用两个指针分别指向链表的首元结点（若有头结点，则指向头结点）和链表的尾结点。指向链表的首元结点（或头结点）的指针为front，指向链表的尾结点的指针为rear。
在这里插入图片描述

带头结点的链队列
在这里插入图片描述
不带头结点的链队列

2.链队列的存储结构定义：

#define SIZE 20
typedef struct people{
        int num;          //序号
        char name[SIZE];  //姓名
}Item;
typedef struct node{
        Item item;           //数据域
        struct node * next;  //指针域，指向链表中的下一个结构
}Node;    //队列的结点类型名为Node
typedef struct queue{
        Node * front;   //指向队头结点的指针
        Node * rear;    //指向队尾结点的指针
}Queue;  //链队列类型名为Queue

该定义中通过typedef为某一类型自定义名称。用Item作为struct people的别名（这样做更加通用），如果以后需要其他数据形式的队列，可以重新定义Item类型。用Node作为struct node的别名，队列的结点类型名是Node。用Queue作为struct queue的别名，链队列类型名为Queue。若有Queue Q;则表示创建了一个队列。从逻辑上说，链队列是元素结点构成的，而从数据类型的角度，链队列实际上是两个指针的组合。

3.链队列的初始化：
链队列初始化为空，队头指针与队尾指针指向头结点。

void InitQueue(Queue * Q)  //形参：指向Queue类型的指针
{
     Q->front=Q->rear=(Node *)malloc(sizeof(Node));  //建立头结点，并将其地址赋给队头指针、队尾指针
     Q->front->next=NULL;                            //头结点的指针域设置为NULL
}
带头结点的链队列初始化 
void InitQueue(Queue * Q)  //形参：指向Queue类型的指针
{
     Q->front=NULL;        //队头指针指向NULL
     Q->rear=NULL;         //队尾指针指向NULL
}
不带头结点的链队列初始化

带头结点的链队列初始化前/后：（初始化后队列为空）
在这里插入图片描述

4.链队列的入队操作：

bool EnQueue(Queue * Q,Item item)  //形参：1.指向Queue类型的指针  2.Item类型的变量item，用于为新结点的数据域赋值
{
     Node * temp;  //指向Node类型的指针temp
     temp=(Node *)malloc(sizeof(Node));  //申请一个结点的空间，并将其地址赋给结构指针temp
     if(temp==NULL)  //若申请结点不成功，则返回false
        return false;
     Copy(item,temp);     //Copy()用于处理数据域，可以根据程序自定义处理数据域的方式
     temp->next=NULL;     //新结点的next指针指向NULL
     Q->rear->next=temp;  //队尾结点的指针域指向新结点
     Q->rear=temp;        //队列的尾指针指向新结点
     return true;      
}

在这里插入图片描述

5.链队列的出队操作：

bool DeQueue(Queue * Q,Item * item)  //形参:1.指向Queue类型的指针 2.指向Item类型的指针，带出出队结点的数据域
{
     Node * temp;  //指向Node类型的指针temp
     if(Q->front==Q->rear)  //若队列为空，则返回false
        return false;       
     temp=Q->front->next;   //指针temp指向首元结点
     Q->front->next=temp->next;  //将首元结点的指针域赋给头结点
     if(Q->rear==temp)    //若队中只有一个结点，则出队后队列为空
        Q->rear=Q->front; //修改队尾指针，指向头结点
     *item=temp->item;    //将出队结点的数据域通过Item类型的指针带出
     free(temp);          //释放出队结点的空间
     return true;         
}

在这里插入图片描述

6.链队列的队长：

int QueueItemCount(const Queue * Q)  //形参:指向Queue类型的指针，由于该函数不修改队列，使用const修饰符对指针所指向的内容进行保护
{
    int count=0;  //定义计数器count
    Node * temp;  //指向Node类型的指针temp
    temp=Q->front->next;  //指针temp指向首元结点
    while(temp!=NULL)     //遍历队列，每经过一个结点计数器递增
    {
         count++;
         temp=temp->next;
    }
    return count;  //返回队列长度
}

7.清空链队列：

void EmptyTheQueue(Queue * Q)  //形参:指向Queue类型的指针
{
     Item item;    //Item类型的变量item
     Node * temp;  //指向Node类型的指针temp
     temp=Q->front->next;  //指针temp指向首元结点
     while(temp!=NULL)  //遍历队列，每经过一个结点调用一次出队算法
     {
          temp=temp->next;   //先将指针temp指向下一结点
          DeQueue(Q,&item);  //调用出队算法
     }
}

注意：在调用出队算法前，需要将指针temp指向下一结点。若调用出队算法后，再修改指针temp则会导致程序出错。例如第一次循环，指针temp指向首元结点，若先调用出队算法，首元结点删除，指针temp的指向无法确定。

8.输出链队列：

void output(const Queue * Q)  //形参:指向Queue类型的指针，由于该函数不修改队列，使用const修饰符对指针所指向的内容进行保护
{
     Node * temp;  //指向Node类型的指针temp
     temp=Q->front->next;  //指针temp指向首元结点
     while(temp!=NULL)     //遍历队列
     {
         printf("序号: %d,姓名: %s\n",temp->item.num,temp->item.name);  //输出形式由数据域的类型决定
         temp=temp->next;
     }
}

9.链队列样例：

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

#define SIZE 20

typedef struct people{
        int num;          //序号
        char name[SIZE];  //姓名
}Item;
typedef struct node{
        Item item;           //数据域
        struct node * next;  //指针域，指向链表中的下一个结构
}Node;
typedef struct queue{
        Node * front;
        Node * rear;
}Queue;

void InitQueue(Queue * Q);
void output(const Queue * Q);
void Copy(Item item,Node * pnode);
bool EnQueue(Queue * Q,Item item);
bool DeQueue(Queue * Q,Item * item);
void EmptyTheQueue(Queue * Q);
int QueueItemCount(const Queue * Q);

int main()
{
    Queue Q;
    Item temp;
    Item item;
    int i;
    int count=1;
    int number;

    InitQueue(&Q);
    printf("请输入入队人姓名:");
    while(scanf("%s",temp.name)&&temp.name[0]!='#')
    {
        temp.num=count++;
        EnQueue(&Q,temp);
        printf("请输入入队人姓名:");
    }
    printf("队列为:\n");
    output(&Q);
    number=QueueItemCount(&Q);
    printf("队列的大小为:%d",number);
    printf("\n连续出队3人:\n");
    for(i=0;i<3;i++)
    {
        DeQueue(&Q,&item);
        printf("序号: %d,姓名: %s\n",item.num,item.name);
    }
    printf("现队列为:\n");
    output(&Q);
    printf("现队列的大小为:%d",QueueItemCount(&Q));
    printf("\n清空队列\n");
    EmptyTheQueue(&Q);
    printf("\nBye!");

    return 0;
}

void InitQueue(Queue * Q)
{
     Q->front=Q->rear=(Node *)malloc(sizeof(Node));
     Q->front->next=NULL;
}

bool EnQueue(Queue * Q,Item item)
{
     Node * temp;
     temp=(Node *)malloc(sizeof(Node));
     if(temp==NULL)
        return false;
     Copy(item,temp);
     temp->next=NULL;
     Q->rear->next=temp;
     Q->rear=temp;
     return true;
}

bool DeQueue(Queue * Q,Item * item)
{
     Node * temp;
     if(Q->front==Q->rear)
        return false;
     temp=Q->front->next;
     Q->front->next=temp->next;
     if(Q->rear==temp)
        Q->rear=Q->front;
     *item=temp->item;
     free(temp);
     return true;
}

void Copy(Item item,Node * pnode)
{
     pnode->item=item;
}

void output(const Queue * Q)
{
     Node * temp;
     temp=Q->front->next;
     while(temp!=NULL)
     {
         printf("序号: %d,姓名: %s\n",temp->item.num,temp->item.name);
         temp=temp->next;
     }
}

int QueueItemCount(const Queue * Q)
{
    int count_=0;
    Node * temp;
    temp=Q->front->next;
    while(temp!=NULL)
    {
         count_++;
         temp=temp->next;
    }
    return count_;
}

void EmptyTheQueue(Queue * Q)
{
     Item item;
     Node * temp;
     temp=Q->front->next;
     while(temp!=NULL)
     {
          temp=temp->next;
          DeQueue(Q,&item);
     }
}

输出结果：
在这里插入图片描述
三、循环队列
1.顺序队列：
在这里插入图片描述
由于队列的项只能添加到表的末尾，并且只能从表的开头移除项。所以得到了以上顺序队列队头指针front和队尾指针rear的移动情况。空队列时两者都指向下标为0的位置。当a、b、c入队时，指针front仍指向队头下标为0的位置，而指针rear则指向下标为3的位置。当a、b出队时，指针front指向下标为2的位置，而指针rear仍指向下标为3的位置。当d、e入队时，指针front仍指向下标为2的位置，但是指针rear的指向却出现了问题，越出了数组的边界，其指向无法确知。但是在下标0和1的位置上，有着闲置的空间，指针rear却无法指向他们，这种现象被称为假溢出。因此为了解决这个问题，引入了循环队列。（队头指针与队尾指针实际上是一种标记，标记队首元素与队尾元素，并非语言指针。）

2.循环队列：
为了解决假溢出，我们使队列形成环形，即在逻辑上将数组的首尾相连形成环。这样，当到达数组末尾时，若首元素空出，就可以把新添加的项储存到这些空出的元素中。
在这里插入图片描述
图中空队列时队头指针和队尾指针都指向下标为0的位置，因此这种情况下也出现了一个问题，当队列满时，队头指针和队尾指针也都指向下标为0的位置。也就是说，当队头指针和队尾指针都指向下标为0的位置时，我们无法区分该队列是满状态还是空状态。为了能正确判断循环队列的空和满，可以用以下两种方法解决：①：仅使用n-1个数组空间。②：使用额外标记，如SIZE来记录使用元素的个数。当SIZE为0时表示队空。当SIZE为数组大小时表示队满。

3.循环队列的存储结构定义：

#define SIZE 20
#define MAXSIZE 7  //仅使用n-1个数组空间，即队列大小最大为6

typedef struct people{
        int num;          //序号
        char name[SIZE];  //姓名
}Item;
typedef struct node{
        Item item[MAXSIZE];  //数据域占用的数组空间
        int front;           //头指针指示器,指向队首元素
        int rear;            //尾指针指示器,指向队尾元素
}Queue;

4.循环队列初始化：
循环队列初始化为空，将队头指针与队尾指针都指向下标为0的位置。

void InitQueue(Queue * Q)  //形参：指向Queue类型的指针
{
     Q->front=0;  //队头指针指向下标为0的位置
     Q->rear=0;   //队尾指针指向下标为0的位置
}

在这里插入图片描述

5.循环队列判空与判满：
对于仅使用n-1个数组空间的情况，循环队列判断空与满，主要看front指针与rear指针的相对位置。当front指针与rear指针的相对位置为0时（即两者指向同一位置），循环队列就为空。那么如何来判断满呢？我们使用取余的方法。对n取余其结果只能在【0,n-1】的范围里。当队尾指针指向的下标+1对数组大小取余与队头指针指向的下标相同，循环队列就为满。例如，数组大小为7，仅使用n-1个数组空间(有效空间为6,下标0~5)，此时front指针指向下标为0的位置，rear指针指向下标为6的位置。（6+1）%7=0，与front指针指向的位置相同，队列为满。
①判断循环队列为空：

bool QueueIsEmpty(const Queue * Q)  //形参:指向Queue类型的指针，由于该函数不修改队列，使用const修饰符对指针所指向的内容进行保护
{
     if(Q->front==Q->rear)//若队头指针与队尾指针都指向相同的位置，则队列为空返回true，否则返回false
        return true;
     else
        return false;
}

②判断循环队列为满：

bool QueueIsFull(const Queue * Q)  //形参:指向Queue类型的指针，由于该函数不修改队列，使用const修饰符对指针所指向的内容进行保护
{
     if((Q->rear+1)%MAXSIZE==Q->front)  //若队尾指针指向的下标+1对数组大小取余与队头指针指向的下标相同，则队列为满返回true，否则返回false
        return true;
     else
        return false;

}

在这里插入图片描述

循环队列满时数组情况(仅使用n-1个数组空间)

6.循环队列的入队操作：

bool EnQueue(Queue * Q,Item item)  //形参：1.指向Queue类型的指针  2.Item类型的变量item，用于为结点的数据域赋值
{
     if(QueueIsFull(Q)==true)  //判满，若队列为满，则返回false
        return false;
     Q->item[Q->rear]=item;        //为结点的数据域赋值
     Q->rear=(Q->rear+1)%MAXSIZE;  //队尾指针后移
     return true;
}

7.循环队列的出队操作：

bool DeQueue(Queue * Q,Item * item)  //形参:1.指向Queue类型的指针 2.指向Item类型的指针，带出出队结点的数据域
{
     if(QueueIsEmpty(Q)==true)  //判空，若队列为空，则返回false
        return false;
     *item=Q->item[Q->front];       //带出出队结点的数据域
     Q->front=(Q->front+1)%MAXSIZE; //队头指针后移
     return true;
}

在这里插入图片描述

8.输出循环队列：
注意：输出时需要用额外的变量将循环队列的front指针与rear指针记录下来，若直接使用，则可能造成front指针与rear指针的指向改变，若再使用错误的指向去做其他事情就会发生错误。

void output(const Queue * Q)  //形参:指向Queue类型的指针，由于该函数不修改队列，使用const修饰符对指针所指向的内容进行保护
{
     int front,rear;  //定义两个整形变量，用于记录front指针与rear指针的指向
     front=Q->front;
     rear=Q->rear;
     while(front<rear)
     {
         printf("序号: %d,姓名: %s\n",Q->item[front].num,Q->item[front].name);  //输出形式由数据域的类型决定
         front++;
     }
}

9.循环队列样例：

#include<stdio.h>
#include<stdbool.h>

#define SIZE 20
#define MAXSIZE 7

typedef struct people{
        int num;          //序号
        char name[SIZE];  //姓名
}Item;
typedef struct node{
        Item item[MAXSIZE];  //数据域
        int front;        //头指针指示器,指向队首元素
        int rear;         //尾指针指示器,指向队尾元素
}Queue;

void InitQueue(Queue * Q);
void output(const Queue * Q);
bool EnQueue(Queue * Q,Item item);
bool QueueIsFull(const Queue * Q);
bool QueueIsEmpty(const Queue * Q);
bool DeQueue(Queue * Q,Item * item);

int main()
{
    Queue Q;
    Item item;
    Item item_;
    int i;
    int number=1;

    InitQueue(&Q);
    if(QueueIsEmpty(&Q)==true)
        printf("现在队列为空!\n");
    while(1)
    {
        printf("请输入入队人姓名:");
        scanf("%s",item.name);
        item.num=number++;
        EnQueue(&Q,item);
        if(QueueIsFull(&Q)==true)
        {
            printf("队列大小为: %d,队列已满!\n",MAXSIZE-1);
            break;
        }
    }
    printf("队列为:\n");
    output(&Q);
    printf("连续出队3人:\n");
    for(i=1;i<=3;i++)
    {
        DeQueue(&Q,&item_);
        printf("序号: %d,姓名: %s\n",item_.num,item_.name);
    }
    printf("现队列为:\n");
    output(&Q);
    printf("\nBye!");

    return 0;
}

void InitQueue(Queue * Q)
{
     Q->front=0;
     Q->rear=0;
}

bool QueueIsEmpty(const Queue * Q)
{
     if(Q->front==Q->rear)
        return true;
     else
        return false;
}

bool QueueIsFull(const Queue * Q)
{
     if((Q->rear+1)%MAXSIZE==Q->front)
        return true;
     else
        return false;

}

bool EnQueue(Queue * Q,Item item)
{
     if(QueueIsFull(Q)==true)
        return false;
     Q->item[Q->rear]=item;
     Q->rear=(Q->rear+1)%MAXSIZE;
     return true;
}

bool DeQueue(Queue * Q,Item * item)
{
     if(QueueIsEmpty(Q)==true)
        return false;
     *item=Q->item[Q->front];
     Q->front=(Q->front+1)%MAXSIZE;
     return true;
}

void output(const Queue * Q)
{
     int front,rear;
     front=Q->front;
     rear=Q->rear;
     while(front<rear)
     {
         printf("序号: %d,姓名: %s\n",Q->item[front].num,Q->item[front].name);
         front++;
     }
}

输出结果：
在这里插入图片描述

No Pain No Gain-
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
新手一看就懂——指针知识点总结
weixin_43635473的博客
09-13 1058
新手一看就懂——指针知识总结与练习题
C语言数据结构005——队列
weixin_45084986的博客
06-28 5833
一、队列的基本概念 (1)定义:只能在表的一端进行插入操作，在表的另一端进行删除操作的线性表。 (2)特点：先进先出 示意图如下： 二、顺序存储结构的队列 有6个存储空间的顺序队列动态示意图 顺序队列的“假溢出”问题 ①假溢出 顺序队列因多次入队列和出队列操作后出现的虽有存储空间但不能进行入队列操作的情况。 ②如何解决顺序队列的假溢出问题？ 可采取四种方法： 1)采用循环队列； 2)按最大可能的进队操作次数设置顺序队列的最大元素个数； 3)修改出队算法，使每次出队列后都把队列中剩余数据元素向队头方向移动
数据结构——队列（C语言实现）
sinzz的博客
04-16 2977
首先，我们需要定义的是链式结构的队列，即单链表为底层实现的。所以需要定义单链表结构来存储数据。然后，定义队列，队列里需要定义两个指向单链表的指针，一个是指向单链表头结点的指针，另一个则用来保存尾结点地址的指针。最后，还需定义一个记录当前队列元素个数的变量，用于遍历队列和判空。int size;} Queue;
数据结构（C语言版）之队列
m0_57859086的博客
11-14 5131
前言 ●数据结构作为计算机专业基础课，综合性强，抽象性高，在一定程度上增加了学习难度，本次我们共同从数据结构的基础探讨，由浅入深进行数据结构的学习。 ●本文只浅显的探讨了队列的基本知识，作者相信随着学习课程的深入，我们将会对数据结构有更深的理解与收获！ ●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！ ———————————————— ...
队列——数据结构严蔚敏C语言版
zt的博客
03-28 1327
文章目录队列的定义环形队列循环队列的基本操作链队链队的基本操作 队列的定义 队列(Queue):先进先出的线性表 队列是仅在队尾进行插入和队头进行删除操作的线性表 队头(front)：线性表的表头端,即可删除端 队尾(rear)：线性表的表尾端,即可插入端 由于这种队列存在假溢出现象,所以引入了循环链表解决假溢出想象 什么是假溢出可参考这篇文章 环形队列 区别环形队列是满队还是空队的两种方式 另设一个标志以区别队列是满队还是空队 少用一个元素空间 队空的条件：Q.front == Q.rear
数据结构队列用C语言描述.rar
08-07
总之，"数据结构队列用C语言描述"这个项目提供了一个学习和实践数据结构的好机会，不仅能够巩固C语言基础，还能深入理解数据结构的原理和应用。通过实际操作和调试代码，可以提升编程技能，为未来的IT职业生涯打下...
数据结构 队列 插入元素 C语言
08-27
数据结构 队列 插入元素 C语言
数据结构 队列 删除元素 C语言
08-27
数据结构 队列 删除元素 C语言
c语言数据结构的队列实现
07-02
c语言数据结构的队列实现，新建队列，入队列，出队列，删除队列
C语言数据结构链表队列的实现
12-31
C语言数据结构链表队列的实现 1.写在前面 　队列是一种和栈相反的，遵循先进先出原则的线性表。 　本代码是严蔚敏教授的数据结构书上面的伪代码的C语言实现代码。 　分解代码没有包含在内的代码如下： #include #...
循环队列的一些问题总结，入队、出队操作
热门推荐
BUstar_wzq的博客
02-02 1万+
在复习数据结构——队列这一节时遇到了一些问题，现总结如下，以便以后查阅： 1.在队列的顺序存储方式里，为了避免存储空间的“假溢出”，充分利用存储空间，我们用了一种实现方式，即循环队列。 (1).图中有两个指针(只是两个整型变量，因为在这里有指示作用，所以理解为指针) front、rear，一个指示队头，一个指示队尾（这里注意：rear定义为指向队尾元素还是队尾元素的下一个空间）。 (2).rea...
队列数据结构c语言_C语言：数据结构-队列的定义及基本运算
weixin_30621659的博客
01-27 1462
队列也是一种运算受限的线性表，请结合实例理解栈的定义和特点，学习时注意与线性表和栈的相关内容进行对比学习，掌握队列的“先进先出”的特点。1.队列的定义队列(Queue)也是一种运算受限的线性表。它只允许在表的一端进行插入，而在另一端进行删除。允许删除的一端称为队头(Front)，允许插入的一端称为队尾(Rear)。不含元素的队列称为空队列。如果元素按照a1，a2，a3，…，an的顺序入队，则a1为...
数据结构（C语言实现）之队列（链队）
亲，如果文章对你有帮助的话请点个关注吧！
04-23 1734
链队是一个简单的链表，只是运算受限，先进先出直接上代码#include "stdio.h" #include&lt;stdlib.h&gt; #define ERROR 0 #define OK 1 typedef int Status; typedef int QElemType; typedef struct QNode { QElemType data; struct QNode...
利用C++创建带头结点单链表，并实现插入、删除、遍历、清空、退出等功能
qq_44757691的博客
11-16 2604
利用C++创建带头结点单链表，并实现插入、删除、遍历、清空、退出等功能
queue的实现 数据结构
jgl841001的专栏
11-07 851
一、队列是什么     队列是一种可以实现“先进先出”的存储结构。其实，说简单点，队列就是排队，跟我们日常生活中到银行取钱排队，排队打饭在道理上是一样的。     队列通常可以分为两种类型：        ①链式队列（由链表实现）。        ②静态队列（由数组实现），静态队列通常都必须是循环队列。     由于链式队列跟链表差不多，所以在这里只针对循环队列来说明并实践。
队列的基本操作（数据结构C语言版）
luo_si_yuan的博客
11-15 3670
 队列的基本操作我使用的是链式结构的方式来实现 关于队列: 1.队列的特性特点:队列是一种“先进先出”缩写为FIFO的线性表。它只允许在表的一端进行插入，而在另一端“删除”元素。 2.队列的两端分别叫做:队头、队尾。队尾：允许插入数据的一端。队头：允许“删除”数据的一端。 链队列： 1.在链队列中 它的队头就是头结点（表头），而队尾无需固定（插入时确定）。 2.链队列创建之初需要确定两...
数据结构严蔚敏 队列基本操作 C语言实现
欢乐佛的博客
03-10 4175
【数据结构严蔚敏】 第三章 队列基本操作C语言 队列基本操作与栈类似，区别是删除元素时根据先进先出原则（FIFO），下面给出链队列的基本操作。 代码部分 1.基本结构定义 typedef int QElemType; //元素类型 typedef int Status; typedef struct QNode { QElemType data; struct QNode *next; }...
数据结构之队列(C语言)
quIDhaonan的博客
09-04 142
队列是一个非常经典的数据结构，是一种线性连续的存储方式，与它相类似的数据结构还有堆栈，线性表，数组这些数据结构，剩下的数据结构我会在后面的文章中一一介绍到。 那我们先来介绍一下队列中数据结构的特点：FIFO-先入先出 何为先入先出呢？就是最先入队列（存储在队列中）的元素最先出去，我们可以用一个图来说明： 因为队列是用来实现某些存储功能的我们当然要设计一些对队列操作方式： 首先是对队列的初始化： 我们首先应该知道一个队列应该有啥东西就可以方便我们操作队列，第一个就是数据的存储空间，在一个就是队列可以存储数据
数据机构 C语言实现队列（含代码详解 易懂）
识海拾贝的博客
10-12 9691
/* 数学模型参照《大话数据结构》队列部分   !!!取余运算实现队列循环!!! */ #include #include #include #include #define OK 1  #define ERROR 0 #define TURE 1 #define FALSE 0 #define MAXSIZE 20 /* 队列最大的成员个数 即数组的长度 */
 数据结构栈和队列c语言
最新发布
10-19
栈和队列是两种常见的数据结构，它们都可以用来存储一系列的数据，并且具有不同的特点和应用场景。 栈是一种后进先出（Last In First Out，LIFO）的数据结构，类似于一个＊＊＊、表达式求值、括号匹配等。 队列是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值