数据结构学习笔记(8.循环队列与链队列)

最新推荐文章于 2022-09-13 01:34:38 发布
最新推荐文章于 2022-09-13 01:34:38 发布
阅读量1.7k 收藏 2
点赞数 3
分类专栏： 数据结构(c语言描述)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mbh_1991/article/details/22653511
版权

本节知识点：

1.队列的概念：
    a.队列也是一种特殊的线性表，队列仅在线性表的两端进行操作，队头：取出数据元素的一端、队尾：插入数据元素的一端！
    b.队列的性质：先进先出(FIFO)

     对于普通的链式队列和顺序队列来说，具体的实现方式跟链式栈和顺序栈一样，只不过无所谓哪边是队列头、哪边是队列尾。因为时间复杂度必然有一端为O(1)，另一端为O(N)！对于这样的复杂度，我们就应该想办法使它都降到O(1)，所以就引入了循环队列！
2.循环队列：



代码如下：

SeqQueue.c文件：

/************************************************************************************ 
文件名：SeqQueue.c
头文件：SeqQueue.h 
时间： 2014/03/31 
作者： Hao 
功能：可以复用的顺序循环队列  即入队列和出队列的时间复杂度都为O(1) 
************************************************************************************/
#include <stdio.h>
#include <malloc.h>
#include "SeqQueue.h"

typedef void* TSeqQueueNode;
typedef struct str_SeqQueue
{
	int capacity;
    int length;
    int front;
    int rear;
    TSeqQueueNode* node;
}TSeqQueue;

/************************************************************************************ 
函数名：   SeqQueue_Create
函数功能： 创建一个容量为capacity的循环队列 
参数：     int capacity 创建循环队列中成员的个数 即循环队列容量
返回值：   void* ret 如果返回NULL 说明创建循环队列失败
                     如果返回ret 说明创建循环队列成功  且ret为描述循环队列的结构体 
************************************************************************************/
SeqQueue* SeqQueue_Create(int capacity)
{
    TSeqQueue* ret = NULL;
    
    if( capacity >= 0 )
    {
        ret = (TSeqQueue*)malloc(sizeof(TSeqQueue) + sizeof(TSeqQueueNode) * capacity);   
	    if( ret != NULL )
	    {
	        ret->capacity = capacity;
	        ret->length = 0;
	        ret->front = 0;
	        ret->rear = 0;
	        ret->node = (TSeqQueueNode*)(ret + 1);
	    }
    }
    else
	{
		ret = NULL;
	} 
    return (SeqQueue*)ret;	
}

/************************************************************************************ 
函数名：   SeqQueue_Destroy
函数功能： 销毁循环队列   free开辟的内存 
参数：     void* list 描述循环队列结构体指针
返回值：   void 
************************************************************************************/
void SeqQueue_Destroy(SeqQueue* queue)
{
	free(queue);
}

/************************************************************************************ 
函数名：  SeqQueue_Clear
函数功能：清空循环队列  其实就是给length=0； front = 0   rear = 0;
函数参数：SeqQueue* queue 描述循环队列结构体指针
函数返回值：int ret  成功返回0
                     失败返回-1 
************************************************************************************/
int SeqQueue_Clear(SeqQueue* queue)
{
	int ret;
	TSeqQueue *Tqueue = (TSeqQueue* )queue;
	/*函数参数合法性检测*/
	if(NULL != Tqueue)
	{
		Tqueue->length = 0;
		Tqueue->front = 0;
		Tqueue->rear = 0;
		ret=0;
	} 
	else
		ret=-1;
	return ret;
}

/************************************************************************************ 
函数名：  SeqQueue_Length
函数功能：获得循环队列 现在的大小
函数参数：void* list 描述循环队列结构体指针
函数返回值：int ret  成功返回length
                     失败返回-1 
************************************************************************************/
int SeqQueue_Length(SeqQueue* queue)
{
	int ret;
	TSeqQueue *Tqueue = (SeqQueue* )queue;
	/*函数参数合法性检测*/
	if(NULL != Tqueue)
	{
		ret = Tqueue->length;
	} 
	else
		ret = -1;
	return ret;
}

/************************************************************************************
函数名：  SeqQueue_Capacity
函数功能：获得循环队列 的容量 
函数参数：void* list 描述循环队列结构体指针
函数返回值：int ret  成功返回capacity 
                     失败返回-1 
************************************************************************************/
int SeqQueue_Capacity(SeqQueue* queue)
{
	int ret;
	TSeqQueue *Tqueue = (SeqQueue* )queue;
	/*函数参数合法性检测*/
	if(NULL != Tqueue)
	{
		ret = Tqueue->capacity;
	} 
	else
		ret = -1;
	return ret;
}

/************************************************************************************
函数名：  SeqQueue_Push
函数功能：入队操作 
函数参数：SeqQueue* queue入队队列, void* data入队数据元素  
          这个队列是从尾部入队rear  从头部出队front  
函数返回值：int ret  成功返回 1 
                     失败返回 0
************************************************************************************/
int SeqQueue_Push(SeqQueue* queue, void* data)
{
	TSeqQueue* Tqueue = (TSeqQueue*)queue;
	int ret = (Tqueue != NULL) && (data != NULL); //安全性检测 
    ret = ret && (Tqueue->length + 1 <= Tqueue->capacity); //容量检测 
    if(ret)
	{
		Tqueue->node[Tqueue->rear] = data;
		Tqueue->rear = (Tqueue->rear + 1) % Tqueue->capacity;
		Tqueue->length++;
	} 
	
	return ret;  
}

/************************************************************************************
函数名：  SeqQueue_Pop
函数功能：出队操作 
函数参数：SeqQueue* queue出队队列  
          这个队列是从尾部入队rear  从头部出队front  
函数返回值：void* ret  成功返回 数据元素地址 
                       失败返回 NULL 
************************************************************************************/
void* SeqQueue_Pop(SeqQueue* queue)
{
	TSeqQueue* Tqueue = (TSeqQueue*)queue;
	void* ret = NULL;
	if((Tqueue != NULL) && (Tqueue->length > 0))
	{
		ret = (void*)(Tqueue->node[Tqueue->front]);
		Tqueue->front = (Tqueue->front + 1) % Tqueue->capacity;
		Tqueue->length--;
	}
	return ret;
}

/************************************************************************************
函数名：  SeqQueue_Top
函数功能：获得队尾元素地址 
函数参数：SeqQueue* queue出队队列  
          这个队列是从尾部入队rear  从头部出队front  
函数返回值：void* ret  成功返回 队尾数据元素地址 
                       失败返回 NULL 
************************************************************************************/
void* SeqQueue_Top(SeqQueue* queue)
{
	TSeqQueue* Tqueue = (TSeqQueue*)queue;
	void* ret = NULL;
	if((Tqueue != NULL) && (Tqueue->length > 0))
	{
		ret = (void*)(Tqueue->node[Tqueue->front]);
	}
	return ret;
}

SeqQueue.h文件： 

#ifndef _SeqQueue_H_
#define _SeqQueue_H_

typedef void SeqQueue;

SeqQueue* SeqQueue_Create(int capacity);

void SeqQueue_Destroy(SeqQueue* queue);

int SeqQueue_Clear(SeqQueue* queue);

int SeqQueue_Push(SeqQueue* queue, void* data);

void* SeqQueue_Pop(SeqQueue* queue);

void* SeqQueue_Top(SeqQueue* queue);

int SeqQueue_Length(SeqQueue* queue);

int SeqQueue_Capacity(SeqQueue* queue);

#endif

main.c文件： 

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


int main(int argc, char *argv[]) 
{
    SeqQueue* queue = SeqQueue_Create(6);
    int a[10] = {0};
    int i = 0;
    
    for(i=0; i<10; i++)
    {
        a[i] = i + 1;
        
        SeqQueue_Push(queue, a + i);
    }
    
    printf("Top: %d\n", *(int*)SeqQueue_Top(queue));
    printf("Length: %d\n", SeqQueue_Length(queue));
    printf("Capacity: %d\n", SeqQueue_Capacity(queue));
    
    while( SeqQueue_Length(queue) > 0 )
    {
        printf("Pop: %d\n", *(int*)SeqQueue_Pop(queue));
    }
    
    printf("\n");
    
    for(i=0; i<10; i++)
    {
        a[i] = i + 1;
        
        SeqQueue_Push(queue, a + i);
        printf("Pop: %d\n", *(int*)SeqQueue_Pop(queue));
    }
    
    SeqQueue_Destroy(queue);
    
	return 0;
}
注意：其实循环队列就是在一段内存空间中，使用front和rear变量夹住一端空间，使其成为顺序队列，并且入队列和出队列的时间复杂度都是O(1)
3.链式队列：


示例代码：

LinkQueue.c文件：

/*******************************************************************************************************
文件名：LinkQueue.c
头文件：LinkQueue.h 
时间： 2013/03/31
作者： Hao
功能:  可以复用 链式队列 
*******************************************************************************************************/
#include <stdio.h>
#include <malloc.h>
#include "LinkQueue.h"

typedef struct str_linkqueue
{
	LinkQueueNode* front;
	LinkQueueNode* rear;
	int length;
}link_queue;

/*******************************************************************************************************
函数名：  Creat_LinkQueueHead
函数功能：创建一个链式队列头 并给队列头分配空间
参数： void
返回值：ret 成功返回链表头地址  失败返回NULL 
*******************************************************************************************************/
LinkQueue* Creat_LinkQueueHead(void)
{
	link_queue* ret = NULL;
	ret = (link_queue* )malloc( sizeof(link_queue)*1 );
	if(NULL != ret) //malloc分配成功 
	{
		ret -> length = 0;
		ret -> front = NULL;
		ret -> rear = NULL; 
	}
	return (LinkQueue* )ret; 
}

/*******************************************************************************************************
函数名：  Get_Length
函数功能：获得链式队列的长度 
参数： LinkQueue* queue 描述队列的结构体 
返回值：ret 成功返回队列长度  失败返回0 
*******************************************************************************************************/
int Get_Length(LinkQueue* queue)
{
	int ret = 0;
	link_queue* lqueue = (link_queue* )queue;
	if( NULL != lqueue )
	{
		ret = lqueue -> length;
	}	
	return ret;
}

/*******************************************************************************************************
函数名：  LinkQueue_Push
函数功能：把数据data从队尾加入队列中 
参数： LinkQueue* queue 描述队列的结构体   void* data 要加入队列数据的地址 
返回值：ret 成功返回1  失败返回0 
*******************************************************************************************************/
int LinkQueue_Push(LinkQueue* queue, void* data)
{
	link_queue* lqueue = (link_queue* )queue;
	int ret = ((NULL != lqueue)&&(NULL != data));
	if(ret)
	{
		LinkQueueNode* node = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
		if(NULL != node)
		{
			node -> Queuedata = data;
			if(lqueue -> length == 0)
			{
				lqueue -> front = node;
				lqueue -> rear = node;
				node -> next = NULL;
			}
			else
			{
				lqueue -> rear -> next = node;
				lqueue -> rear = node;
				node -> next = NULL; 
			}
			lqueue -> length++;
		}
		
	}
	
	return ret;
} 

/*******************************************************************************************************
函数名：  LinkQueue_Pop
函数功能：把数据从队头取出 
参数： LinkQueue* queue 描述队列的结构体   
返回值：ret 成功返回取出数据地址  失败返回NULL 
*******************************************************************************************************/
void* LinkQueue_Pop(LinkQueue* queue)
{
	void* ret = NULL;
	LinkQueueNode* node = NULL; 
	link_queue* lqueue = (link_queue* )queue;
	
	if((NULL != lqueue)&&(lqueue->length > 0))
	{
		node = lqueue->front;
		lqueue->front = lqueue->front->next;
		lqueue->length--;
		ret = node->Queuedata;
		free(node);
		
		if(lqueue->length == 0)
		{
			lqueue->front = NULL; //其实理论上可以不给front赋值NULL的  
			lqueue->rear = NULL;
		}
	}
	return ret;
} 

/*******************************************************************************************************
函数名：  LinkQueue_Top
函数功能：获得队头数据地址 
参数： LinkQueue* queue 描述队列的结构体   
返回值：ret 成功返回取出数据地址  失败返回NULL 
*******************************************************************************************************/
void* LinkQueue_Top(LinkQueue* queue)
{
	void* ret = NULL;

	link_queue* lqueue = (link_queue* )queue;
	
	if((NULL != lqueue)&&(lqueue->length > 0))
	{
		ret = lqueue->front->Queuedata;

	}
	return ret;
} 

/*******************************************************************************************************
函数名：  Clean_LinkQueue
函数功能：清空队列 
参数： LinkQueue* queue 描述队列的结构体   
返回值：ret 成功返回1  失败返回0 
*******************************************************************************************************/
int Clean_LinkQueue(LinkQueue* queue)
{
	int ret = 0;
	void* temp = NULL;
	if(NULL != queue)
	{
		ret = 1;
		while(Get_Length(queue))
		{
			temp = LinkQueue_Pop(queue);
			if(NULL == temp)
			{
				ret = 0;
				break;
			}
		}
		
	}
	return ret;
}

/*******************************************************************************************************
函数名：  Destroy_LinkQueue
函数功能：清空队列并且销毁队列头 
参数： LinkQueue* queue 描述队列的结构体   
返回值：ret 成功返回1  失败返回0 
*******************************************************************************************************/
void Destroy_LinkQueue(LinkQueue* queue)
{
	Clean_LinkQueue(queue);
	free(queue);
}

LinkQueue.h 文件： 

#ifndef __LinkQueue_H__
#define __LinkQueue_H__

typedef void LinkQueue;  //这个是为了 封装方便 
typedef struct Str_LinkQueue LinkQueueNode;  //这个结构体是链表的真身 
struct Str_LinkQueue   
{                     
	LinkQueueNode* next;
	void* Queuedata;
};

LinkQueue* Creat_LinkQueueHead(void);

void Destroy_LinkQueue(LinkQueue* queue);

int Get_Length(LinkQueue* queue);

int Clean_LinkQueue(LinkQueue* queue);

int LinkQueue_Push(LinkQueue* queue, void* data);

void* LinkQueue_Pop(LinkQueue* queue);

void* LinkQueue_Top(LinkQueue* queue); 
 
#endif

main.c 文件： 

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

int main()
{
	LinkQueue* queue = Creat_LinkQueueHead();
    int a[10] = {0};
    int i = 0;
    
    for(i=0; i<10; i++)
    {
        a[i] = i + 1;
        
        LinkQueue_Push(queue, a + i);
    }
    
    printf("Pop: %d\n", *(int*)LinkQueue_Pop(queue));
    printf("Top: %d\n", *(int*)LinkQueue_Top(queue));
    printf("Length: %d\n", Get_Length(queue));
    
    //Clean_LinkQueue(queue);
    
    while( Get_Length(queue) > 0 )
    {
        printf("Pop: %d\n", *(int*)LinkQueue_Pop(queue));
    }
    
    Destroy_LinkQueue(queue);
	return 0;
}
注意：链队列，无非就是定义了两个指针，分别指向队列头和队列尾，这样找到队头和队尾的时间复杂度就是O(1)



qq418674358
关注
专栏目录
结构体与循环队列
u013744104的博客
10-17 370
循环队列，是可以循环存储的的顺序队列 节点的结构： typedef struct { int size; int front; int rear; int* data; } MyCircularQueue; 需要以个Front 和Rear 两个指针。 Rear 用于进队，Front 用于进队。 操作方式:创建队列，进队，出队，打印队列，对是否为空，对是否满。清空对，释放对。 创建对： Front 与Rear 均为0: MyCircularQueue* myCircularQ
数据结构 | 循环队列结构
JacobTsang的博客
05-31 711
队列（Queue） 定义：限定在表的一端插入，在表的另一端删除的线性表。 先进入队列的先出去。 为了解决队列数据结构假溢出的缺陷，采用循环队列结构，把数组逻辑上看成一个头尾相连的环。 #include <iostream> #include <stdlib.h> #include <windows.h> using namespace std; typede...
数据结构：循环队列（C语言实现）
热门推荐
lpp0900320123的专栏
03-07 12万+
生活中有很多队列的影子，比如打饭排队，买火车票排队问题等，可以说与时间相关的问题，一般都会涉及到队列问题；从生活中，可以抽象出队列的概念，队列就是一个能够实现“先进先出”的存储结构。队列分为链式队列和静态队列；静态队列一般用数组来实现，但此时的队列必须是循环队列，否则会造成巨大的内存浪费；链式队列是用链表来实现队列的。这里讲的是循环队列，首先我们必须明白下面几个问题 一、循环队列的基础知识 1
循环队列-基础数据结构
hi332516_1的博客
03-08 1193
队列：也是一种受到限制的线性表，一端进行入队，另一端进行出队，我们将入队的一端一般称作队尾，另一端称作队头。如果没有元素叫做空队。 队列的特点：先进先出（FIFO） 顺序表实现的队列为什么叫循环队列？ 关于循环队列的三个难点：（重点） 第一个难点：怎么让队列也可以实现入队和出队的时间复杂度都为 O(1) 此时，入队的时间复杂度为多少？（入106） O(1) 不需要挪动元素 出队的时间复杂度为多少？（出101） O(n) 需要挪动元素 所以，...
【数据结构】循环队列
ZXC
06-05 537
#define MAXSIZE 10 typedef struct { int data[MAXSIZE]; int head; int rear; }loopQueue;循环队列结构体，尾节点不存放元素。int getLength_loopQueue(loopQueue *queue) { return (queue-&gt;rear + MAXSIZE - queue-&gt;head...
数据结构学习笔记：链队列和循环队列
m0_52799531的博客
05-16 500
一、链式队列 链式队列，简称"链队列"，即使用链表实现的队列存储结构。 链式队列的实现思想同顺序队列类似，只需创建两个指针（命名为 top 和 rear）分别指向链表中队列的队头 创建链式队列的 C 语言实现代码为: //创建链队列结点 typedef struct LinkNode{ int data; LinkNode* next; }*LinkNodePtr; //链队列 typedef struct LinkQueue{ LinkNodePtr front; //队头.
数据结构学习笔记.docx
06-06
### 数据结构学习笔记知识点概述 #### 一、算法复杂度 **时间复杂度**：算法的时间复杂度是指算法运行时间与问题规模之间的关系。如果一个算法的基本操作执行次数是问题规模\( n \)的一个函数\( f(n) \)，那么该...
c语言数据结构学习笔记.pdf
08-17
C语言数据结构学习笔记的核心内容可以分为以下几个方面： 1. 数据结构基础 数据结构是计算机存储、组织数据的方式。它包括数据的逻辑结构、物理结构（存储结构）以及数据的运算。 1.1 逻辑结构和物理结构 逻辑结构...
数据结构学习笔记（3.栈，队列，数组 4.串）
super_song的博客
05-04 1197
文章目录第三章 栈，队列和数组栈（stack）顺序栈的实现 第三章 栈，队列和数组 栈（stack） 栈的定义 只允许在一端进行插入或删除操作的线性表 重要术语：栈顶，栈底，空栈 栈的基本操作 创建，销毁，进栈，出栈， 栈的常考题型 可能是先全部进栈，再出栈；也可能是边进边出； 可能的出栈顺序的排列组合为卡特兰数，了解即可 考试多数出选择题，选出可能的情况 知识点小结 栈是一种进出受限的线性表 顺序栈的实现 ...
数据结构之循环队列
qq_36660655的博客
01-27 511
循环队列 首先存储队列元素的结构体是数组 循环的含义为front以及rear可以循环的代表任意一个数组元素的下表 通过（front+1）%len或者（rear+1）%len来实现 front为队列中第一个元素的下标 rear为队列最后元素的下一个存储空间的下标 判断队列是否为空，用（front=？rear）规定相等就是队列为空不相等就是队列中存在元素 判断队列是否已满（不是指数组满而是指队列满，...
数据结构 链队列
weixin_62746979的博客
05-17 218
1.介绍链队列前先来看一下关于的知识点 上图介绍了队列的几种变化，空队列时对头队尾指针都指向头指针，插入一个元素x时，队尾指针指向x，头指针也指向x。 2.上代码 #include<stdio.h> #include<malloc.h> typedef struct LinkNode { int data; LinkNode* next; }*LinkNodePtr; typedef struct LinkQueue { LinkNodePtr front;
数据结构学习笔记 --- 队列（链队列）
whz_zb的专栏
02-12 1107
1. 引言  本文主要讲解链队列。和栈一样，队列也是操作受限的线性表，只允许在队尾插入元素，在对头删除元素。对于链队列结构， 为了便于插入元素，设立了队尾指针。这样插入元素的操作与队列长度无关。 2. 链队列 #include "ds.h" typedef int QElemType; typedef struct QNode{ QEl
循环队列知识点
janvinal的专栏
03-11 1714
//向循环队列插入元素 status enqueue(sqqueue &q,const int&e)//队列插入元素 {     if( (q.rear+1)%MAXSIZE==q.front ) return ERROR;//队满返回添加元素错误     q.base[q.rear]=e;//添加元素     q.rear=(q.rear+1)%MAXSIZE;//修改队尾指针指到添加
数据结构 循环队列
FriedrichSong的博客
08-10 307
循环队列
循环队列的简单知识
dressrosa
03-06 780
队列其实也是链表，这里讲的是顺序表示。队列，顾名思义，就是排队的队形。按照专业一点就是FIFO(first in first out) 原则，从对列头出列，从对尾入列。 因为循环队列最利用效率，也稍微增加了难度，所以要记住循环队列的表示方法。 其实很多数据结构都有很多种写法，重要是理解其思想，代码完成只是让自己更加透彻的掌握，每一种实现方式都是按其思想一步一步完成的。 先贴出结构体：
循环队列知识点（附加6-1 另类循环队列 (15分)）
chstor's blog
03-13 802
**循环队列** 队首Q->Front=(Q->Front+1)%Q->MaxSize; 队尾Q->Rear=(Q->Front+Q->Count)%Q->MaxSize; 通用的计算队列长度公式：(rear-front+QueueSi...
循环队列基础知识
steph_curry的博客
12-27 216
#include #include "stdlib.h" #include using namespace std; typedef char ElemType; #define MAX_SIZE 100 struct CQueue { ElemType *base; int front; int rear; }; typedef CQueue CircleQueue; void InitC
链队列学习笔记
Bless
04-10 173
队列的链式结构一. 链队列的简单操作1.1 链队列的定义1.2 初始化链队列1.3 入队操作和出队操作1.4 打印链队列1.5 链队列的长度1.6 主函数 一. 链队列的简单操作 以下为一些基础的操作函数。 1.1 链队列的定义 #include<bits/stdc++.h> using namespace std; //链队列 typedef int ElemType; //...
数据结构详解(其六) 循环队列
look_outs的博客
09-13 145
循环队列又称为环形缓冲器，要求在资源（队列长度）有限的情况下完成队列
刘斯宇数据结构笔记：顺序表、栈与队列详解
- 文件提供了一个系统的数据结构学习框架，涵盖了理论与实践，适合进一步深入研究。 这个文档提供了丰富的数据结构基础知识，对于理解计算机科学中的基础组织方式和算法实现至关重要。无论是学习编程初学者还是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值