C 数据结构 之 队列

最新推荐文章于 2023-04-21 06:00:00 发布
最新推荐文章于 2023-04-21 06:00:00 发布
阅读量302 收藏
点赞数
分类专栏： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guaiderzhu1314/article/details/104797509
版权

队列

1. 使用方法

  • 每次只能加入一个数字，每次只能拿出一个数字
  • 队列里的数字有前后顺序，先进的数字在前，后进的数字在后
  • 每次从队列里获得的数字一定是最先放进去的数字（先进先出）

2. 实现方法

typedef struct {
	int buf[size]; //存放数字的数组
	int head;      //第一个数字所在的下标（如果队列空则 head 应该等于 tail ）
	int tail;      //下一个数字应该在的下标
}queue;
  • 除了这个结构体，还需要为这个队列编写一组相关的关联函数
    • 队列的初始化函数 用来把一个没有使用过的队列设置成可使用的状态
      • void queue_init(queue *p_queue) {…}
    • 队列的清理函数 用来把一个使用过的队列里的所有数字删除
      • void queue_deinit(queue*p_queue){…}
    • 获得队列里的数字个数的函数
      • int queue_size(const queue *p_queue){…}
    • 判断队列是否是空的函数
      • int queue_empty(const queue *p_queue){…}
    • 判断队列是否满的函数
      • int queue_full(const queue *p_queue){…}
    • 向队列里加数字的函数(用整数类型返回值表示是否把数字加进了队列里)
      • int queue_push(queue *p_queue， int val){…}
    • 从队列里获得数字的函数（同时删除数字）
      • int queue_pop(queue *p_queue, int *p_val){…}
    • 从队列里获得数字的函数（不会删除数字）
      • int queue_top(const queue *p_queue, int *p_val){…}
/
//queue_1.h
#ifndef  __QUEUE_1_H__
#define  __QUEUE_1_H__

typedef struct {
    int buf[SIZE];  //记录队列里的数字
    int head;       //记录第一个数字所在存储区的下标
    int tail;       //记录下一个数字应该放置的下标
}queue;

//队列初始化函数
void queue_init(queue * p_queue);

//队列的清理函数
void queue_deinit(queue *p_queue);

//获得队列里数字个数的函数
int queue_size(const queue *p_queue);

//判断队列是否为空的函数
int queue_empty(const queue *p_queue);

//判断队列是否满的函数
int queue_full(const queue *p_queue);

//向队列里加入数字的函数 
int queue_push(queue *p_queue, int val);

//从队列获得数字的函数（同时删除数字）
int queue_pop(queue *p_queue, int *p_val);

//从队列获得数字的函数（同时删除数字）
int queue_front(const queue *p_queue, int *p_val);

#endif  //QUEUE_1_H__

/
//queue_1.c
#include "queue_1.h"

//队列初始化函数
void queue_init(queue * p_queue) {
    p_queue->tail = 0;  //在队列没有数字的时候，下一个数字应该放在下标为0的存储区里
    p_queue->head = 0;  //head 等于 tail表示队列里没有数字
}

//队列的清理函数
void queue_deinit(queue *p_queue) {
    p_queue->tail = 0;  //在队列没有数字的时候，下一个数字应该放在下标为0的存储区里
    p_queue->head = 0;  //head 等于 tail表示队列里没有数字
}

//获得队列里数字个数的函数
int queue_size(const queue *p_queue) {
    //当tail和head相等时返回0
    //每当队里里多一个数，tail 会加1,相减结果就会加1
    //每当队列里少一个数，head 会加1，相减结果就会减1 
    return p_queue->tail - p_queue->head;
}

//判断队列是否为空的函数
int queue_empty(const queue *p_queue) {
    return p_queue->head == p_queue->tail;
}

//判断队列是否满的函数
int queue_full(const queue *p_queue) {
    //队列也有两种实现方法，一种是从前向后使用这些存储区
    //换句话说，只要队列最后一个存储区被填上了数字，那么就可以认为这个队列已经满了
    //虽然队列先进先出的定义下，当最后一个存储区被填上数字之后，前面下标为为0的存储区
    //的数可能已经被拿走了，这个时候下标为0的存储区是可以继续用来填数字的
    //但现在实现的这个版本，可以认为，当最后一个存储区被填上数字就可以认为这个存储区已经满了 
    return p_queue->tail >= SIZE;
}

//向队列里加入数字的函数 
int queue_push(queue *p_queue, int val) {
    if (p_queue->tail >= SIZE) {
        //队列已经满了
        return 0; 
    }
    p_queue->buf[p_queue->tail] = val; //把新数组记录到数组里以 tail 做下标的存储区里
    p_queue->tail++;                   //把tail向后移动一步
    return 1;
}

//从队列获得数字的函数（同时删除数字）
int queue_pop(queue *p_queue, int *p_val) {
    if (p_queue->tail == p_queue->head) {
        //如果队列是空的
        return 0;
    }
    *p_val = p_queue->buf[p_queue->head]; //把数组里以head做下标的的存储区的数字传递给调用函数
    p_queue->head++;                      //把head向后移动一步，表示删除这个数字
    return 1;
}

//从队列获得数字的函数（不删除数字）
int queue_front(const queue *p_queue, int *p_val) {
    if (p_queue->tail == p_queue->head) {
        return 0;
    }
    *p_val = p_queue->buf[p_queue->head];
    return 1;
}

/
//queue_main.c
#include <stdio.h>
//如果一个源文件里使用了某个头文件里声明的函数，那这个头文件也是这个源文件的必要头文件
#include "queue_1.h"
int main() {
    //声明一个结构体变量代表一个队列,然后对队列做初始化,最后做清理
    //使用数据结构的基本代码框架
    queue que = {0};
    int val = 0;

    queue_init(&que);
    printf("数字个数是%d\n", queue_size(&que));
    printf("队列是否空%d\n", queue_empty(&que));
    printf("队列是否满%d\n", queue_full(&que));

    queue_push(&que, 10);
    queue_push(&que, 20);
    queue_push(&que, 30);
    printf("数字个数是%d\n", queue_size(&que));
    printf("队列是否空%d\n", queue_empty(&que));
    printf("队列是否满%d\n", queue_full(&que));

    queue_front(&que, &val);
    printf("最前面的数字是%d\n", val);

    queue_pop(&que, &val);
    printf("最前面的数字是%d\n", val);
    queue_pop(&que, &val);
    printf("最前面的数字是%d\n", val);

    //这个时候第一个和第二个存储区数字已经被删了
    //但是当 SIZE 下标存储区被填满()过（tail就等于了SIZE），（这个版本）依然认为队列满了
    //所以最后即使队列里的数字被删完了，依然显示队列是满的
    queue_push(&que, 40);
    queue_push(&que, 50);
    printf("数字个数是%d\n", queue_size(&que));
    printf("队列是否空%d\n", queue_empty(&que));
    printf("队列是否满%d\n", queue_full(&que));

    while(1) {
        if(!queue_pop(&que, &val))
        {
            break;
        }
        printf("%d\n", val);
    }

    printf("数字个数是%d\n", queue_size(&que));
    printf("队列是否空%d\n", queue_empty(&que));
    printf("队列是否满%d\n", queue_full(&que));
    
    queue_deinit(&que);

    return 0;
}

/*
gcc -DSIZE=5 queue_1.c queue_main.c
output:
数字个数是0
队列是否空1
队列是否满0
数字个数是3
队列是否空0
队列是否满0
最前面的数字是10
最前面的数字是10
最前面的数字是20
数字个数是3
队列是否空0
队列是否满1
30
40
50
数字个数是0
队列是否空1
队列是否满1
*/
  • 回想一下刚刚讲过的队列，是从前向后使用存储区，当最后一个存储区使用完以后，就不能在往里加入数字了。如果能重复利用已经被拿走数字的存储区，40 和 50 其实是可以放进去的。所以就有了循环队列。

循环队列

当数组里最后一个存储区也被放上数字以后可以把后边的数字放在 下标为0的存储区里（这个存储区里必须没有有效数字）

1. 实现方法

typedef struct{
int buf[SIZE]; //记录数字的数组
int qty; //队列里的数字个数
int tail; //下一个数字所在的下标
} queue;

loop_queue_1.h

// 前后加上预处理指令
#ifndef     __LOOP_QUEUE_1_H__
#define     __LOOP_QUEUE_1_H__


// qty 可能大于也可能小于 tail
// 当tail 因为大于等于 size 被置为0时
typedef struct{
    int buf[SIZE]; //记录数字的数组
    int qty; //队列里的实际数字个数
    int tail; //下一个数字所在的下标
} queue;

// 删除函数内容和形参名称

// get_head 函数只是在队列里面使用
// 我们不希望队列以外的函数来使用get_head 函数
// 所以 get_head 函数的生命不应该出现在头文件里
// 获得最前面数字所在下标的函数
// int get_head(const queue *);

// 队列的初始化函数
void queue_init(queue *);

// 队列清理函数
void queue_deinit(queue *);

//获得队列里数字个数的函数
int queue_size(const queue *);

// 判断队列是否空的函数
int queue_empty(const queue *);

// 判断队列是否满的函数
int queue_full(const queue *);

// 向队列里加入数字的函数
int queue_push(queue *, int);

// 从队列里获得数字的函数（同时删除数字）
int queue_pop(queue *, int *);

// 从队列里获得数字（不会删除数字）
int queue_front(const queue *, int *);

#endif      __LOOP_QUEUE_1_H__

loop_queue_1.c

#include "loop_queue_1.h"

// 获得最前面数字所在下标的函数
int get_head(const queue *p_queue) {
    int ret = p_queue->tail - p_queue->qty;
    // 当tail被置0以后（由于queue_pop函数，tail比qty先到SIZE）， 就会出现ret<0的情况
    // 并且这种情况出现以后，ret<0 将一直保持下去，因为每次queue_push 都会给 tail和qty都加一
    if (ret < 0) {
        ret += SIZE;
    }
    return ret;
}

// 队列的初始化函数
void queue_init(queue *p_queue) {
    p_queue->tail = 0;
    p_queue->qty = 0; //代表队列里没有数字
}

// 队列清理函数
void queue_deinit(queue *p_queue) {
    p_queue->tail = 0;
    p_queue->qty = 0;
}

// 获得队列里数字个数的函数
int queue_size(const queue *p_queue){
    // qty 成员变量当做返回值传递给调用函数
    return p_queue->qty;
}

// 判断队列是否空的函数
int queue_empty(const queue *p_queue) {
    return !p_queue->qty;
}

// 判断队列是否满的函数
int queue_full(const queue *p_queue) {
    return p_queue->qty >= SIZE;
}

// 向队列里加入数字的函数
int queue_push(queue *p_queue, int val) {
    if (p_queue->qty >= SIZE){
        //队列满了
        return 0;
    }
    p_queue->buf[p_queue->tail] = val;
    p_queue->tail++;
    p_queue->qty++;
    // tail 一直加可能会超过存储区范围（当qty因为queue_pop没有超过SIZE，但tail超过SIZE后）
    // 当tail = size ,把tail 置为0，就可以绕着圈的填数字了
    if (p_queue->tail >= SIZE) {
        p_queue->tail = 0;
    }

    // 这两每次一起加，对get_head的结果不会有任何改变
    return 1;
}

// 从队列里获得数字的函数（同时删除数字）
int queue_pop(queue *p_queue, int *p_val) {
    if (!p_queue->qty) {
        // 队列是空的
        return 0;
    }
    // 使用get_head 函数得到第一个数字所在的下标，把这个存储区里的数字传递给调用函数
    *p_val = p_queue->buf[get_head(p_queue)]; 
    // 把qty 减一 就相当于删除了这个数字
    p_queue->qty--;
    // 然后 get_head 的结果就会加一
    return 1;
}

// 从队列里获得数字（不会删除数字）
int queue_front(const queue *p_queue, int *p_val) {
    if (!p_queue->qty) {
        return 0;
    }
    *p_val = p_queue->buf[get_head(p_queue)];
}

loop_queue_main.c

#include <stdio.h>
//如果一个源文件里使用了某个头文件里声明的函数，那这个头文件也是这个源文件的必要头文件
#include "loop_queue_1.h"
int main() {
    //声明一个结构体变量代表一个队列,然后对队列做初始化,最后做清理
    //使用数据结构的基本代码框架
    queue que = {0};
    int val = 0;

    queue_init(&que);
    printf("数字个数是%d\n", queue_size(&que));
    printf("队列是否空%d\n", queue_empty(&que));
    printf("队列是否满%d\n", queue_full(&que));

    queue_push(&que, 10);
    queue_push(&que, 20);
    queue_push(&que, 30);
    printf("数字个数是%d\n", queue_size(&que));
    printf("队列是否空%d\n", queue_empty(&que));
    printf("队列是否满%d\n", queue_full(&que));

    queue_front(&que, &val);
    printf("最前面的数字是%d\n", val);

    queue_pop(&que, &val);
    printf("最前面的数字是%d\n", val);
    queue_pop(&que, &val);
    printf("最前面的数字是%d\n", val);


    queue_push(&que, 40);
    queue_push(&que, 50);
    printf("数字个数是%d\n", queue_size(&que));
    printf("队列是否空%d\n", queue_empty(&que));
    // 上一个版本这里的判满结果是真(size = 5)，因为已经把最后存储区用了
    // 这个结果判满的结果是假，因为前面那个 10和20 的存储区已经空出来了
    printf("队列是否满%d\n", queue_full(&que));

    while(1) {
        if(!queue_pop(&que, &val))
        {
            break;
        }
        printf("%d\n", val);
    }

    printf("数字个数是%d\n", queue_size(&que));
    printf("队列是否空%d\n", queue_empty(&que));
    printf("队列是否满%d\n", queue_full(&que));
    
    queue_deinit(&que);

    return 0;
}

/*
gcc -DSIZE=5 loop_queue_1.c loop_queue_main.c
output:
数字个数是0
队列是否空1
队列是否满0
数字个数是3
队列是否空0
队列是否满0
最前面的数字是10
最前面的数字是10
最前面的数字是20
数字个数是3
队列是否空0
队列是否满0 ****这里和之前有不同,上个版本这里是1****
30
40
50
数字个数是0
队列是否空1
队列是否满0
*/
半只因
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言数据结构链表队列的实现
12-31
C语言数据结构链表队列的实现 1.写在前面 　队列是一种和栈相反的，遵循先进先出原则的线性表。 　本代码是严蔚敏教授的数据结构书上面的伪代码的C语言实现代码。 　分解代码没有包含在内的代码如下： #include #...
数据结构—循环队列（C语言）
chenshengnanii的博客
05-16 2121
一、头文件 二、循环结点 三、初始化 四、插入 五、删除 六、打印 七、测试代码 八、主函数 九、全部代码 十、测试结果 十一、总结 一、头文件 #include <stdio.h> #include <malloc.h> #define MAXSIZE 5 二、循环结点 typedef struct CircleIntQueue { int data[MAXSIZE]; int head; int tail; }*CircleIntQueue
数据结构—链队列
夏日漱石的博客
04-14 860
链队列
数据结构-循环队列的基本操作函数实现（含全部代码）
热门推荐
关注网络安全、云原生安全
09-17 1万+
主要包含以下函数： InitQueue(SqQueue &Q) 参数：循环队列Q 功能：初始化循环队列Q 时间复杂度：O(1) QueueEmpty(SqQueue Q) 参数：循环队列Q 功能：判断队空与否 时间复杂度：O(1) EnQueue(SqQueue &Q,QElemType e)...
数据结构——链表
rocky_56X的博客
02-03 357
头文件 1 #ifndef _LINKLIST_H_ 2 #define _LINKLIST_H_ 3 4 #define SUCCESS 100 5 #define FAILURE 101 6 7 typedef int DataType; 8 9 struct node 10 { 11 Data
数据结构队列的基本操作（C语言）
多低调的博客
09-18 3833
队列（Queue）是另一种限定性的线性表，它只允许在表的一端插入元素，而在另一端删除元素，所以队列具有先进先出（Fist In Fist Out，缩写为FIFO)的特性。这与我们日常生活中的排队是一致的，最早进入队列的人最早离开，新来的人总是加入到队尾。在队列中，允许插入的一端叫做队尾(rear)，允许删除的一端则称为队头(front)。 本次只写了顺序队列和链队的基本操作，以及一个利用队来实现的将随机数奇偶分配输出的程序，不太严谨，尚待改进，可供参考 这次并不是写在一个源文件里的，而是分了...
c语言数据结构的队列实现
07-02
c语言数据结构的队列实现，新建队列，入队列，出队列，删除队列
数据结构 队列 插入元素 C语言
最新发布
08-27
数据结构 队列 插入元素 C语言
数据结构 队列 删除元素 C语言
08-27
数据结构 队列 删除元素 C语言
数据结构——队列 求队列长度 C语言
03-16
输入若干个整数, 以0结束, 利用入队的操作生成一个循环队列, 求该队列的长度。
（七）循环队列的基本函数实现
qq_52608074的博客
08-17 807
1.队列 队列：一种先进先出的线性表，为什么是先进先出呢？因为它删除元素是在队头，而插入元素是在队尾，就像这样： 我们每插入一个数据，队尾指针就向后移一位，每删除一个数据队尾指针就向前移动一位，如我们删除一个数据就得到下图： 得到： 但是这样我们会发现这样每次删除数据的时间复杂度就是O(n),那么有没有什么好的方法让它变得更快一点呢？ 这就出现了循环队列： 2.循环队列 循环队列不一样的地方就在于： 删除元素时不移动队尾指针，而是将队头指针向后移一位，这样大大提高了时间复杂度。 防止删除元素后前面空
（七）链式队列的初始化、入队列和出队列
Frank Kong的博客
09-25 6603
链式队列需要有队头指针和队尾指针才能唯一确定一个队列，头指针一般指向头结点，尾指针指向最后一个元素结点。空的队列就是队头指针和队尾指针都指向了头结点。在可以确地长度最大值时采用循环队列，无法估计长度的时候用链式队列。 结构定义 typedef int QElemType; typedef struct QNode{ QElemType data; struct QNode *n
用栈实现队列、用队列实现栈
qq_45841224的博客
12-08 182
1、用栈实现队列：栈是先进后出，队列是先进先出 定义两个栈 把第一个栈的输出 输入到第二个栈里面就可以 再让第二个栈进行输出就可以 main方法 Stack stack=new Stack(); Stack stack1=new Stack(); for(int i=0;i<10;i++) { stack.set(i); } stack.putf(); for(int i=0;i<10;i++) { int a=st...
基础数据结构：循环队列
weixin_58368590的博客
02-21 279
先写头文件list.h #pragma once #define MAX_SIZE 100 //循环队列结构体设计： typedef int ELEM_TYPE; typedef struct Queue { ELEM_TYPE *base; //这个指针用来接收malloc从堆里申请的数组 int front;//队头指针（实际上保存的是数组下标，int） int rear;//队尾指针 （实际上保存的是数组下标，int） }Queue, *PQueue; //增删改查 //初始化 ...
c语言数据结构的主函数怎么写,数据结构算法前面的头文件该如何写?主函数该如何写?...
weixin_39618456的博客
05-20 2129
一、头文件头文件一般包含类、子程序、变量和其他标识符的前置声明。需要在一个以上源文件中被声明的标识符可以被放在一个头文件中，并在需要的地方包含这个头文件。头文件用于让编译器持有正确的标识符词典。头文件不正确的时候，最常出现的错误是“标识符未定义”(identifier undefined)。要修正这些问题，事实上应该去查询你所使用的标识符(函数、变量等)的文档。以VC为代表的Windows系列的I...
数据机构 C语言实现队列（含代码详解 易懂）
识海拾贝的博客
10-12 9672
/* 数学模型参照《大话数据结构》队列部分   !!!取余运算实现队列循环!!! */ #include #include #include #include #define OK 1  #define ERROR 0 #define TURE 1 #define FALSE 0 #define MAXSIZE 20 /* 队列最大的成员个数 即数组的长度 */
[数据结构]：06-队列（链表带头结点）（C语言实现）
Chandni_小月月
02-26 585
此专栏包含408考研数据结构全部内容，除其中使用到C++引用外，全为C语言代码。使用C++引用主要是为了简化指针的使用，避免二重指针的出现。
JAVA算法中各类数据结构的初始化及常用函数（自用）
程序员小祝的博客
12-30 1800
java算法题中常见数据结构的初始化以及常用函数。
FreeRTOS 队列（一）
Bit_Dong的博客
04-21 1249
队列是为了任务与任务、任务与中断之间的通信而准备的，可以在任务与任务、任务与中断之间传递消息，队列中可以存储有限的、大小固定的数据项目。任务与任务、任务与中断之间要交流的数据保存在队列中，叫做队列项目。队列所能保存的最大数据项目数量叫做队列的长度，创建队列的时候会指定数据项目的大小和队列的长度。由于队列用来传递消息的，所以也称为消息队列。FreeRTOS 中的信号量的也是依据队列实现的！所以有必要深入的了解FreeRTOS 的队列。
数据结构 队列遍历输出元素代码
04-14
以下是队列遍历输出元素的代码： ```python # 定义队列 queue = [] # 向队列中添加元素 queue.append(1) queue.append(2) queue.append(3) queue.append(4) queue.append(5) # 遍历队列并输出元素 while queue: print(queue.pop(0)) ``` 这段代码将输出以下内容： ``` 1 2 3 4 5 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值