【数据结构】队列（循环队列和链队列）详细讲解各种操作

已于 2023-08-21 23:00:54 修改
阅读量5.1k 收藏 87
点赞数 27
分类专栏： 数据结构 文章标签： 数据结构
于 2023-04-15 23:09:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72853403/article/details/130157136
版权

🎊专栏【数据结构】

🍔喜欢的诗句：更喜岷山千里雪 三军过后尽开颜。

🎆音乐分享【勋章】

大一同学小吉，欢迎并且感谢大家指出我的问题🥰

4ebf69852f254b96a9ab4e02ec80d809.jpeg

图片来源网络，如果侵权，请联系我 

目录

⭐队列的分类 

✨循环队列

🎈优点

🎈缺点

✨链队列

🎈优点

🎈缺点

⭐基本概念

✨队列

✨队头

✨队尾

⭐循环队列  详细操作 

🎊定义

🎈算法步骤

🎈算法描述

🎆为什么要“循环”

🚥队空

🚥队满

🎊初始化

🎈算法步骤

🎈算法描述

🎊求队列长度

🎈算法步骤

🎈算法描述

🎊入队

🎈算法步骤

🎈算法描述

🎊出队

🎈算法步骤

🎈算法描述

🎊取队头元素

🎈算法步骤

🎈算法描述

🎊遍历队列

🎈算法步骤

🎈算法描述

🍔完整代码

⭐链队列  详细操作

🎊定义

🎊初始化

🎈算法步骤

🎈算法描述

🎊入队

🎈算法步骤

🎈算法描述

🎊出队

🎈算法步骤

🎈算法描述

🎊取队头元素

🎈算法步骤

🎈算法描述

🎊遍历队列

🎈算法步骤

🎈算法描述

🍔完整代码

😎附加题

🚥核心代码

 

 

⭐队列的分类 

✨循环队列

🎈优点

  1. 有效利用存储空间：因为循环队列可以重复使用已经出队的空间，所以相对于普通队列，它更能有效地利用存储空间。

  2. 提高队列操作效率：由于循环队列的队尾和队头可以相连，所以插入和删除元素的操作都可以在 O(1) 的时间内完成，使得队列操作效率提高。

  3. 方便实现算法：循环队列广泛应用于各种算法中，如 BFS（广度优先搜索）、模拟程序、操作系统等。这是因为循环队列具有较好的随机读取性能，方便实现算法。

🎈缺点

  1. 队列长度固定：循环队列的队列长度是固定的，无法动态扩容或缩小。如果队列长度过小，可能会导致入队操作失败，而队列长度过大则会浪费存储空间。

  2. 难以判断队列是否为空：由于循环队列的队头和队尾可以相连，因此当队头指针和队尾指针重合时，无法判断队列是空还是满。为了解决这个问题，通常需要在循环队列中增加一个计数器，记录队列中元素的个数。

  3. 不易实现动态删除操作：循环队列的底层存储结构通常采用数组实现，如果要删除队列中的某个元素，需要将该元素之后的所有元素依次前移，并将队尾指针重新指向前一个位置。这个操作比较繁琐，不如链式队列方便。

✨链队列

🎈优点

  1. 队列长度没有限制：链队列没有固定长度的限制，可以动态添加和删除队列中的元素，满足不同场景下的需求。

  2. 插入和删除操作方便：由于链队列是采用链式存储结构实现的，因此在插入和删除操作时，只需要改变指针的引用即可，而不必像顺序队列那样进行元素的搬移操作。

  3. 存储空间使用灵活：链队列只需要在堆上动态分配内存，因此它可以更灵活地使用存储空间，可以通过释放已经不再需要的节点来减少存储空间的浪费。

  4. 难以出现队列满的情况：链队列不会出现队列满的情况，因为它可以动态增长，只要内存允许，就可以无限添加元素。

🎈缺点

  1. 空间开销：在使用链式存储结构时，每个节点需要额外的空间来存储指向下一个节点的指针，因此链队列的空间开销相对于顺序队列要大。

  2. 难以实现随机访问：由于链队列的存储方式是链式的，因此在进行随机访问时，查找某个位置的节点需要从头节点开始依次遍历，效率比顺序队列低。

  3. 无法利用CPU缓存：链队列中每个节点的存储空间不连续，因此使用CPU缓存会出现严重缓存不命中问题，导致效率降低。

综上所述，链队列适合插入、删除操作频繁，而对于需要快速随机访问的场景则不是很适合。当然，数据结构的选择需要综合考虑业务需求和实际情况，选择最适合的数据结构。

⭐基本概念

✨队列

一种先进先出的线性表，只允许在表的一端进行插入，另一端进行删除，类似于平时日常生活的排队

✨队头

允许删除的一端是队头（别搞反了）

✨队尾

允许插入的一端的队尾（别搞反了）

1985419053914476ab2b82c79ddfb03a.jpeg

⭐循环队列  详细操作 

🎊定义

🎈算法步骤

1.使用一组地址连续的存储单元依次存放从队头到队尾的元素

2.定义头指针front  尾指针rear

🎈算法描述

typedef struct SqQueue
{
	int *base;
	int front;//头指针
	int rear;//尾指针	
}SqQueue;

🎆为什么要“循环”

初始化创建空队列时，令front = rear = 0 ,

每当插入新的队尾元素时，尾指针rear+1,

每当删除队头元素时，头指针front+1

因此，头指针始终指向队头元素，尾指针始终指向队尾元素的下一个位置

如图所示

a0d2e238c15e482d9d3178b2f27e4501.jpeg 

假设当前队列分配的最大空间为6，那么当队列在上图（d）状态时，就不能再继续插入新的队尾元素，否则会出现溢出现象（数组非法越界），但是现在队列实际可用的空间还没有占满，那么这种现象就被叫做“假溢出”

变成“循环队列”就可以解决这个问题

循环队列里面，头，尾指针以及队列元素之间的关系不变，但是头，尾指针“按照环状+1”的操作可以通过“模”运算来实现。通过取模，头指针和尾指针就可以在顺序表空间里面以头尾衔接的方式“循环”移动

这样子

🚥队空

S.front==S.rear

🚥队满

(S.rear+1)%MAXSIZE==S.front

🎊初始化

初始化就是动态分配一个预定义大小为MAXSIZE的数组空间

🎈算法步骤

1.分配一个预定义大小为MAXSIZE的数组空间，base指向数组空间的首地址

2.将头指针和为指针置为0，表示空队列

🎈算法描述

int init(SqQueue &S)
{
	S.base=new int[maxsize];
	if(!S.base) return -1;
	S.front=S.rear=0;//空队列
	return 1;
}

🎊求队列长度

🎈算法步骤

对于非循环队列，尾指针和头指针的差值就是队列长度，但是对于循环队列，这样子算出的长度可能为负数，所以得把差值加上maxsize，然后与maxsize求余

🎈算法描述

int QueueLength(SqQueue S)
{
	return (S.rear-S.front+maxsize)%maxsize;
}

🎊入队

在队尾插入一个新的元素

🎈算法步骤

1.判断队列是否满，如果满，返回-1

2.将新元素插入队尾

（S.base[S.rear]=num）

3.队尾指针+1

🎈算法描述

int EnQueue(SqQueue &S,int num)
{
	if((S.rear+1)%maxsize==S.front) return -1;
	S.base[S.rear]=num;
	S.rear=(S.rear+1)%maxsize;//入  队尾指针+1
	return 1;
}

🎊出队

删除队头元素

d704e57b165444108c23ac7ca7cbb8a0.png

🎈算法步骤

1.判断队列是否满，如果满，返回-1

2.保存队头元素

3.队头指针+1

🎈算法描述

int DeQueue(SqQueue &S)
{
	if(S.front==S.rear) return -1;
	cout<<S.base[S.front]<<endl;
	S.front=(S.front+1)%maxsize;//出  队头指针+1
	return 1;	
}

🎊取队头元素

🎈算法步骤

当队列非空时，取出队头元素的值，队头指针不变

🎈算法描述

int GetHead(SqQueue S)
{
    if(S.front!=S.rear)    //非空
        return S.base[S.front];
}

🎊遍历队列

🎈算法步骤

1.判断队列是否空，如果空，返回-1

2.头指针+1，向下遍历队列

🎈算法描述

int Trance(SqQueue &S)
{
	if(S.front==S.rear) return -1;
	while(S.rear!=S.front)
	{
		cout<<S.base[S.front]<<" ";
		S.front=(S.front+1)%maxsize ;
	}
	return 1;
}

🍔完整代码

#include<iostream>
using namespace std;

typedef struct SqQueue
{
	int *base;
	int front;//头指针
	int rear;//尾指针	
}SqQueue;

#define maxsize 16

//1
int init(SqQueue &S)
{
	S.base=new int[maxsize];
	if(!S.base) return -1;
	S.front=S.rear=0;
	return 1;
}
//3
int EnQueue(SqQueue &S,int num)
{
	if((S.rear+1)%maxsize==S.front) return -1;
	S.base[S.rear]=num;
	S.rear=(S.rear+1)%maxsize;//入  队尾指针+1
	return 1;
}
//4
int DeQueue(SqQueue &S)
{
	if(S.front==S.rear) return -1;
	cout<<S.base[S.front]<<endl;
	S.front=(S.front+1)%maxsize;//出  队头指针+1
	return 1;	
}
//6
int Trance(SqQueue &S)
{
	if(S.front==S.rear) return -1;
	while(S.rear!=S.front)
	{
		cout<<S.base[S.front]<<" ";
		S.front=(S.front+1)%maxsize ;
	}
	return 1;
}
//7
int QueueLength(SqQueue S)
{
	return (S.rear-S.front+maxsize)%maxsize;
}

int main()
{
	SqQueue S;
	int n,m;
	cout<<"请选择:"<<endl;
	cout<<"1.初始化"<<endl;
	cout<<"2.队列是否空"<<endl;
	cout<<"3.入队"<<endl;
	cout<<"4.出队"<<endl;
	cout<<"5.判断队列是否满"<<endl;
	cout<<"6.遍历队列"<<endl;
	cout<<"7.求队列长度"<<endl;
	cout<<"0.结束"<<endl;
	for(;;)
	{
		int num;
		cin>>num;
		switch(num)
		{
			case 1:
				if(init(S)) cout<<"初始化成功"<<endl;
				else cout<<"初始化失败"<<endl;
				break;
			case 2:
				if(S.front==S.rear) cout<<"空队列"<<endl;
				else cout<<"非空队列"<<endl;
				break;
			case 3:
				cout<<"请输入需要入队的数目"<<endl;
				cin>>n;
				for(int i=0;i<n;i++)
				{
					cin>>m;
					if(EnQueue(S,m)) cout<<"入队成功"<<endl;
					else cout<<"入队失败"<<endl;
				}
				break;
			case 4:
				if(DeQueue(S)) cout<<"出队成功"<<endl;
				else cout<<"出队失败"<<endl;
				break;
			case 5:
				if(S.front==(S.rear+1)%maxsize) cout<<"队列已满"<<endl;
				else cout<<"队列未满"<<endl;
				break;
			case 6:
				if(Trance(S)) cout<<"遍历成功"<<endl;
				else cout<<"遍历失败"<<endl;
				break;
			case 7:
				cout<<"队列长度为:"<<QueueLength(S)<<endl;
			case 0:
				return 0;		
		}
	}
}

⭐链队列  详细操作

🎊定义

d13f2ad668894cfbabd1aaeb14b7a73c.png

通常，链队列使用单链表来表示

这里为了操作方便，在队头前面加上一个头结点，并且令头指针始终指向头结点 

typedef struct QNode{
	int data;
	struct QNode *next;
}QNode,*QueuePtr;

typedef struct{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;

🎊初始化

初始化就是构造一个只有头结点的空队列

🎈算法步骤

1.生成新结点作为头结点，🏳️‍🌈队头和队尾指针都指向这个结点🏳️‍🌈

2.头结点的指针域置空

🎈算法描述

int init(LinkQueue &S)
{
	S.front=S.rear=new QNode;
	S.front->next=NULL;
	return 1;
}

🎊入队

尾插法 

与循环队列入队不同，链队列入队不用判断队是否满，只要为入队元素动态分配一个内存空间即可

🎈算法步骤

1.为入队元素分配一个内存空间，用指针p指向

2.将新结点的数据域置为e

3.将新结点插入到队尾

4.修改队尾指针为p

497065a1ad444b00a78dedac3a1f9b58.jpeg 

🎈算法描述

int EnQueue(LinkQueue &S,int e)
{
	QNode *P;//注意是*P 不是 P
	P=new QNode;
	P->data=e;
	
	P->next=NULL;
	
	S.rear->next=P;//插入队尾
	S.rear=P;//修改队尾指针
	return 1;
}

🎊出队

输出队头元素

出队前要判断队是否为空，出队后要释放队头元素的空间

🎈算法步骤

1.判断队列是否为空，如果为空，那么返回-1

2.临时保存队头元素的值，方便释放空间

3.修改头指针的指针域，方便指向下一个结点

4.判断出队元素是否为最后一个结点，如果是，那么就将队尾指针重新赋值，指向头结点

5.释放原队头元素的空间

🏳️‍🌈注意：S.front->next为队头，S.front不为队头🏳️‍🌈

fc3fbaaaed5046eb9c1684f9eaf53afb.png

🎈算法描述

需要判断当队列中的最后一个元素被删后，队尾指针也会丢失，因此要对队尾指针重新赋值（指向头结点）

int DeQueue(LinkQueue &S)
{
	QNode *P;
	if(S.front==S.rear) return -1;
	
	P=S.front->next;//p指向队头元素
	cout<<P->data<<endl;
	
	S.front->next=P->next;//修改头结点的指针域
	
	if(S.rear==P) S.rear=S.front;//如果最后一个元素被删，队尾指针指向头结点
	delete P;
	
	return 1;
}

🎊取队头元素

🎈算法步骤

1.判断队是否为空

2.输出队头元素

（S.front->next->data，不是S.front->data）

🎈算法描述

int GetHead(LinkQueue S)
{
    if(S.front!=S.rear)    //非空
        return S.front->next->data;
}

🎊遍历队列

🎈算法步骤

1.创建新结点P

2.新结点P指向队头S.front->next

3.从队头遍历到队尾

🎈算法描述

int Trance(LinkQueue &S)
{
	QNode *P;
	
	if(S.front==S.rear) return -1;
	P=S.front->next;
	while(P)
	{
		cout<<P->data<<" ";
		P=P->next;
	}
	return 1;
}

🍔完整代码

#include<iostream>
using namespace std;

#define maxsize 16

typedef struct QNode{
	int data;
	struct QNode *next;
}QNode,*QueuePtr;

typedef struct{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;

//1
int init(LinkQueue &S)
{
	S.front=S.rear=new QNode;
	S.front->next=NULL;
	return 1;
}
//3
int EnQueue(LinkQueue &S,int e)
{
	QNode *P;//注意是*P 不是 P
	P=new QNode;
	P->data=e;
	
	P->next=NULL;
	
	S.rear->next=P;//插入队尾
	S.rear=P;//修改队尾指针
	return 1;
}
//4
int DeQueue(LinkQueue &S)
{
	QNode *P;
	if(S.front==S.rear) return -1;
	
	P=S.front->next;//p指向队头元素
	cout<<P->data<<endl;
	
	S.front->next=P->next;//修改头结点的指针域
	
	if(S.rear==P) S.rear=S.front;//如果最后一个元素被删，队尾指针指向头结点
	delete P;
	
	return 1;
}
//5
int Trance(LinkQueue &S)
{
	QNode *P;
	
	if(S.front==S.rear) return -1;
	P=S.front->next;
	while(P)
	{
		cout<<P->data<<" ";
		P=P->next;
	}
	return 1;
}
int main()
{
	LinkQueue S;
	int n,m;
	cout<<"请选择:"<<endl;
	cout<<"1.初始化"<<endl;
	cout<<"2.队列是否空"<<endl;
	cout<<"3.入队"<<endl;
	cout<<"4.出队"<<endl;
	cout<<"5.遍历队列"<<endl;
	cout<<"0.结束"<<endl;
	for(;;)
	{
		int num;
		cin>>num;
		switch(num)
		{
			case 1:
				if(init(S)) cout<<"初始化成功"<<endl;
				else cout<<"初始化失败"<<endl;
				break;
			case 2:
				if(S.front==S.rear) cout<<"空队列"<<endl;
				else cout<<"非空队列"<<endl;
				break;
			case 3:
				cout<<"请输入需要入队的数目"<<endl;
				cin>>n;
				for(int i=0;i<n;i++)
				{
					cin>>m;
					if(EnQueue(S,m)) cout<<"入队成功"<<endl;
					else cout<<"入队失败"<<endl;
				}
				break;
			case 4:
				if(DeQueue(S)) cout<<"出队成功"<<endl;
				else cout<<"出队失败"<<endl;
				break;
			case 5:
				if(Trance(S)) cout<<"遍历成功"<<endl;
				else cout<<"遍历失败"<<endl;
				break;
			case 0:
				return 0;
		}
	}
}

😎附加题

        假设以数组Q[m]存放循环队列中的元素，同时设置一个标志tag，以tag= 0 和tag= 1来区别在队头指针(front)和队尾指针(rear)相等时，队列状态为“空” 还是“满＂。

试编写与此结构相应的插入(Enqueue) 和删除(Dequeue) 算法。

🚥核心代码

#define m 10                                    // 定义循环队列的长度
int Q[m];                                       // 循环队列数组
int front = 0, rear = 0;                        // 队头指针和队尾指针
int tag = 0;                                    // 标志位，用于区分队空和队满状态

void Enqueue(int x) {                           // 插入元素到队尾
    if ((rear + 1) % m == front && tag == 0) {   // 判断队满
        cout << "队列已满" << endl;
        return;
    }
    Q[rear] = x;                                // 插入元素到队尾
    rear = (rear + 1) % m;                      // 队尾指针加1
    tag = 0;                                    // 标志为0表示队列不为空
}

int Dequeue() {                                 // 删除队头元素
    if (front == rear && tag == 1) {            // 判断队空
        cout << "队列已空" << endl;
        return -1;
    }
    int x = Q[front];                           // 取出队头元素
    front = (front + 1) % m;                    // 队头指针加1
    tag = 1;                                    // 标志为1表示队列不为满
    return x;
}

🥰如果大家有不明白的地方，或者文章有问题，欢迎大家在评论区讨论，指正🥰 

Code over！ 

 

在下小吉.
关注
  • 27
    点赞
  • 踩
  • 87
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 22
    评论
专栏目录
数据结构（C语言版） 清华大学出版社 第三章栈和队列 例题答案
09-06
数据结构是计算机科学中的核心课程，它探讨了如何有效地存储和操作数据。在这个主题中，栈和队列是两种基础且重要的数据结构。本章节来自《数据结构（C语言版）》清华大学出版社的第三章，专门讲解了栈和队列的概念...
数据结构循环队列的基本操作
02-01
数据结构中循环队列的基本操作，分享一下，欢迎大家批评指正！
【数据结构】循环队列
不 良的博客
07-07 4307
队列又称为"先进先出（FIFO）"线性表：插入操作只能在队尾进行，删除操作只能在队首进行。而循环队列是队列的一种特殊形式，循环队列（也被称为环形队列）是一种线性数据结构，其操作表现基于先进先出原则，并且队尾被连接在队首之后以形成一个循环。循环队列固定大小，空间能够重复利用。循环队列可以用数组或者链表实现，那下面我们来分析一下哪种方式更好：当我们想使用链表实现时，假设我们想要开辟的队列长度为k = 4；front表示队头指针，rear表示队尾指针：由上图可知，当rear和front 都指向同一个位置时队列为空
数据结构——循环队列详解
热门推荐
weixin_51785373的博客
10-27 1万+
队列主要有顺序队列，循环队列，双端队列，优先队列。而当中循环队列是一种线性数据结构。它也被称为“环形缓冲器”。它只允许在一端进行插入操作，即队尾（rear），而在另一端进行删除操作，即队头 (front)，其操作表现基于FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。向队列中插入新的数据元素称为入队，新入队的元素就成为了队列的队尾元素。循环队列允许元素在队尾插入，在队头删除，同时遵循先进先出原则。由于循环队列是基于数组实现的，所以它的访问速度很快，特别是在移动元素时。
【数据结构】队列——循环队列（详解）
最新发布
2201_75425839的博客
06-09 1104
0 循环队列循环队列（Circular Queue）是队列的一种实现方式，它通过将队列存储空间的最后一个位置与第一个位置相连接，形成一个循环的队列结构，从而可以更加高效地利用存储空间。在循环队列中，当队尾指针到达队列存储空间的末尾时，下一个插入操作将从头开始，即实现了队列的“循环”。1 特定条件下循环队列队/空队满判断条件在循环队列中，判断队列是否为空或已满是一个重要的操作。由于循环队列的特性，我们不能简单地通过比较队头指针（front）和队尾指针（rear。
循环队列详解
weixin_61488314的博客
03-22 744
为了满足队列先进先出的特点,我们要保证可以很容易的找到第一个元素的位置和最后一个元素的位置,用单链表我们是可以用两个指针来定位第一个元素和最后一个元素的位置,可以很方便的进行插入,删除,但是我们还要对队列进行判空和判满操作,那么此时就会遇到一个问题,当队头指针和队尾指针相等时代表着空还是满呢?利用数据在数组中的下标来判断队列是否为满,当rear的下一个为front的时候表示满,size表示实际能存储的数据个数,这里的size = 5。当push一个元素之后,rear此时指向的是最后一个数据的下一个节点。
队列之循环队列
TomotoJ的博客
03-18 620
首先搞清楚什么是队列？ 队列：只允许在一段进行插入，在另一端进行删除的线性表。 循环队列：具有队头指针和队尾指针，指示队列元素所在的位置，避免删除元素时移动大量元素。 循环队列特性： 只能从队尾插入元素、在队头删除元素。 先进先出（First In First Out）的线性表，先进入的元素出队，后进入的元素才能出队。 优点： 相比普通的队列，元素出队时无需移动大量元素，只需移动头指针。 适...
队列文档之循环队列
二木成林
05-09 8215
循环队列就是将顺序队列臆造成一个环状的空间（实际上不是，只是把它看成是环状的），即把存储队列元素的顺序表从逻辑上视为一个环。
数据结构——循环队列
yue152152的博客
03-28 1万+
概念 基于队列的先进先出的原则，在确定了队列长度的前提下，另队列首尾相接而实现的一种结构。 循环队列的作用 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/design-circular-queue 题目 设置循环队列 注意事项 .
NJUCM-数据结构课程3.实验三 栈和队列.zip
06-02
这两种数据结构在计算机科学中有着广泛的应用，尤其是在算法设计、编译原理、操作系统、网络以及各种软件开发中。 《数据结构》实验报告3.doc 文件可能包含了对实验的全面总结，包括实验目的、实验环境、实验内容和...
数据结构 队列实验报告.pdf
06-18
在链队列中，我们通常会添加一个头结点，方便管理和操作。链队列的特点是仅允许在队尾插入元素（入队），在队头删除元素（出队）。程序设计中，用户通过输入特定命令与系统交互，例如查看队列长度、元素入队、出队、...
算法与数据结构：6-栈和队列3.pdf
09-20
《算法与数据结构：6-栈和队列3》主要讲解了栈和队列在实现递归中的应用，特别以斐波那契数列为例子进行了深入的阐述。斐波那契数列是一个典型的递归问题，其特点是每一项等于前两项之和。在讲解过程中，通过两种...
数据结构-C语言版-第二版(严蔚敏)-第3章-栈和队列-答案.doc
12-06
本资源主要讲解了数据结构中的栈和队列两种基本数据结构。栈是一种后进先出的线性表，队列是一种先进先出的线性表。栈和队列都是基本的数据结构，可以应用于解决多种计算机科学问题。 栈 栈是一种后进先出的线性表...
栈和队列的实现
05-24
在《实验2 栈和队列的实现.doc》文档中，可能会详细讲解这两种数据结构的定义、特性、操作以及如何用代码实现。通常，文档会涵盖以下内容： - 栈和队列的基本概念 - 栈和队列的操作（Push、Pop、Enqueue、Dequeue） ...
数据结构和算法.zip
01-01
"数据结构和算法.zip"这个压缩包文件很可能包含了关于数据结构的各种讲解、示例和练习，虽然具体的子文件名"fgsefgergj"无法直接提供详细信息，但我们可以根据一般的数据结构学习内容来探讨相关知识点。 1. **数组*...
2019天勤数据结构与操作系统二合一
08-29
这份2019天勤的资料集将帮助学习者建立起对数据结构和操作系统坚实的理解，这对于计算机专业学生准备面试、提升技能或者进行项目开发都极其有益。通过深入学习和实践，可以提升解决问题的能力，更好地适应IT行业的...
（带头结点）循环链队列（只设队尾指针）
qq_51214556的博客
11-12 5954
只给队尾指针，不给头结点，不设头指针，要求编写初始化、入队、出队的算法。开头不懂什么意思懵逼好久，后面又因为数据运行通过，但存在非法访问内存卡了好一会，虽然不一定用的上，但还是写一下，虽然写完突然感觉也就那样，下面是个人结合代码对算法的理解。 初始化 因为只给了rear指针，初始化时，rear即指向头结点，所以rear->next=rear即是初始化条件，构成初始循环。 入队 队列从队尾入队，所以在rear指针和头结点之间插入即可。 出队 因为要遵从先进先出的特点，要删除头结点后面的一个结
循环队列和链式队列的结构及其基本操作（入队、出队、取队头、查看对内元素）
Fizz_沫烨的博客
01-23 9578
循环队列 队列：只允许在一端进行插入操作，在另一端进行删除操作；数据存储在一个一维数组中 特点：先进先出（FIFO）结构 队头（front）：删除数据的一端 队尾（rear）：插入数据的一端 顺序队列的缺点：空队时front和rear都指向下标-1处，进队时rear先+1，再放入数据，出队时front先+1，再删数据 队满时一个个删数据，当front和rear都指向最后的位置时，前面的
数据结构-队列
小白白O快起来
01-25 1633
本篇文章讲解了，队列的特性，顺序队列、循环队列、链队等基本操作的代码，在应用中讲解了几个使用到队列的算法
educoder实训教学平台数据结构c语言循环队列及链队列的基本操作
10-23
循环队列是一种特殊的队列，其特点是队列的元素在物理结构上是环形排列的。educoder实训教学平台提供了循环队列的基本操作，包括初始化、入队、出队和判空等。 循环队列的初始化操作是创建一个空队列，并设置队列的头指针和尾指针都为0。入队操作是往队尾插入一个元素，插入后尾指针向后移动一位，并将元素放入新的队尾位置。出队操作是将队首元素删除，删除后头指针向后移动一位。判空操作是通过比较队列的头指针和尾指针是否相等来确定队列是否为空。 链队列是使用链表实现的队列，其特点是可以动态地分配内存空间，不会造成内存溢出的问题。educoder实训教学平台也提供了链队列的基本操作，包括初始化、入队、出队和判空等。 链队列的初始化操作是创建一个空队列，并设置头指针和尾指针都指向空节点。入队操作是在链队列的尾部插入一个新节点，尾指针向后移动一位，并将新节点的数据放入新的尾节点。出队操作是删除链队列的头节点，头指针向后移动一位。判空操作是通过判断链队列的头指针和尾指针是否指向同一节点来确定队列是否为空。 通过educoder实训教学平台提供的循环队列和链队列的基本操作，学习者可以掌握数据结构中队列的实现方式和基本操作的原理，进而应用于解决一些实际问题。
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

在下小吉.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值