C语言之循环队列与队列的链式存储结构

最新推荐文章于 2024-07-26 18:54:25 发布
最新推荐文章于 2024-07-26 18:54:25 发布
阅读量1.6k 收藏
点赞数
分类专栏： C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjjontheway/article/details/104037260
版权

约定

循环队列满：

一般情况下，队列满和队列空的情况是：
font: 队列头指针
rear: 队列尾指针

Q->font=Q->rear

约定： 牺牲一个元素控件，约定以“队列头指针在队列尾指针的下一个位置（指环状的下一个位置）上”。
约定：在入队前，测试尾指针rear在循环意义下加1后等于头指针，则认为队满。即：

  • rear所指的单元始终为空
  • 循环队列为空：front=rear
  • 循环队列满：（rear+1）%MAX_QUEUE_SIZE = front.(对MAX_QUEUE_SIZE取余，比如6取余6就是0，就代表绕一圈后的数组索引)
  • 循环队列空：font = rear.

CircleQueue.h

#ifndef _CIRCLEQUEUE_H_
#define	_CIRCLEQUEUE_H_

#define OK 1
#define ERROR -1
#define MAX 100
typedef int QElementType;
typedef struct  
{
	QElementType *data;							//指向数据缓冲区
	int font;									//队列头
	int rear;									//队列尾
}SqQueue;

int CheckQueueFull(SqQueue *Q);					//判断队列是否为满
int CheckQueueEmpty(SqQueue *Q);				//判断队列是否为空
int InitQueue(SqQueue *Q);  					//队列初始化
int EnQueue(SqQueue *Q, QElementType e);		//数据入队
int DeQueue(SqQueue *Q, QElementType *e);		//数据出队
void PrintQuence(SqQueue  *Q);					//数据处理
void testCircleQueue(void);						//测试函数

#endif

Demo 1

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

//----------------------------------------------------------------------------------------------
//!brief Check Circle Queue is Full
//!
//!param 	Input  Circle Queue ptr
//!return  	1	   OK
//!			-1     Error    	
//----------------------------------------------------------------------------------------------
int CheckQueueFull(SqQueue *Q)
{
	if( (Q->rear+1)%MAX == Q->font)
	{
		return OK;
	}
	else
	{
		return ERROR;
	}
} 

//----------------------------------------------------------------------------------------------
//!brief Check Circle Queue is empty  
//!
//!param 	Input  Circle Queue ptr
//!return  	1	   OK
//!			-1     Error    	
//----------------------------------------------------------------------------------------------
int CheckQueueEmpty(SqQueue *Q)
{
	if(Q->font == Q->rear)
	{
		return OK;
	}
	else
	{
		return ERROR;
	}
} 


//----------------------------------------------------------------------------------------------
//!brief Initial Circle Queue  
//!
//!param 	Input  Circle Queue ptr
//!return  	1	   OK
//!			    	
//----------------------------------------------------------------------------------------------
int InitQueue(SqQueue *Q)
{
	Q->data = (QElementType *)malloc(MAX * sizeof(QElementType));   //分配缓冲区
	if (!Q->data)
	{
		exit(0);
	}
	Q->font = Q->rear = 0;											//队列头和队列尾初始化
	
	return OK;
}

//----------------------------------------------------------------------------------------------
//!brief Put a data into the Queue  
//!
//!param 	Input  Queue  ptr
//!param    Input  Data Element
//!
//!return  	1	   OK	    	
//----------------------------------------------------------------------------------------------
int EnQueue(SqQueue *Q, QElementType e)
{
	if(CheckQueueFull(Q))
	{
		return ERROR;
	}

	Q->data[Q->rear] = e;		   //数据入队
	Q->rear = (Q->rear + 1) % MAX; //重新设置队尾指针，即队尾指针增1
	return OK;
}

//----------------------------------------------------------------------------------------------
//!brief Extract a data out of the Queue  
//!
//!param 	Input  Queue  ptr
//!param    Input  Data Element ptr buffer
//!
//!return  	1	   OK	    	
//----------------------------------------------------------------------------------------------
int DeQueue(SqQueue *Q, QElementType *e)
{
	if (Q->font == Q->rear)					//判断队列是否为空
	{
		return ERROR; 					
	}
	*e = Q->data[Q->font];					//获取队首元素
	Q->font = (Q->font + 1) % MAX;			//头指针移动
	return OK;
}

//----------------------------------------------------------------------------------------------
//!brief Print out element data in the queue
//!
//!param 	Input  Queue  ptr
//!	
//----------------------------------------------------------------------------------------------
void PrintQuence(SqQueue *Q)
{
	int i;
	i = Q->font;
	while (i != Q->rear) 
	{
		printf("%d", Q->data[i]);
		i = (i + 1) % MAX;
	}
	printf("\n");
}

void testCircleQueue(void)
{
	SqQueue Q = {0};
	QElementType e=0;
	int i = 5,j = 5;
	InitQueue(&Q);
	for(i;i>0;i--)
	{
		EnQueue(&Q, i);
		printf("入队元素为%d\n", i);
	}
	PrintQuence(&Q);

	for(j;j>0;j--)
	{
		DeQueue(&Q, &e);
		printf("出队元素为%d\n",e);
	}

	return;
}

Demo 2

/*---------------------------------------
*CircleQueueSolution.h
*--------------------------------------*/
#ifndef _CIRCLEQUEUESOLUTION_H_
#define _CIRCLEQUEUESOLUTION_H_

#define ELEMENT_SIZE 40
#define MAX_ELEMENT_NUM 5
#define OK 1
#define ERROR -1

typedef struct MSG_TYPE 
{
	char msg[40];   //每个element的大小
}MSG_TYPE_ST;

typedef struct CIRCLEQUEUE
{
	int font;	//头部
	int rear;	//尾部
	MSG_TYPE_ST buffer[MAX_ELEMENT_NUM]; //缓存大小

}CIRCLEQUEUE_ST;

int CQ_InitQueue(CIRCLEQUEUE_ST *Q);  //初始化
int CQ_EnQueue(CIRCLEQUEUE_ST *CQ, void *element);
int CQ_DeQueue(CIRCLEQUEUE_ST *CQ, void* element);
void test_CircleQueueSolution(void);

#endif

/*---------------------------------------
*CircleQueueSolution.c
*--------------------------------------*/
#include "CircleQueueSolution.h"
#include "stdio.h"
#include "string.h"
#include "stdlib.h"

//circle queue object entity
static CIRCLEQUEUE_ST cq = { 0 }; 

//Test data source for test
static char *test_msg[] = {
	"This is element 1",
	"This is element 2",
	"This is element 3",
	"This is element 4",
	"This is element 5",
};

static int CQ_IsFull(CIRCLEQUEUE_ST *CQ);
static int CQ_IsEmpty(CIRCLEQUEUE_ST *CQ);
static void PrintfCircleQueue(CIRCLEQUEUE_ST *CQ);

/*--------------------------------------------------
* Check Circle Queue is Full
* return : 1--full
*          0--not full  
--------------------------------------------------*/
static int CQ_IsFull(CIRCLEQUEUE_ST *CQ)
{
	if ((CQ->rear+1)%MAX_ELEMENT_NUM == CQ->font)
	{
		printf("Circle is full\n");
		return 1;   
	}
	else
	{
		return 0;
	}

}

/*--------------------------------------------------
* Check Circle Queue is Empty
* return : 1--full
*          0--not full
--------------------------------------------------*/
static int CQ_IsEmpty(CIRCLEQUEUE_ST *CQ)
{
	if (CQ->rear == CQ->font)
	{
		printf("Circle queue is empty.\n");
		return 1;
	}
	else
	{
		return 0;
	}

}

int CQ_InitQueue(CIRCLEQUEUE_ST *CQ)
{
	CQ->font = CQ->rear = 0;
	return OK;
}


/*--------------------------------------------------
* Put Element in Circle Queue
* return : 1  --OK
*          -1 --ERROR
--------------------------------------------------*/
int CQ_EnQueue(CIRCLEQUEUE_ST *CQ, void *element)
{
	if(CQ_IsFull(CQ)||(strlen((char *)element)>ELEMENT_SIZE)) //如果压入元素长度大于element size也返回
	{
		return ERROR;
	}
	else
	{
		//拷贝到缓存中
		//memset(&CQ->buffer[CQ->rear],element, sizeof(element));
		strncpy_s(CQ->buffer[CQ->rear].msg, ELEMENT_SIZE, element, strlen(element));
		CQ->rear = (CQ->rear + 1) % MAX_ELEMENT_NUM;
		return OK;
	}
}

/*--------------------------------------------------
* Read Element from Circle Queue and store to element
* return : 1  --OK
*          -1 --ERROR
--------------------------------------------------*/
int CQ_DeQueue(CIRCLEQUEUE_ST *CQ, void* element)
{
	if (CQ_IsEmpty(CQ))
	{
		return ERROR;
	}
	else
	{
		//memcpy(element, &CQ->buffer[CQ->font], sizeof(MSG_TYPE_ST));
		strncpy_s((char *)element, ELEMENT_SIZE, CQ->buffer[CQ->font].msg, sizeof(CQ->buffer[CQ->font].msg));
		CQ->font = (CQ->font + 1) % MAX_ELEMENT_NUM;
		return OK;
	}
}

/*--------------------------------------------------
* Printf all Circle Queue element
* return : 1  --OK
*          -1 --ERROR
--------------------------------------------------*/
static void PrintfCircleQueue(CIRCLEQUEUE_ST *CQ)
{
	int i = CQ->font;
	
	while (i != CQ->rear )
	{
		printf("%s\n", CQ->buffer[i].msg);
		i = (i + 1) % MAX_ELEMENT_NUM;
	}
}

void test_CircleQueueSolution(void)
{
	char e[40] = {0};
	CQ_InitQueue(&cq);
	for (int i=0;i<5;i++)
	{
		CQ_EnQueue(&cq, test_msg[i]);
	}

	PrintfCircleQueue(&cq);
	
	for (int i=0;i<3;i++)
	{
		CQ_DeQueue(&cq, (char *)e);
		printf("%s\n", e);
		memset(e, 0, sizeof(e));

	}
	CQ_EnQueue(&cq, "this is new msg1");
	CQ_EnQueue(&cq, "this is new msg2");
	CQ_EnQueue(&cq, "this is new msg3");
}

链式存储结构及实现

上述循环队列在已知队列最大长度的情况下，可以使用循环队列，但是如果入队速度大于处理速度，可能会存在因为队列满而丢失数据的情况。
此时使用链式的队列存储能从空间上解决此问题，虽然在空间上增加了开销，需要一个指针域，但是还可以接收。因此相对固定长度的队列，更加灵活。

头文件

#ifndef _LINKQUEUE_H_
#define _LINKQUEUE_H_

#include "SingleLinkList.h"

//===============================================================================
//S E L F				D E F I N I T I O N
//===============================================================================
#define TRUE			1
#define FALSE           0

//===============================================================================
//S T R U C T			D E F I N I T I O N
//===============================================================================
typedef struct {

	Node  *front;	//指向队列首节点的头指针
	Node  *rear;	//指向队列尾节点的尾指针
}LinkQueue;

//===============================================================================
//F U N C T I O N			D E F I N I T I O N
//===============================================================================
//-------------------------------------------------------------------------------
//初始化
//-------------------------------------------------------------------------------
void LinkQueue_InitQueue(LinkQueue *Q);

//-------------------------------------------------------------------------------
//队列空
//-------------------------------------------------------------------------------
bool LinkQueue_IsEmpty(LinkQueue *Q);

//-------------------------------------------------------------------------------
//队列满
//-------------------------------------------------------------------------------
bool LinkQueue_IsFull(LinkQueue *Q);

//-------------------------------------------------------------------------------
//元素入队
//-------------------------------------------------------------------------------
bool LinkQueue_EnQueue(LinkQueue *Q, ElemType elemData);

//-------------------------------------------------------------------------------
//元素出队
//-------------------------------------------------------------------------------
bool LinkQueue_DeQueue(LinkQueue *Q, ElemType *elemData);

//-------------------------------------------------------------------------------
//测试函数
//-------------------------------------------------------------------------------
void LinkQueue_TestQueue(void);


#endif

实现

//===============================================================================
//				Link List For Queue 
//===============================================================================
#include "LinkQueue.h"


//===============================================================================
//I N C L U D E			F I L E
//===============================================================================
#include "LinkQueue.h"
#include "string.h"
#include "stdlib.h"
#include "stdio.h"
#include "assert.h"

//===============================================================================
//S T A T I C			D E F I N I T I O N
//===============================================================================
static ElemType inputData[5] = {
	"This is Node Data 1",
	"This is Node Data 2",
	"This is Node Data 3",
	"This is Node Data 4",
	"This is Node Data 5",
};
//===============================================================================
//S T A T I C			V A R I A B L E
//===============================================================================

//===============================================================================
//G L O B A L 			F U N		
//===============================================================================
//-------------------------------------------------------------------------------
//初始化
//-------------------------------------------------------------------------------
void LinkQueue_InitQueue(LinkQueue *Q)
{
	Q->front = malloc(sizeof(Node));
	if (Q->front != NULL){
		Q->front->next = NULL;
	}

	Q->rear  = malloc(sizeof(Node));
	if (Q->rear != NULL) {
		Q->rear->next = NULL;
	}

	Q->front = Q->rear;

	return;
}

//-------------------------------------------------------------------------------
//队列空
//-------------------------------------------------------------------------------
bool LinkQueue_IsEmpty(LinkQueue *Q)
{
	if (Q->front == Q->rear) {
		return TRUE;
	}
	else {
		return FALSE;
	}
}

//-------------------------------------------------------------------------------
//队列满
//链式队列没有队列满的概念
//-------------------------------------------------------------------------------
bool LinkQueue_IsFull(LinkQueue *Q)
{
	return FALSE;
}

//-------------------------------------------------------------------------------
//元素入队
//-------------------------------------------------------------------------------
bool LinkQueue_EnQueue(LinkQueue *Q, ElemType elemData)
{
	
	/*Node procedure part*/
	Node *pNode = malloc(sizeof(Node));
	if (pNode== NULL){
		return FALSE;
	}
	pNode->elem = elemData;
	pNode->next = NULL;

	/*Link Queue procedure part*/
	Q->rear->next = pNode;			//把有用元素elem新节点p赋给原队尾节点的后继
	Q->rear = pNode;				//把当前的p节点设置为队尾节点，rear指向pNode

	return TRUE;
}

//-------------------------------------------------------------------------------
//元素出队
//-------------------------------------------------------------------------------
//!brief   出队操作，就是头节点font的后继节点出队，
//		   若链表除头尾节点只剩一个元素时，则需将rear指向font
//!       
//-------------------------------------------------------------------------------
bool LinkQueue_DeQueue(LinkQueue *Q, ElemType *elemData)
{
	if (LinkQueue_IsEmpty(Q)){
		return FALSE;
	}

	Node *p = NULL;
	p = Q->front->next;		//获取font的后继节点
	strncpy_s(elemData->data, NODE_DATA_SIZE,  p->elem.data, strlen(p->elem.data));//获取后继节点数据
	
	Q->front = p->next;		//头节点的后继节点修改为欲删除节点的后继

	if (Q->rear == p){		//如果当前尾节点为欲删除的节点
		Q->rear = Q->front; //将rear指向font
	}

	free(p);				//释放p所指向的空间
	
	return TRUE;

}

//-------------------------------------------------------------------------------
//测试函数
//-------------------------------------------------------------------------------
void LinkQueue_TestQueue(void)
{
	LinkQueue Q;
	ElemType elemData;
	LinkQueue_InitQueue(&Q);

	for (int i=0; i<5; i++)
	{
		LinkQueue_EnQueue(&Q, inputData[i]);
		printf("Put \"%s\" in Queue\r\n", inputData[i].data);
	}
	
	printf("\r\n");

	LinkQueue_DeQueue(&Q, &elemData);
	printf("Get \"%s\" out Queue\r\n", elemData.data);

}

输出

在这里插入图片描述

wjjontheway
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【031】 队列（链式存储·循环队列）
专注【PostgreSQL源码学习&研究】
12-03 1012
文章目录1. 概述 1. 概述      在《数据结构·队列（链式存储，C实现）》一节，讲解了使用单链表方式来实现队列的功能。本节将着重描述如何使用单链表方式来实现循环队列。                                                                                                                                           ...
c语言实现循环队列和链式队列
fanc的博客
08-24 1464
队列与栈不同，队列必须是先进先出(first in first out)，而栈是后进先出的(last in first out) 链式队列与单链表的区别是，链式队列不能随意的增加，删除，以及读取队列中间的某一个数据。循环队列采用牺牲一个存储单元的方法。 front = rear表示队列空 (rear + 1) % MaxSize = front表示队列满 例如： rear = 4 fron
循环队列的链式存储实现
Cb_MX
11-17 1049
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication2 { //循环队列的链式存储 public class LinkQueue { NodeQueue front; NodeQueue rea
最全数据结构个人笔记【循环队列-链式队列】
最新发布
qq_58204972的博客
07-26 783
​ 队列是最常见的概念，日常生活经常需要排队，仔细观察队列会发现，队列是一种逻辑结构，是一种特殊的线性表。只要满足上述条件，那么这种特殊的线性表就会呈现一种“先进先出”的逻辑，这种逻辑就被称为队列。由于这种固定两端操作的简单约定，队列获得了“先进先出”的基本特性，如下图所示：​。
循环队列-链式存储结构-c语言实现
王腾涛
07-03 2797
/* 循环队列-线性表-链式结构 */ #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0typedef int Status; typedef int QElemType; //节点 定义 typedef struct QNode{ QElemType data; struct
循环队列的链式存储结构
weixin_30533797的博客
02-09 186
1 #include "stdafx.h" 2 #include <iostream> 3 #include <exception> 4 using namespace std; 5 6 //循环队列的顺序存储结构 7 8 typedef int Status; 9 const int ok = 1; 10 const int e...
数据结构-----循环队列 链式队列
FDk_LCL的博客
04-02 2661
目录 队列的定义 顺序队列 循环队列 循环队列的实现 链式队列 链式队列的实现 队列的定义 队列是一种只允许一端进行插入操作，一端只允许进行删除操作的线性表。 队列是一种先进先出（FIFO）的线性表，它只允许在表的一端进行插入和在表的另一端删除元素。在队列中，允许插入的一段叫做队尾（rear），允许删除的一端叫做队头（front）。假设队列为q = (a...
C语言实现队列源码，包含顺序队列，链式队列，循环队列，亲测可用
04-25
本文将详细讨论在C语言中实现的几种队列类型，包括顺序队列、链式队列以及循环队列，并结合提供的源代码进行解析。 顺序队列是基于数组实现的数据结构，它的特点是操作主要集中在数组的两端：一端称为队头，用于出...
djb.rar_C++_c 循环 队列_数据队列_链式队列_队列 数据结构
09-23
本压缩包“djb.rar”包含C++和C语言实现的几种队列类型，包括顺序队列、顺序循环队列和链式队列。这些源代码为理解队列的数据结构提供了很好的实例。 1. **顺序队列**：顺序队列是最简单的队列实现，它使用数组作为...
用C语言数组设计循环队列
i_Crave的博客
11-11 1772
解释： 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。 来源：力扣（LeetCode） 链接：622. 设计循环队列 - 力扣（LeetCode） (leetcode-cn.com) 著作权归领扣网络
数据结构--队列--顺序循环队列的操作实现（C语言）
羟基与苯的博客
04-15 5606
文章目录🎄队列是个什么样的数据结构？🎄循环队列🎄顺序循环队列的实现⭐1.创建初始化队列⭐2.入队⭐3.出队⭐4.队列遍历打印⭐5.清空队列⭐6.判断队列空⭐7.判断队列满⭐8.动态内存释放🎄总结 本文中涉及的完整代码及各操作测试代码均已提交至Gitee，大家可以点击链接参考。 鄙人乃是一介初学者，文中及代码中难免出错，请同志们批评指正！ 🎄队列是个什么样的数据结构？ 我们前面介绍过栈，栈乃是一个只有一个口的直筒子。那么队列，其实是一个两端开口的直筒子。其实这里的队列就基本相当于我们生活中的队列。
循环队列的基本用法（链式存储结构）
一蓑烟雨任平生的专栏
05-07 1119
#include #include #define DataType int typedef struct Node { DataType Data; struct Node *Next; }QNode; typedef struct LNode { QNode *Front; QNode *Rear; }LNode; LNode *In
Python数据结构与算法基础|第五期：代码实现——循环队列的链式存储结构
NumLock桌
01-12 627
在上一次，我们通过取余等数学方法实现了顺序存储的循环队列。由于我们使用的是Python内置的列表类型作为底层，实际上我们的存储空间并不是首尾相连的。下面，我们使用链式存储结构来实现一个真正首尾相连的循环队列： class Node(object): '定义节点。' def __init__(self): '初始化：数据域与指针域。' self.data = None sel...
数据结构 循环队列的顺序存储与链式存储
zjj8008120308的博客
12-12 1090
循环队列的顺序存储 #include<stdio.h> #include<stdlib.h> #define MaxSize 10 typedef int QElemType; typedef struct{ //对循环队列的结点的结构体进行定义 QElemType data[MaxSize]; int front; //头指针指向队首元素 int rear; //尾指针指向队尾元素的下一个位置 }SqQueue; int
循环队列的顺序存储和链式存储
weixin_44748812的博客
11-25 494
顺序存储： #include <iostream> #define MAXSIZE 5//容量 using namespace std; typedef int Datatype; typedef class Node Queue; class Node { public: Node(); ~Node() {}; void CreateQueue();//创建 int IsE...
数据结构——链式循环队列
zswsx123的博客
02-03 306
#include<iostream> #include<math.h> using namespace std; #define SIZE 10 #pragma warning(disable:4996) typedef struct l { char data; struct l* next; }node; typedef struct I { node *front; node *rear; }List; void openlist(List &L);//初始化队
线性结构--->循环队列的链式储存实现
叶晓默
10-06 1153
循环队列的链式储存
队列的链式存储结构（循环队列）
weixin_64800741的博客
03-29 97
【代码】队列的链式存储结构（循环队列）
队列的顺序存储（循环队列）和链式存储（带和不带头结点）C/C++实现
qq_49818809的博客
04-01 2092
队列的顺序存储（循环队列）和链式存储（带和不带头结点）C/C++实现 文章目录队列的顺序存储（循环队列）和链式存储（带和不带头结点）C/C++实现@[TOC](文章目录)一、循环队列1.引入库二、链式队列（带头结点）1.引入库2.读入数据三、链式队列（ 不带头结点）四、总结 由于队列的顺序存储中存在“假溢出”或“上溢出”，一般在使用中会采用循环队列或链式队列，下面给出循环队列和链式队列（带和不带头结点）的实现。 一、循环队列
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值