队列

最新推荐文章于 2020-07-31 23:10:44 发布
最新推荐文章于 2020-07-31 23:10:44 发布
阅读量527 收藏
点赞数
文章标签： c语言基础 数据结构 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39482521/article/details/76796006
版权
定义
队列是只允许在一端删除，在另一端插入的线性表
允许删除的一端叫做队头(front)，允许插入的一端叫做队尾(rear)。

特性

先进先出(FIFO, First In First Out)


顺序队列

error.h

#ifndef __ERROR_H__
#define __ERROR_H__

#include <stdio.h>
#define ERROR         -1
#define FULL_STACK    -2
#define EMPTY_STACK   -3
#define MALLOC_ERROR  -4

#define FULL_QUEUE    -5
#define EMPTY_QUEUE   -6

int errno;     // 错误号

void myError(char *str);

char* myStrError(int num);


#endif // __ERROR_H__


error.c

#include "error.h"

void myError(char *str)
{
	char *msg = myStrError(errno);
	printf ("%s: %s\n", str, msg);
/*	
	switch (errno)
	{
		case ERROR:
			printf ("%s: 输入参数错误\n", str);
			break;
		case FULL_STACK:
			printf ("%s: 满栈状态\n", str);
			break;
		case EMPTY_STACK:
			printf ("%s: 空栈状态\n", str);
			break;
		case MALLOC_ERROR:
			printf ("%s: 空间分配失败\n", str);
			break;
	}	
*/
}

char* myStrError(int num)
{
	switch (errno)
	{
		case ERROR:
			return "输入参数错误";
		case FULL_STACK:
			return "满栈状态";
		case EMPTY_STACK:
			return "空栈状态";
		case MALLOC_ERROR:
			return "空间分配失败";
		case FULL_QUEUE:
			return "队满状态";	
		case EMPTY_QUEUE:
			return "队空状态";
			
	}
}


SqQueue.h

#ifndef __SQQUEUE_H__
#define __SQQUEUE_H__
#include "error.h"

#define TRUE  1
#define FALSE 0

#define SIZE 10
typedef int QueueData;
typedef struct _queue
{
	QueueData data[SIZE];
	int front;     // 指向队头的下标
	int rear;      // 指向队尾的下标
}Queue;

// 置空队
int InitQueue (Queue *Q);  

// 判队空否
int QueueEmpty (Queue *Q);  

// 判队满否       
int QueueFull (Queue *Q);      

// 进队  
int EnQueue (Queue *Q, QueueData x);     

// 出队  
int DeQueue (Queue *Q, QueueData *x);

// 取队头
int GetFront (Queue *Q, QueueData *x);


#endif // __SQQUEUE_H__


SqQueue.c

#include "SqQueue.h"

int InitQueue (Queue *q)
{
	if (q == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	// 置空队
	q->front = 0;
	q->rear  = 0;
	
	return TRUE;
}

int QueueEmpty (Queue *q)
{
	if (q == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	return q->front == q->rear;
}


int QueueFull (Queue *q) 
{
	if (q == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	
	return q->front == (q->rear+1)%SIZE;
} 

int EnQueue (Queue *q, QueueData x)
{
	if (q == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	if (QueueFull(q))
	{
		errno = FULL_QUEUE;	
		return FALSE;
	}
	
	q->rear = (q->rear+1) % SIZE;
	q->data[q->rear] = x;
	
	return TRUE;
}

int DeQueue (Queue *q, QueueData *x)
{
	if (q == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	if (QueueEmpty(q))
	{
		errno = EMPTY_QUEUE;
		return FALSE;
	}
	q->front = (q->front + 1) % SIZE;
	*x = q->data[q->front];
	
	return TRUE;
}

int GetFront (Queue *q, QueueData *x)
{
	if (q == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	if (QueueEmpty(q))
	{
		errno = EMPTY_QUEUE;
		return FALSE;
	}
	int index = (q->front + 1) % SIZE;
	*x = q->data[index];
	
	return TRUE;
}


main.c

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


int main()
{
	Queue q;
	InitQueue(&q);
	
	if (QueueEmpty(&q))
	{
		printf ("空队\n");
	}
	
	int i;
	char str[50];
	for (i = 0; i < 10; i++)
	{
		if (EnQueue(&q, i) != TRUE)
		{
			sprintf (str, "第 %d 个元素入队失败", i);
			myError(str);
		}
	}
	
	int x;
	for (i = 0; i < 10; i++)
	{
		if (DeQueue(&q, &x) != TRUE)
		{
			sprintf (str, "第 %d 个元素出队失败", i);
			myError(str);
		}
		
		printf ("x = %d\n", x);
	}
	
	return 0;
}



链式队列

error.h

#ifndef __ERROR_H__
#define __ERROR_H__

#include <stdio.h>
#define ERROR         -1
#define FULL_STACK    -2
#define EMPTY_STACK   -3
#define MALLOC_ERROR  -4

#define FULL_QUEUE    -5
#define EMPTY_QUEUE   -6

int errno;     // 错误号

void myError(char *str);

char* myStrError(int num);


#endif // __ERROR_H__


error.c

#include "error.h"

void myError(char *str)
{
	char *msg = myStrError(errno);
	printf ("%s: %s\n", str, msg);
/*	
	switch (errno)
	{
		case ERROR:
			printf ("%s: 输入参数错误\n", str);
			break;
		case FULL_STACK:
			printf ("%s: 满栈状态\n", str);
			break;
		case EMPTY_STACK:
			printf ("%s: 空栈状态\n", str);
			break;
		case MALLOC_ERROR:
			printf ("%s: 空间分配失败\n", str);
			break;
	}	
*/
}

char* myStrError(int num)
{
	switch (errno)
	{
		case ERROR:
			return "输入参数错误";
		case FULL_STACK:
			return "满栈状态";
		case EMPTY_STACK:
			return "空栈状态";
		case MALLOC_ERROR:
			return "空间分配失败";
		case FULL_QUEUE:
			return "队满状态";	
		case EMPTY_QUEUE:
			return "队空状态";
			
	}
}


LinkQueue.h

#ifndef __LINKQUEUE_H__
#define __LINKQUEUE_H__
#include "error.h"

#define TRUE  1
#define FALSE 0

typedef int QueueData;
typedef struct _node
{
	QueueData data;
	struct _node *next;
}Node;

typedef struct _queue
{
	Node *front;
	Node *rear;
}Queue;

Queue* Create_Queue();

int QueueEmpty (Queue *Q);   

// 进队
int EnQueue (Queue *Q, QueueData x);   

// 出队
int DeQueue (Queue *Q, QueueData *x);

// 取队头
int GetFront (Queue *Q, QueueData *x);

int Destroy_Queue (Queue *Q);

#endif // __LINKQUEUE_H__


LinkQueue.c

#include "LinkQueue.h"
#include <stdlib.h>

Queue* Create_Queue()
{
	Queue * q = (Queue*)malloc(sizeof(Queue)/sizeof(char));
	if (q == NULL)
	{
		errno = MALLOC_ERROR;
		return NULL;
	}
	
	// 置空队
	q->front = NULL;
	q->rear  = NULL;
	
	return q;
}

int QueueEmpty (Queue *q)
{
	if (q == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	
	return q->front == NULL;
}

int EnQueue (Queue *q, QueueData x)
{
	if (q == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	Node * node = (Node*)malloc(sizeof(Node)/sizeof(char));
	if (node == NULL)
	{
		errno = MALLOC_ERROR;
		return FALSE;
	}
	node->data = x;
	node->next = NULL;
	
	if (q->front == NULL)
	{
		q->front = node;
		q->rear  = node;
	}
	else
	{
		q->rear->next = node;
		q->rear = node;
	}
	
	return TRUE;
}

int DeQueue (Queue *q, QueueData *x)
{
	if (q == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	if (QueueEmpty(q))
	{
		errno = EMPTY_QUEUE;
		return FALSE;
	}
		
	Node *p = q->front;
	*x = p->data;
	
	q->front = p->next;
	free(p);
	
	if (q->front == NULL)
		q->rear = NULL;
		
	return TRUE;
}

int GetFront (Queue *q, QueueData *x)
{
	if (q == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	if (QueueEmpty(q))
	{
		errno = EMPTY_QUEUE;
		return FALSE;
	}
		
	*x = q->front->data;
		
	return TRUE;
}

int Destroy_Queue (Queue *q)
{
	if (q == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	int x;
	while (QueueEmpty(q) != TRUE)
	{
		DeQueue(q, &x);
	}
	
	free(q);
	
	return TRUE;
}


main.c

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


int main()
{
	Queue* q = Create_Queue();
	
	int i;
	char str[50];
	for (i = 0; i < 10; i++)
	{
		if (EnQueue(q, i) != TRUE)
		{
			sprintf (str, "第 %d 个元素入队失败", i);
			myError(str);
		}
	}
	
	int x;
	for (i = 0; i < 10; i++)
	{
		if (DeQueue(q, &x) != TRUE)
		{
			sprintf (str, "第 %d 个元素出队失败", i);
			myError(str);
		}
		
		printf ("x = %d\n", x);
	}
	
	return 0;
}


小呀小三爷
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
嵌入式C语言入门——队列（链式队列）
qq_35599308的博客
12-11 359
数据结构之队列队列定义队列结构队列的初始化队列的进队判断队列是否为空队列的出队队头获取数据 队列 队列是只允许在一端删除，在另一端插入的顺序表 允许删除的一端叫队头(front)，允许插入的一端叫队尾(rear) 先进先出(FIFO) 定义队列结构 //定义链式结点 typedef struct _node { Data data; struct _node *next; }Node; ...
队列（一）
泪无痕的博客
05-22 1383
一、队列的定义        队列是另一种限制性线性表，它只允许在表的一端插入元素，在表的另一端删除元素，所以队列具有先进先出的特性。        在队列中，允许插入的一端称为队尾，允许删除的一端称为队头。        假设队列为q = （a1,a2,a3. . .an）,则a1就是队列的队头元素，an就是队列的队尾元素。        数据结构：                （1）Init...
队列问题
cay6995的博客
02-07 2971
1、什么叫队列？队头、队尾怎么区分? 队列(queue)是只允许在一端进行插入操作。而在另一端进行删除操作的线性表。 允许插入的一端称为队尾，允许删除的一端称为队头。   2、队列有哪些基本操作？     3、链式队列入队操作，就是在链表尾部插入结点，代码如何实现？     4、链式队列出队操作，就是头结点的后继结点出队，将头结点的后继改为它后面的结点，
高效延时队列的设计与实现
09-02
【高效延时队列的设计与实现】 延时队列是一种特殊的消息队列，它具有延时功能，使得消息在生产者发布后不会立即被消费，而是会在预设的延时时间过后才被处理。这种机制在很多业务场景中非常有用，如订单处理、定时...
C#消息队列发送及接收
03-25
在IT行业中，消息队列（Message Queue，MQ）是一种常用于分布式系统中解耦组件、提高系统可扩展性和可靠性的技术。在C#编程中，我们可以利用Microsoft Message Queuing（MSMQ）库来实现消息队列的发送和接收。本文将...
Python队列的定义与使用方法示例
09-21
Python中的队列是一种重要的数据结构，它遵循先进先出（FIFO）的原则，即最早进入队列的元素最早被移出。在实际编程中，队列常用于任务调度、多线程间的通信以及缓存管理等领域。Python标准库提供了`queue`模块，...
python队列queue模块详解
09-20
在Python中，`queue`模块提供了三种类型的队列：`Queue`（默认），`LifoQueue`（后进先出，类似栈），和`PriorityQueue`（优先级队列）。 首先，让我们详细了解一下`Queue`类的初始化函数`__init__(self, maxsize=0...
ios实现简易队列
08-25
在iOS开发中，队列是一种常用的数据结构，用于存储和管理数据。本篇主要探讨如何在iOS平台上实现一个简单的队列，通过Objective-C语言来创建一个名为`XMQueue`的类，以满足特定的队列操作需求。 首先，队列遵循先进...
C++队列用法实例
12-25
本文实例讲述了C++队列用法。分享给大家供大家参考。具体如下： /* 队列使用时必须包含头文件 #include <queue> 有以下几种方法 入队push(),出队pop(), 读取队首元素front(),读取队尾元素back() ， 判断队是否有...
c++循环队列
07-24
**C++循环队列详解** 循环队列是一种特殊类型的线性数据结构，它在物理存储上是连续的，但在逻辑上表现为一个环形结构。在循环队列中，队尾指针可以在达到数组长度后“回绕”到数组的开头，从而实现循环的效果。...
PHP队列原理及基于队列的写文件案例
12-20
在IT领域，队列是一种重要的数据结构，尤其在处理大量数据和并发操作时，队列的优势尤为明显。本文主要探讨了PHP中的队列原理，并提供了一个基于队列的写文件案例，帮助理解如何在实际项目中应用队列。 首先，队列...
java队列实现方法(顺序队列,链式队列,循环队列)
08-28
Java 队列实现方法 Java 队列是一种常用的数据结构，用于实现先进先出（FIFO）或后进先出（LIFO）的操作。Java 中提供了多种实现队列的方法，包括顺序队列、链式队列和循环队列等。下面我们将详细介绍每种队列的...
m数据结构 day6 队列：先进先出，只能在一端插入，而在另一端删除的线性表
wulimmya的博客
07-31 2422
文章目录
栈和队列：进队列操作详解
"进队列enQueue(q,e)-栈和队列.PPT" 栈和队列是数据结构中的两种基础但非常重要的线性数据结构。在计算机科学中，它们被广泛应用于各种算法和程序设计中。 栈（Stack）是一种后进先出（LIFO, Last In First Out）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值