C语言高级-5队列

最新推荐文章于 2024-04-21 09:15:42 发布
最新推荐文章于 2024-04-21 09:15:42 发布
阅读量509 收藏 1
点赞数 1
分类专栏： C数据结构 物联网 文章标签： c语言 开发语言 数据结构 球钟
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60718520/article/details/127589945
版权

14天阅读挑战赛

目录

一、队列的定义

二、双端队列

三、队列的应用场景

四、队列的实现

五、链式队列

六、队列的应用球钟问题

一、队列的定义

队列是限制在两端进行插入操作和删除操作的线性表
允许进行存入操作的一端称为“队尾”
允许进行删除操作的一端称为“队头”
当线性表中没有元素时，称为“空队”
特点 ：先进先出（FIFO）
有个浪费一个的思想，是浪费对头还是对尾，看情况，顺序队列浪费对尾、链式队列浪费对头

二、双端队列

双端队列（Deque）是指允许两端都可以进行入和出队操作的队列，deque 是 “double ended queue” 的简称。那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。

固定一端其实就能当栈来使用。

三、队列的应用场景

1、通讯应用，先进来的会先收到消息

 2、访问旅游城市规划。

B城市先访问，B城市的孩子城市也会先访问，这就是先进先出的思想。

四、队列的实现

front指向对头元素的位置。
rear指向对尾元素的下一个位置。
在队列操作过程中，为了提高效率，以调整指针代替队列元素的移动，并将数组作为循环队列的操作空间。
为区别空队和满队，满队元素个数比数组元素个数少一个。

1、队列结构和相应的头文件

sequeue.h

typedef int datatype;  
#define N 128           //队列容量

typedef struct {
	datatype data[N];   //用数组作为队列的存储空间
	int front;           //指示队头
	int rear;            //指示对尾
}sequeue;                

sequeue * queue_create();
int enqueue(sequeue *sq, datatype x);
datatype dequeue(sequeue *sq);
int queue_empty(sequeue *sq);
int queue_full(sequeue *sq); 
int queue_clear(sequeue *sq);
sequeue * queue_free(sequeue *sq);

2、创建队列

sequeue * queue_create() {
	sequeue *sq;

	if ((sq = (sequeue *)malloc(sizeof(sequeue))) == NULL) {
		printf("malloc failed\n");
		return NULL;
	}

	memset(sq->data, 0, sizeof(sq->data));
	sq->front = sq->rear = 0;
	return sq;
}

3、入队

int enqueue(sequeue *sq, datatype x) {
	if (sq == NULL) {
		printf("sq is NULL\n");
		return -1;
	}

	if ((sq->rear + 1) % N == sq->front) {
		printf("sequeue is full\n");
		return -1;
	}

	sq->data[sq->rear] = x;
	sq->rear = (sq->rear + 1) % N;

	return  0;
}

4、出队

datatype dequeue(sequeue *sq) {
	datatype ret;

	ret = sq->data[sq->front];

	sq->front = (sq->front + 1) % N;

	return ret;
}

5、判断队列是否满

int queue_full(sequeue *sq) {
	if (sq == NULL) {
		printf("sq is NULL\n");
		return -1;
	}

	if ((sq->rear + 1) % N == sq->front) {
		return 1;
	}
	else {
		return 0;
	}
}

6、判断队列空

int queue_empty(sequeue *sq) {
	if (sq == NULL) {
		printf("sq is NULL\n");
		return -1;
	}

	return (sq->front == sq->rear ? 1 : 0);
}

7、 清空队列

int queue_clear(sequeue *sq) {
	if (sq == NULL) {
		printf("sq is NULL\n");
		return -1;
	}

	sq->front = sq->rear = 0;

	return 0;
}

8、释放队列

sequeue * queue_free(sequeue *sq) {
	if (sq == NULL) {
		printf("sq is NULL\n");
		return NULL;
	}

	free(sq);
	sq = NULL;

	return NULL;
}

9、主函数main.c用于测试

#include <stdio.h>
#include "sequeue.h"

int main(int argc, const char *argv[])
{
	sequeue *sq;

	if ((sq = queue_create()) == NULL) {
		return -1;
	}
	
	enqueue(sq, 10);
	enqueue(sq, 100);
	enqueue(sq, 1000);

	while (!queue_empty(sq)) {
		printf("dequeue:%d\n", dequeue(sq));
	}

	queue_free(sq);

	return 0;
}

五、链式队列

插入操作在队尾进行，删除操作在队头进行，由队头指针和队尾指针控制队列的操作。

 

 linkstack.h文件

typedef int data_t;

typedef struct node {
	data_t data;
	struct node *next;
}listnode, *linkstack;

linkstack stack_create();
int stack_push(linkstack s, data_t value);
data_t stack_pop(linkstack s);
int stack_empty(linkstack s);
data_t stack_top(linkstack s);
linkstack stack_free(linkstack s);

linkstack.c文件

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

linkqueue * queue_create() {
	linkqueue *lq;

	if ((lq = (linkqueue *)malloc(sizeof(linkqueue))) == NULL) {
		printf("malloc linkqueue failed\n");
		return NULL;
	}

	lq->front = lq->rear = (linklist)malloc(sizeof(listnode));
	if (lq->front == NULL) {
		printf("malloc node failed\n");
		return NULL;
	}
	lq->front->data = 0;
	lq->front->next = NULL;

	return lq;
}

int enqueue(linkqueue *lq, datatype x) {
	linklist p;

	if (lq == NULL) {
		printf("lq is NULL\n");
		return -1;
	}

	if ((p = (linklist)malloc(sizeof(listnode))) == NULL) {
		printf("malloc node failed\n");
		return -1;
	}
	p->data = x;
	p->next = NULL;

	lq->rear->next = p;
	lq->rear = p;

	return 0;
}

datatype dequeue(linkqueue *lq) {
	linklist p;

	if (lq == NULL) {
		printf("lq is NULL\n");
		return -1;
	}

	p = lq->front;
	lq->front = p->next;
	free(p);
	p = NULL;

	return (lq->front->data);
}

int queue_empty(linkqueue *lq) {
	if (lq == NULL) {
		printf("lq is NULL\n");
		return -1;
	}

	return (lq->front == lq->rear ? 1 : 0);
}

int queue_clear(linkqueue *lq) {
	linklist p;

	if (lq == NULL) {
		printf("lq is NULL\n");
		return -1;
	}

	while (lq->front->next) {
		p = lq->front;
		lq->front = p->next;
		printf("clear free:%d\n", p->data);
		free(p);
		p = NULL;
	}
	return 0;
}

linkqueue * queue_free(linkqueue *lq) {
	linklist p;

	if (lq == NULL) {
		printf("lq is NULL\n");
		return NULL;
	}

	while (lq->front) {
		p = lq->front;
		lq->front = p->next;
		printf("free:%d\n", p->data);
		free(p);
	}

	free(lq);
	lq = NULL;

	return NULL;
}

main.c测试函数

#include <stdio.h>
#include "linkqueue.h"

int main(int argc, const char *argv[])
{
	linkqueue *lq;

	lq = queue_create();
	if (lq == NULL) 
		return -1;

	enqueue(lq, 10);
	enqueue(lq, 20);
	enqueue(lq, 30);
	enqueue(lq, 40);

	//while (!queue_empty(lq)) {
		//printf("dequeue:%d\n", dequeue(lq));
	//}
	queue_clear(lq);

	lq = queue_free(lq);
	enqueue(lq, 50);

	return 0;
}

六、队列的应用球钟问题

球钟是一个利用球的移动来记录时间的简单装置 它有三个可以容纳若干个球的指示器：分钟指示器，五分钟指示器，小时指示器 若分钟指示器中有2个球，五分钟指示器中有6个球，小时指示器中有5个球，则时间为5:32

每过一分钟，球钟就会从球队列的队首取出一个球放入分钟指示器，分钟指示器最多可容纳4个球。 当放入第五个球时，在分钟指示器的4个球就会按照他们被放入时的相反顺序加入球队列的队尾。而第五个球就会进入五分钟指示器。 按此类推，五分钟指示器最多可放11个球，小时指示器最多可放11个球。

当小时指示器放入第12个球时，原来的11个球按照他们被放入时的相反顺序加入球队列的队尾，然后第12个球也回到队尾。这时，三个指示器均为空，回到初始状态，从而形成一个循环。因此，该球钟表示时间的范围是从0：00到11：59。 现设初始时球队列的球数为27，球钟的三个指示器初态均为空。问，要经过多久，球队列才能回复到原来的顺序？

linkqueue.h

typedef int datatype;

typedef struct node {
	datatype data;
	struct node *next;
}listnode , *linklist;

typedef struct {
	linklist front;
	linklist rear;
}linkqueue;

linkqueue * queue_create();
int enqueue(linkqueue *lq, datatype x);
datatype dequeue(linkqueue *lq);
int queue_empty(linkqueue *lq);
int queue_clear(linkqueue *lq);
linkqueue * queue_free(linkqueue *lq);

linkqueue.c

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

linkqueue * queue_create() {
	linkqueue *lq;

	if ((lq = (linkqueue *)malloc(sizeof(linkqueue))) == NULL) {
		printf("malloc linkqueue failed\n");
		return NULL;
	}

	lq->front = lq->rear = (linklist)malloc(sizeof(listnode));
	if (lq->front == NULL) {
		printf("malloc node failed\n");
		return NULL;
	}
	lq->front->data = 0;
	lq->front->next = NULL;

	return lq;
}

int enqueue(linkqueue *lq, datatype x) {
	linklist p;

	if (lq == NULL) {
		printf("lq is NULL\n");
		return -1;
	}

	if ((p = (linklist)malloc(sizeof(listnode))) == NULL) {
		printf("malloc node failed\n");
		return -1;
	}
	p->data = x;
	p->next = NULL;

	lq->rear->next = p;
	lq->rear = p;

	return 0;
}

datatype dequeue(linkqueue *lq) {
	linklist p;

	if (lq == NULL) {
		printf("lq is NULL\n");
		return -1;
	}

	p = lq->front;
	lq->front = p->next;
	free(p);
	p = NULL;

	return (lq->front->data);
}

int queue_empty(linkqueue *lq) {
	if (lq == NULL) {
		printf("lq is NULL\n");
		return -1;
	}

	return (lq->front == lq->rear ? 1 : 0);
}

int queue_clear(linkqueue *lq) {
	linklist p;

	if (lq == NULL) {
		printf("lq is NULL\n");
		return -1;
	}

	while (lq->front->next) {
		p = lq->front;
		lq->front = p->next;
		printf("clear free:%d\n", p->data);
		free(p);
		p = NULL;
	}
	return 0;
}

linkqueue * queue_free(linkqueue *lq) {
	linklist p;

	if (lq == NULL) {
		printf("lq is NULL\n");
		return NULL;
	}

	while (lq->front) {
		p = lq->front;
		lq->front = p->next;
		printf("free:%d\n", p->data);
		free(p);
	}

	free(lq);
	lq = NULL;

	return NULL;
}

sqstack.h

typedef int data_t;

typedef struct {
	data_t *data;
	int maxlen;
	int top;
}sqstack;

sqstack * stack_create(int len);
int stack_push(sqstack * s, data_t value);
int stack_empty(sqstack *s);
int stack_full(sqstack *s);
data_t stack_pop(sqstack *s);
data_t stack_top(sqstack *s);
int stack_clear(sqstack *s);
int stack_free(sqstack *s);

sqstack.c

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

sqstack * stack_create(int len) {
	sqstack * s;

	if ((s =(sqstack *)malloc(sizeof(sqstack))) == NULL) {
		printf("malloc sqstack failed\n");
		return NULL;
	}

	if ((s->data = (data_t *)malloc(len * sizeof(data_t)))==NULL) {
		printf("malloc data failed\n");
		free(s);
		return NULL;
	}

	memset(s->data, 0, len*sizeof(data_t));
	s->maxlen = len;
	s->top = -1;

	return s;
}

int stack_push(sqstack * s, data_t value) {
	if (s == NULL) {
		printf("s is NULL\n");
		return -1;
	}

	if (s->top == s->maxlen-1) {
		printf("stack is full\n");
		return -1;
	}

	s->top++;
	s->data[s->top] = value;

	return 0;
}

/*
 *@ret 1-empty
 * */
int stack_empty(sqstack *s) {
	if (s == NULL) {
		printf("s is NULL\n");
		return -1;
	}
	return (s->top == -1 ? 1 : 0);
}

/*
 * @ret 1-full
 * */
int stack_full(sqstack *s) {
	if (s == NULL) {
		printf("s is NULL\n");
		return -1;
	}
	return  (s->top == s->maxlen-1 ? 1 : 0);
}

data_t stack_pop(sqstack *s) {
	s->top--;
	return (s->data[s->top+1]);
}

data_t stack_top(sqstack *s) {
	return (s->data[s->top]);
}

int stack_clear(sqstack *s) {
	if (s == NULL) {
		printf("s is NULL\n");
		return -1;
	}
	
	s->top = -1;
	return 0;
}

int stack_free(sqstack *s) {
	if (s == NULL) {
		printf("s is NULL\n");
		return -1;
	}
	
	if (s->data != NULL) 
		free(s->data);
	free(s);

	return 0;
}

test.c

#include <stdio.h>
#include "linkqueue.h"
#include "sqstack.h"

int check(linkqueue * lq);

int main(int argc, const char *argv[])
{
	linkqueue *lq;
	sqstack *s_hour, *s_five, *s_min;
	int value;
	int i, min = 0;

	if ((lq = queue_create()) == NULL) {
		return -1;
	}

	for (i = 1; i <= 27; i++) {
		enqueue(lq, i);
	}

	if ((s_hour = stack_create(11)) == NULL) {
		return -1;
	}

	if ((s_five = stack_create(11)) == NULL) {
		return -1;
	}

	if ((s_min = stack_create(4)) == NULL) {
		return -1;
	}

	while (1) {
		min++;
		if (!queue_empty(lq)) {
			value = dequeue(lq);
			if (!stack_full(s_min)) {
				stack_push(s_min, value);
			} else {
				while (!stack_empty(s_min)) {
					enqueue(lq, stack_pop(s_min));
				}
				if (!stack_full(s_five)) {
					stack_push(s_five, value);
				} else {
					while (!stack_empty(s_five)) {
						enqueue(lq, stack_pop(s_five));
					}
					if (!stack_full(s_hour)) {
						stack_push(s_hour, value);
					} else {
						while (!stack_empty(s_hour)) {
							enqueue(lq, stack_pop(s_hour));
						}
						enqueue(lq, value);
						//0:0
						if (check(lq) == 1) {
							break;
						}
					}
				}

			}
		}
	}
	printf("total:%d\n", min);

	printf("dequeue:");
	while (!queue_empty(lq)) 
		printf("%d ", dequeue(lq));
	
	puts("");

	return 0;
}

int check(linkqueue * lq) {
	linklist p;

	if (lq == NULL) {
		printf("lq is NULL\n");
		return -1;
	}

	p = lq->front->next;

	while (p && p->next) {
		if (p->data < p->next->data) {
			p = p->next;
		} else {
			return 0;
		}
	}
	return 1;
}

4IOT
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C语言 第五章进制
qq_43181253的博客
09-16 676
//一，十进制 1，0~9组成，逢十进一 //二，二进制 1，0，1组成，逢二进一 2，0b或0B开头，0b1010 3,1+1=0b10 4，二进制转十进制"乘以进制" 1，十进制：1230=01+310+2100+11000 2，二进制：0b1011=11+12+04+18 3,n位二进制最大值：ob111…111 转为十进制为：11+12+14+…+12…1*2^(n-1)=2n-1 //八...
【C语言5】数组
亿点点细节的博客
01-29 822
数组
Java Deque（双端队列）介绍与使用
一个有兴趣的程序员男孩
08-17 2266
Deque的介绍与使用
C语言应用1：队列
生活在别处u的博客
06-22 773
1.队列 队列是一种先进先出的线性表，每次操作只允许删除表的前端节点或者后端节点。 2.应用领域 2.1.AT指令： 使用2G/3G/4G模块时，定时向服务器传输数据时，可能会产生冲突。比如定时2s通过AT_CMD1发送温湿度数据，定时10s通过AT_CMD2发送电量数据。那么每过10s就可能出现AT指令冲突。使用队列可以规避这种冲突，每隔一段时间需要发送数据时的时候，将对应的AT传入队列中，由队列进行统一管理，并定时（这个时间可以短一些，决定精度）检测队列里是否有数据，有就上传服务器。如下图所示。 2.
数据结构——双端队列
最新发布
qq_67693066的博客
04-21 1074
数据结构——双端队列
Java双端队列Deque及其应用
Java硬件工程师的博客
02-15 1496
1.Deque的概念 双向队列：支持在首尾插入和删除元素的线性集合。它具有既具有FIFO(先进先出)特点又具有LIFO(后进先出)的特点，即是队列又是栈； java官方文档推荐用deque实现栈（stack）。 在Java中，Queue的实现类一般都是用LinkedList。 特点： 1.插入、删除、获取操作支持两种形式：快速失败和返回null或true/false 2.既具有FIFO特点又具有LIFO特点，即是队列又是栈 3.不推荐插入null元素，null作为特定返回值表示队列为空 4.未定义基于元
数据结构_队列_双端队列
weixin_37841366的博客
09-19 767
队列（Queue） 特点：和栈不同，队列的最大特点是先进先出（FIFO），就好像按顺序排队一样。对于队列的数据来说，我们只允许在队尾查看和添加数据，在队头查看和删除数据。 实现：可以借助双链表来实现队列。双链表的头指针允许在队头查看和删除数据，而双链表的尾指针允许我们在队尾查看和添加数据。 应用场景：直观来看，当我们需要按照一定的顺序来处理数据，而该数据的数据量在不断地变化的时候，则需要队列来帮助解题。在算法面试题当中，广度优先搜索（Breadth-First Search）是运用队列最多的地方，我们将
详解双端队列&单调队列
Forward♞的博客
08-10 887
typedef struct DequeNode //队列的节点//指向下一个//指向前一个int data;//数据域}DQNode;//队头指针//队尾指针}Deque;
C语言开发----c语言图书借阅系统源码.rar
04-10
- C语言是一种中级语言，它的语法简洁明了，既具有高级语言的抽象性，又具备低级语言的控制力。图书借阅系统的开发需要对C语言的基本语法，如变量、数据类型、控制结构（if-else、switch-case、for、while等）、...
C语言进阶－第2讲C语言复习共25页.pdf.zip
11-22
10. **高级数据结构**：链表、树、图、队列、栈等，它们的实现和应用。 11. **多线程编程**：使用`pthread`库进行并发编程，理解线程同步和互斥锁。 12. **位域**：在结构体中定义位字段，节省存储空间。 13. **...
c语言基础-c语言编程基础之链表操作示例-环形链表.zip
03-17
链表作为一种重要的数据结构，在计算机科学中有着广泛的应用，特别是在C语言编程中。本文将深入探讨C语言中的链表操作，特别是...学习并熟练运用这些知识，能提升你的C语言编程技能，为后续的高级编程打下坚实基础。
7、双端队列
qq_36697948的博客
01-19 2117
双端队列（Double-ended Queue，简称deque）是一种线性数据结构，它允许在两端进行插入和删除操作。这意味着与普通队列（FIFO，先进先出）或栈（LIFO，后进先出）不同，双端队列的使用者不仅可以从队列的一端（通常称为“尾”端）添加元素（enqueue），也可以从这一端删除元素（dequeue）。同时，双端队列还支持在另一端（通常称为“头”端）执行相同的操作，即在队列头部添加（enqueue at head）和删除（dequeue at head）元素。
双端队列及应用
MichaelAn的博客
02-13 181
双端队列及应用 什么是双端队列？ 双端队列是一种特殊的队列，首尾都可以添加或者删除元素，是一种加强版的队列。 JS 中的数组就是一种典型的双端队列。push、pop 方法分别从尾部添加和删除元素，unshift、shift 方法分别从首部添加和删除元素。 滑动窗口最大值 给定一个数组 nums，有一个大小为 k 的滑...
java 双端队列应用实例_数据结构（队列）的应用——Queue（队列）和Deque(双端队列)...
weixin_36057489的博客
02-24 579
一、队列的定义队列也是数据结构的其中一种，和栈相反的是。队列是只允许在一端进行插入，在另一端进行删除的线性表。插入的一端称为队尾，删除的一端称为队头。如下图：二、队列的顺序存储结构基于数组实现，底层结构使用顺序表进行存储数据。使用顺序表存储有个缺点：出队的时间复杂度高O(n); 容易形成假溢出。循环队列：把队列的头尾相接的并且使用顺序存储结构进行数据存储的队列称之为循环队列。三、队列的链式存储结构...
java数据结构之双端队列ArrayDeque
冰血ANG的博客
09-05 3064
java 自带双端队列ArrayDeque的源码解析
队列的应用场景和介绍
热门推荐
孔祥月的博客
07-09 1万+
队列的应用场景和介绍 特点：先进先出 英文：Queue 应用场景举例 银行排队：四个业务员，为排队的人的服务，每有一个业务员服务完成后，这时下一位被服务者从下面的队列中产生。 队列介绍 队列是一个有序列表，可以用数组和链表实现。数组顺序存储，链表链式存储。 遵循先入先出的原则，即先存入队列的数据，要先取出，后存入的要后取出。 用数组模拟示意图：rear代表尾部，f...
双端队列入门
liulangcheshou的博客
11-26 5789
最近学习到双端队列的时候，由于书上没有给出例子，所以一时不太能理解什么是双端队列 双端队列的定义：可以在两端做插入和删除操作的队列就叫做双端队列 那，看到这个定义，我就犯迷糊了，什么叫在两端插入和删除啊？ 刚开始我的疑惑是，如果给双端队列分配一个长度为10的数组，初始Front指针和Rear指针都指向0， 假设数组下标是左到右，0-10 初始化的时候，Front和

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

4IOT

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

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

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

打赏作者

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

抵扣说明：

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

余额充值