数据结构c语言8：链队列及循环队列

已于 2022-05-16 23:03:39 修改
阅读量486 收藏
点赞数
分类专栏： 数据结构c语言 文章标签： 数据结构 c语言
于 2022-05-16 19:59:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67231135/article/details/124803565
版权

一、链队列

链队是采用链式存储结构实现的队列，通常链队用单链表来表示。一个链队需要两个分别指向队头和队尾的指针才能唯一确定。

创建队列的链式存储结构
//创建链队列结点 
typedef struct LinkNode{
	int data;
	LinkNode* next; 
}*LinkNodePtr; 

//链队列
typedef struct LinkQueue{
	LinkNodePtr front;   //队头指针 
	LinkNodePtr rear;    //队尾指针 
}*LinkQueuePtr;

在这里插入图片描述

初始化
LinkQueuePtr initQueue(){
	LinkNodePtr headerPtr=(LinkNodePtr)malloc(sizeof(struct LinkNode));
	LinkQueuePtr resultPtr=(LinkQueuePtr)malloc(sizeof(struct LinkQueue));
	
	headerPtr->data=-1;
	headerPtr->next=NULL;
	
	resultPtr->front=headerPtr;
	resultPtr->rear=headerPtr;
	
	return resultPtr; 
}
打印队列
void outputLinkQueue(LinkQueuePtr paraQueuePtr){
	LinkNodePtr tempPtr=paraQueuePtr->front->next;
	
	while(tempPtr!=NULL){
		printf("%d ",tempPtr->data);
		tempPtr=tempPtr->next;
	}
	printf("\r\n");
}
入队
void enqueue(LinkQueuePtr paraQueuePtr,int e){
	//创建新节点 
	LinkNodePtr p=(LinkNodePtr)malloc(sizeof(LinkNodePtr));
	p->data=e;
	p->next=NULL;
	
	//移动rear指针,让p入队 
	paraQueuePtr->rear->next=p;
	paraQueuePtr->rear=p;  
}
出队
int dequeue(LinkQueuePtr paraQueuePtr){
	if(paraQueuePtr->front==paraQueuePtr->rear){
		//队列为空
		printf("队列为空，无法删除\r\n");
		return -1; 
	}
	
	//找到队列最前面结点 
	LinkNodePtr p=paraQueuePtr->front->next;
	int e=p->data; 
	
	//删除此结点
	paraQueuePtr->front->next=paraQueuePtr->front->next->next;
	if(paraQueuePtr->rear==p){
		paraQueuePtr->rear=paraQueuePtr->front;
	}
	
	free(p);
	
	return e;	
}

在这里插入图片描述

测试函数
void test(){
	LinkQueuePtr tempQueuePtr=initQueue();
	
	enqueue(tempQueuePtr, 5);
	enqueue(tempQueuePtr, 7);
	enqueue(tempQueuePtr, 58);
	outputLinkQueue(tempQueuePtr);
	
	printf("删除%d\r\n",dequeue(tempQueuePtr));
	outputLinkQueue(tempQueuePtr);
	printf("删除%d\r\n",dequeue(tempQueuePtr));
	outputLinkQueue(tempQueuePtr);
	printf("删除%d\r\n",dequeue(tempQueuePtr));
	outputLinkQueue(tempQueuePtr);
	printf("删除%d\r\n",dequeue(tempQueuePtr));
}
完整代码
#include<stdio.h>
#include<malloc.h>

//创建链队列结点 
typedef struct LinkNode{
	int data;
	LinkNode* next; 
}*LinkNodePtr; 

//链队列
typedef struct LinkQueue{
	LinkNodePtr front;   //队头指针 
	LinkNodePtr rear;    //队尾指针 
}*LinkQueuePtr; 

//初始化
LinkQueuePtr initQueue(){
	LinkNodePtr headerPtr=(LinkNodePtr)malloc(sizeof(struct LinkNode));
	LinkQueuePtr resultPtr=(LinkQueuePtr)malloc(sizeof(struct LinkQueue));
	
	headerPtr->data=-1;
	headerPtr->next=NULL;
	
	resultPtr->front=headerPtr;
	resultPtr->rear=headerPtr;
	
	return resultPtr; 
} 

//打印队列
void outputLinkQueue(LinkQueuePtr paraQueuePtr){
	LinkNodePtr tempPtr=paraQueuePtr->front->next;
	
	while(tempPtr!=NULL){
		printf("%d ",tempPtr->data);
		tempPtr=tempPtr->next;
	}
	printf("\r\n");
}

//入队 
void enqueue(LinkQueuePtr paraQueuePtr,int e){
	//创建新节点 
	LinkNodePtr p=(LinkNodePtr)malloc(sizeof(LinkNodePtr));
	p->data=e;
	p->next=NULL;
	
	//移动rear指针,让p入队 
	paraQueuePtr->rear->next=p;
	paraQueuePtr->rear=p;  
}

//出队
int dequeue(LinkQueuePtr paraQueuePtr){
	if(paraQueuePtr->front==paraQueuePtr->rear){
		//队列为空
		printf("队列为空，无法删除\r\n");
		return -1; 
	}
	
	//找到队列最前面结点 
	LinkNodePtr p=paraQueuePtr->front->next;
	int e=p->data; 
	
	//删除此结点
	paraQueuePtr->front->next=paraQueuePtr->front->next->next;
	if(paraQueuePtr->rear==p){
		paraQueuePtr->rear=paraQueuePtr->front;
	}
	
	free(p);
	
	return e;	
}

//测试
void test(){
	LinkQueuePtr tempQueuePtr=initQueue();
	
	enqueue(tempQueuePtr, 5);
	enqueue(tempQueuePtr, 7);
	enqueue(tempQueuePtr, 58);
	outputLinkQueue(tempQueuePtr);
	
	printf("删除%d\r\n",dequeue(tempQueuePtr));
	outputLinkQueue(tempQueuePtr);
	printf("删除%d\r\n",dequeue(tempQueuePtr));
	outputLinkQueue(tempQueuePtr);
	printf("删除%d\r\n",dequeue(tempQueuePtr));
	outputLinkQueue(tempQueuePtr);
	printf("删除%d\r\n",dequeue(tempQueuePtr));
} 

int main(){
	test();
}
运行结果
5 7 58
删除5
7 58
删除7
58
删除58

队列为空，无法删除
删除-1

二、循环队列

初始化创建空队列时，令front=rear=0。每当插入新的队尾元素时，rear+1；删除队头元素时，front+1。循环队列则是保持头尾指针及元素之间的关系不变，只是在循环队列中，头、尾指针“依环状增一”的操作可用“模”运算来实现。
在这里插入图片描述
因为队列无论是满还是空，头尾指针都相同，故而无法用front=rear这个条件判断队列的状态。对于这个问题，处理方法是少用一个元素空间，即当队列中有n-1个元素时就认为队满。这样队空时判断条件不变，即front=rear时；队满的判断条件则为（rear+1）%n=front。

结构体创建
typedef struct CircleQueue{
	int data[5];
	int front;
	int rear;
}*CircleQueuePtr;
初始化
CircleQueuePtr initCircleQueue(){
	CircleQueuePtr resultPtr = (CircleQueuePtr)malloc(sizeof(struct CircleQueue));
	resultPtr->front=0;
	resultPtr->rear=0;
	
	return resultPtr;
}
入队
void enqueue(CircleQueuePtr paraQueuePtr,int e){
	if((paraQueuePtr->rear+1)%5==paraQueuePtr->front%5){
		printf("队满无法添加\r\n");
		return;
	}
	
	paraQueuePtr->data[paraQueuePtr->rear%5]=e;
	paraQueuePtr->rear++;
}
出队
int dequeue(CircleQueuePtr paraQueuePtr){
	if(paraQueuePtr->rear==paraQueuePtr->front){
		printf("队空无法删除\r\n");
		return -1;
	}
	
	int resultValue=paraQueuePtr->data[paraQueuePtr->front%5];
	paraQueuePtr->front++;
	
	return resultValue;
}
打印队列
void outputCircleQueue(CircleQueuePtr paraQueuePtr){
	if(paraQueuePtr->rear==paraQueuePtr->front){
		printf("队空\r\n");
		return;
	}
	
	for(int i=paraQueuePtr->front;i<paraQueuePtr->rear;i++){
		printf("%d ",paraQueuePtr->data[i%5]);
	}
	printf("\r\n");
}
测试函数
void test(){
	CircleQueuePtr tempPtr=initCircleQueue();
	
	enqueue(tempPtr,10);
	enqueue(tempPtr,15);
	enqueue(tempPtr,20);
	enqueue(tempPtr,15);
	outputCircleQueue(tempPtr);
	
	enqueue(tempPtr,30);
	outputCircleQueue(tempPtr);
	
	printf("删除：%d\n",dequeue(tempPtr));
	outputCircleQueue(tempPtr);
	
	printf("删除：%d\n",dequeue(tempPtr));
	outputCircleQueue(tempPtr);
	
	printf("删除：%d\n",dequeue(tempPtr));
	outputCircleQueue(tempPtr);
	
	printf("删除：%d\n",dequeue(tempPtr));
	outputCircleQueue(tempPtr);
	
	printf("删除：%d\n",dequeue(tempPtr));
	outputCircleQueue(tempPtr);
		
}
完整代码
#include <stdio.h>
#include <malloc.h>

typedef struct CircleQueue{
	int data[5];
	int front;
	int rear;
}*CircleQueuePtr;

//初始化
CircleQueuePtr initCircleQueue(){
	CircleQueuePtr resultPtr = (CircleQueuePtr)malloc(sizeof(struct CircleQueue));
	resultPtr->front=0;
	resultPtr->rear=0;
	
	return resultPtr;
} 

//入队
void enqueue(CircleQueuePtr paraQueuePtr,int e){
	if((paraQueuePtr->rear+1)%5==paraQueuePtr->front){
		printf("队满无法添加\r\n");
		return;
	}
	
	paraQueuePtr->data[paraQueuePtr->rear%5]=e;
	paraQueuePtr->rear++;
} 

//出队
int dequeue(CircleQueuePtr paraQueuePtr){
	if(paraQueuePtr->rear==paraQueuePtr->front){
		printf("队空无法删除\r\n");
		return -1;
	}
	
	int resultValue=paraQueuePtr->data[paraQueuePtr->front%5];
	paraQueuePtr->front++;
	
	return resultValue;
} 

//打印队列
void outputCircleQueue(CircleQueuePtr paraQueuePtr){
	if(paraQueuePtr->rear==paraQueuePtr->front){
		printf("队空\r\n");
		return;
	}
	
	for(int i=paraQueuePtr->front;i<paraQueuePtr->rear;i++){
		printf("%d ",paraQueuePtr->data[i%5]);
	}
	printf("\r\n");
}

//测试
void test(){
	CircleQueuePtr tempPtr=initCircleQueue();
	
	enqueue(tempPtr,10);
	enqueue(tempPtr,15);
	enqueue(tempPtr,20);
	enqueue(tempPtr,15);
	outputCircleQueue(tempPtr);
	
	enqueue(tempPtr,30);
	outputCircleQueue(tempPtr);
	
	printf("删除：%d\n",dequeue(tempPtr));
	outputCircleQueue(tempPtr);
	
	printf("删除：%d\n",dequeue(tempPtr));
	outputCircleQueue(tempPtr);
	
	printf("删除：%d\n",dequeue(tempPtr));
	outputCircleQueue(tempPtr);
	
	printf("删除：%d\n",dequeue(tempPtr));
	outputCircleQueue(tempPtr);
	
	printf("删除：%d\n",dequeue(tempPtr));
	outputCircleQueue(tempPtr);
		
} 

int main(){
	test();
}
运行结果
10 15 20 15
队满无法添加
10 15 20 15
删除：10
15 20 15
删除：15
20 15
删除：20
15
删除：15
队空
队空无法删除
删除：-1
队空
AimeeChu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言中如何写一循环链表队列,C语言数据结构——线性表链式循环队列(链表实现方式)...
weixin_26833939的博客
05-21 396
队列相关知识及操作请参看上一章一、链式队列链式队列 ： 用链表形式实现的队列。链表结点为队列数据存储区，链表结点包括两部分数据存储区和指针存储区。数据存储区 ：存放真实有效数据的区域。指针存储区 ：存放下一个链表结点的地址。注意：1. 链式队列不存在队列已满的情况。在内存足够大的情况下，每次动态申请链表结点内存都会成功，即不会出现队列已满的情况，除非数据量超大内存不够。2. 链式队列只存在队列为空...
链式队列 || 循环队列--C语言实现
weixin_45506125的博客
07-15 356
链式队列的思想是尾插法，先进先出。 1、首先我们需要一个头节点 //创建一个结构体表示节点 typedef struct node_s { int data; struct node_s* next; }que; //创建头节点 que* creat_head_node() { que* head = (que*)malloc(sizeof(que)); head->next = NULL; memset(head, 0, sizeof(que)); r
循环队列以及链队列的实现（C语言）
weixin_41778615的博客
04-20 273
#define OK 1 #define ERROR 0 #define MAXSIZE 10 typedef int Status; typedef int QElemType; #if 0 /*循环链表的存储结构*/ typedef struct { QElemType data[MAXSIZE ]; int front; int rear; }SqQueue; ...
c语言实现链队列的基本功能
HZPHYT的博客
08-05 7051
链队列，实际上是一个带有头指针和尾指针的单链表，头指针指向头节点（不存放数据），尾指针指向队尾节点，虽然用头指针可以确定一个单链表，但是插入操作是在队尾进行，如果没有尾指针，会变得复杂 初始化： void init(pQueue pq){ pq-&gt;front=pq-&gt;rear=(pNode)malloc(sizeof(Node)); } 注意：（1）.为头指针和尾指针申请内存...
C语言实现顺序队列、循环队列、链式队列
记录学习点滴
04-13 2325
队列：先进先出（FIFO）。队尾入队，队头出队。 1.顺序队列 #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 typedef int dataType; typedef struct { dataType data[MAXSIZE]; int front, rear; ..................
头歌数据结构循环队列及链队列的基本操作
05-18
在本文中，我们将深入探讨头歌数据结构中的两种基本数据结构——循环队列和链队列，以及它们在实现过程中的基本操作。首先，我们来理解这两种数据结构的概念。 循环队列是一种线性数据结构，它模拟了现实生活中的...
数据结构：链队列
05-30
在众多的数据结构中，链队列是一种常用且实用的结构，尤其适用于处理动态变化的数据集合。本篇文章将详细探讨链队列，包括它的定义、工作原理以及如何在实际编程中实现。 链队列，顾名思义，是基于链表实现的队列...
xqueue：基于C语言实现的循环队列缓冲区
最新发布
04-09
在实现循环队列时，C语言提供了直接操作内存的手段，如指针操作，使得创建高效的循环队列数据结构成为可能。 根据提供的链接，`xqueue`是一个用C语言实现的循环队列缓冲区。这个库可能包含以下关键组成部分： 1. *...
数据结构之栈和队列的代码实现（C语言）
12-30
这个资源主要是使用C语言实现的栈和队列两种数据结构基本操作，包含栈的入栈、出栈，队列的入队列、出队列的相关操作，具体包含如下几个： 1、顺序栈：入栈、出栈、获取栈顶元素、打印栈。 2、链栈：入栈、出栈、...
C语言实现队列源码，包含顺序队列，链式队列，循环队列，亲测可用
04-25
本文将详细讨论在C语言中实现的几种队列类型，包括顺序队列、链式队列以及循环队列，并结合提供的源代码进行解析。 顺序队列是基于数组实现的数据结构，它的特点是操作主要集中在数组的两端：一端称为队头，用于出...
c语言链式栈或循环队列，实现插入，删除数据，能演示过程
10-15
c语言链式栈或循环队列，实现插入，删除数据，能演示过程，输出结果
C语言循环队列的表示与实现实例详解
01-01
1.概述： C语言的队列（queue），是先进先出（FIFO, First-In-First-Out）的线性表数据结构。在具体应用中通常用链表或者数组来实现。队列只允许在后端（称为rear）进行插入操作，在前端（称为front）进行删除操作。 循环队列可以更简单的防止伪溢出的发生，但是队列大小是固定的。 2.实例代码： /* 队列的顺序存储结构(循环队列) */ #define MAX_QSIZE 5 /* 最大队列长度+1 */ typedef struct { QElemType *base; /* 初始化的动态分配存储空间 */ int front; /* 头指针，若队列不空，指向
链式循环队列
呓语程序缘
10-26 921
假设以带头点的循环链表表示队列，链表长度为n，只设一个指针指向队尾元素节点，不设头指针，试编写相应的队列初始化、入队和出队的算法； 实现要求： 1、输入循环链表长度n； 2、入队m个元素； 3、打印队列中所有元素； 4、出队k个元素； 5、打印队列中的元素； 6、销毁队列。 输入： 8 6 1 2 3 4 5 6 3 输出： 1 2 3 4 5 6 4 5 6 #include <stdio.h> #include <stdlib.h> #define OK 1 #define E
C语言-数据结构-队列(循环队列(数组)与链式队列(链表))
weixin_42947972的博客
09-09 969
一.简介 在哔哩哔哩看视频学的,赫斌老师数据结构入门的内容-b站搜索:av6159200(P47),通过学习循环队列,能独立把赫斌老师教的敲出来,并且自己摸索着实现链式队列. 第三部分最后面有我链式队列的ppt图解下载 二.什么是队列 队列与栈有一个明显的区别就是,栈是先进后出,而队列是先进先出. 队列与栈有一个相同点就是那就是一开始都有顶部(top)和底部(bottom),但是为了与栈产生区别,...
数据结构 c语言实现链式循环队列（输入数字入队 输入字母出队）
不文东的博客
07-29 3600
一.头文件linkqueue.h #ifndef __LINKQUEUE_H__ #define __LINKQUEUE_H__ #include #include #include typedef int datatype; typedef struct linkqueuenode {     datatype data;     struct linkqueueno
（带头结点）循环链队列（只设队尾指针）
qq_51214556的博客
11-12 5947
只给队尾指针，不给头结点，不设头指针，要求编写初始化、入队、出队的算法。开头不懂什么意思懵逼好久，后面又因为数据运行通过，但存在非法访问内存卡了好一会，虽然不一定用的上，但还是写一下，虽然写完突然感觉也就那样，下面是个人结合代码对算法的理解。 初始化 因为只给了rear指针，初始化时，rear即指向头结点，所以rear->next=rear即是初始化条件，构成初始循环。 入队 队列从队尾入队，所以在rear指针和头结点之间插入即可。 出队 因为要遵从先进先出的特点，要删除头结点后面的一个结
c++循环队列与链队列基本操作的实现
qq_60462402的博客
04-23 3237
队列定义 队列，一种特殊的线性表，乍一看总觉得和栈有那么千丝万缕的联系。事实上，队列的确与栈非常类似，但它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 循环队列–队列的顺序表示与实现 就是与顺序表对应的队列类型，使用一组连续的存储单元依次存放队列从头到尾的元素，同时使用两个整型变量：front（头指针）与rear（尾指针）分别指示队首元素和队尾元素。 循环队列存储结构表示 typ
单链表数据结构简单实现
APCPP2012的专栏
11-17 588
#include #include struct linkNode{ int data; linkNode *next; }; linkNode *createList(){ linkNode *q; linkNode * p; int temp; cout cin>>temp; if(temp!=0){ p=(linkNode *)malloc(si

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值