【链式队列的实现】

最新推荐文章于 2024-08-31 22:19:14 发布
最新推荐文章于 2024-08-31 22:19:14 发布
阅读量401 收藏 11
点赞数 7
分类专栏： 数据结构 文章标签： 数据结构 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_82676816/article/details/141750079
版权

1.链式队列 与 循环顺序队的比较

1.1链式队列

优点

  • 动态扩展：

不需要预先分配固定的存储空间，内存使用灵活，不会因为队列满而导致溢出。

  • 插入和删除操作简单：

在链式队列中，插入和删除操作只需调整指针，无需移动数据，时间复杂度为O(1)。

  • 无容量限制：

只要系统有足够的内存，链式队列可以容纳任意数量的元素。

缺点

  • 额外内存消耗：

每个元素需要额外存储指针，导致内存开销增加。

  • 实现复杂度高：

需要处理指针的管理，容易出现难以发现的错误，特别是在多线程环境下更为复杂。

  • 缓存性能差：

由于链表的元素在内存中可能是不连续存储的，因此缓存命中率低，访问速度可能较慢。

1.2环顺序队列

优点

  • 内存使用紧凑：

循环顺序队列在预先分配好的固定内存空间中进行操作，无需额外的指针存储空间，内存开销较小。

  • 缓存性能好：

元素存储在连续的内存空间中，这样能够提高缓存命中率，访问速度较快。

  • 实现简单：

循环顺序队列的实现相对简单，不需要处理复杂的指针操作，尤其是在单线程环境下，管理更容易。

缺点

  • 固定容量：

循环顺序队列需要预先指定容量，如果容量不足可能会导致队列溢出，容量过大会浪费内存。

  • 插入删除操作效率稍低：

尽管循环顺序队列的插入和删除操作复杂度也是O(1)，但在环绕操作时需要计算位置，可能影响操作效率。

  • 难以扩展：

如果需要增加队列的容量，必须重新分配更大的内存并迁移数据，这个过程复杂且耗时。

1.3小结

  • 链式队列适合需要动态扩展、且对内存消耗不敏感的场景，适用于元素数量不可预知或频繁变化的情况。
  • 循环顺序队列则适合对内存有严格限制、且元素数量相对固定的场景，适用于内存紧张的环境中，且能有效利用缓存提高访问速度。

2.链式队列的整队创建（包含头结点，头尾指针）

2.1链式队列的结构类型定义

在这里插入图片描述
一个完整的链式队列包含头指针，尾指针，头结点，一般结点这四个部分

//<1>队列结点结构定义
typedef struct QNode
{
	QElemType data;//队结点数据域,用来存储队列元素
	struct QNode* next;//队结点指针域，用来指向下一个队结点
}QNode, *QNodePtr;
//QNode: 链队列结点类型,用来定义队结点
//QNodePtr: 链队列结点指针类型，用来定义队结点指针

//<2>队列链式定义
typedef struct
{
	QNodePtr front, rear;//定义链队的头指针，尾指针
}LinkQueue;
//LinkQueue:通过LinkQueue定义链队列；通过 定义出的链队列 访问队列的头指针，尾指针

2.1.1链式队列的基本操作图解

在这里插入图片描述

2.2.链队列的初始化

注意：传入链队列类型的指针，因为初始化时要修改 链队列类型中 的头尾指针

bool InitQueue(LinkQueue * q)

2.2.1算法步骤

（1）创建头结点 并 将头尾指针指向头结点
（2）初始化链式队列头结点的指针域

在这里插入图片描述
初始化完成后的空队如上图

//1.链队列的初始化
//注意：传入链队列类型的指针，因为初始化时要修改 链队列类型中 的头尾指针
bool InitQueue(LinkQueue * q)
{
	//[1]创建头结点 并 将头尾指针指向头结点
	q->front = q->rear = (QNodePtr)malloc(sizeof(QNode));

	if (!q->front)
	{
		return false;//内存分配失败
	}

	//[2]初始化链式队列头结点的指针域
	q->front->next = NULL;

	return true;
}

2.3求链队列的长度

注意：不传入链队列类型的指针，因为求长度时只访问 链队列类型中 的头指针

int QueueLength(LinkQueue q)

2.3.1算法步骤

（1）定义并初始化临时指针p指向首元结点
（2）定义并初始化计数器为0(因为没有排除空队的情况)
（3）循环记录链式队的结点个数

本质就是单链表求长度的操作

//2.求链队列的长度
//本质为带头结点的单链表的求长度操作
//注意：不传入链队列类型的指针，因为求长度时只访问 链队列类型中 的头指针
int QueueLength(LinkQueue q)
{
	//[0]判断链式队列是否存在
	if (q.front == NULL)
	{
		return 0;//链式队列不存在
	}

	//[1]定义并初始化临时指针p指向首元结点
	QNodePtr p = q.front->next;

	//[2]定义并初始化计数器为0(因为没有排除空队的情况)
	int count = 0;

	//[3]循环记录链式队的结点个数
	while (p!=NULL)
	{
		count++;

		p = p->next;
	}

	return count;
}

2.4链队列的入队（核心1）

注意：传入链队列类型的指针，因为入队时要修改 链队列类型中 的尾指针

bool EnQueue(LinkQueue* q, QElemType e)

2.4.1算法步骤

（1）创建并初始化新结点s
<1>初始化新结点的数据域
<2>初始化新结点的指针域为NULL
（2）将新结点插入到队尾并更新尾指针

本质就是带头结点的单链表的尾插法操作(注意尾指针的更新)
在这里插入图片描述
（1）
在这里插入图片描述
（2）
在这里插入图片描述

//3.链队列的入队
//本质为带头结点的单链表的尾插法操作(注意尾指针的更新)
//注意：传入链队列类型的指针，因为入队时要修改 链队列类型中 的尾指针
bool EnQueue(LinkQueue* q, QElemType e)
{
	//[0]判断链式队列是否存在
	if (q->front == NULL)
	{
		return false;
	}

	//[1]创建并初始化新结点s
	QNodePtr s = (QNodePtr)malloc(sizeof(QNode));
	
	if (!s)
	{
		return false;//内存分配失败
	}
	//<1>初始化新结点的数据域
	s->data = e;
	//<2>初始化新结点的指针域为NULL
	s->next = NULL;
	
	//[2]将新结点插入到队尾并更新尾指针
	q->rear->next = s;

	q->rear = s;

	return true;
}

2.5链队列的出队（核心2）

注意：传入链队列类型的指针，因为出队时要修改 链队列类型中 的头指针

bool DeQueue(LinkQueue* q, QElemType* e)

2.5.1算法步骤

（1）排除链式队列不存在 以及 为空队 的情况
（2）定义临时指针p指向待删除的首元结点
（3）弹出首元结点的数据
（4）更新头结点next域的指向
（5）注意链式队列中只存在一个结点时，需要更新尾指针（尾指针指向头结点）
（6）销毁待删除首元结点空间

本质为带头结点的单链表的删除首元结点操作（注意尾指针的更新）
在这里插入图片描述
（2）
在这里插入图片描述
（4）
在这里插入图片描述
（6）
在这里插入图片描述

//4.链队列的出队
//本质为带头结点的单链表的删除首元结点操作（注意尾指针的更新）
//注意：传入链队列类型的指针，因为出队时要修改 链队列类型中 的头指针
bool DeQueue(LinkQueue* q, QElemType* e)
{
	//[1]排除链式队列不存在 以及 为空队 的情况
	if (q->front == NULL||q->front == q->rear)
	{
		return false;
	}

	//[2]定义临时指针p指向待删除的首元结点
	QNodePtr p = q->front->next;

	//[3]弹出首元结点的数据
	*e = p->data;

	//[4]更新头结点next域的指向
	q->front->next = p->next;

	//[5]注意链式队列中只存在一个结点时，需要更新尾指针（尾指针指向头结点）
	if (q->rear == p)
	{
		q->rear = q->front;
	}

	//[6]销毁待删除首元结点空间
	free(p);

	return true;
}

2.6链队列的求队头元素

注意：不用传入链队列类型的指针，因为取队头元素时要不修改 链队列类型中 的头尾指针

bool GetHead(LinkQueue q,QElemType *e)

2.6.1算法步骤

（1）排除链式队列不存在 以及 为空队 的情况
（2）直接弹出首元结点的数据（即头结点next域结点空间中的数据）

在这里插入图片描述
空队时没有队头元素

//5.链队列的求队头元素
//注意：不用传入链队列类型的指针，因为取队头元素时要不修改 链队列类型中 的头尾指针
bool GetHead(LinkQueue q,QElemType *e)
{
	//[1]排除链式队列不存在 以及 为空队 的情况
	if (q.front == NULL || q.front == q.rear)
	{
		return false;
	}

	//[2]直接弹出首元结点的数据
	*e = q.front->next->data;
	return true;
}

2.7链队列的清空

注意：传入链队列类型的指针,因为释放完队中除头结点外所有空间后，需要重置 链队列类型中 的头尾指针

bool ClearQueue(LinkQueue* q)

2.7.1算法步骤

（1）定义两个临时指针n和m，
n指向待删除结点
m指向待删除结点的下一个结点
（2）初始化临时指针n指向首元结点
（3）循环删除除头结点以外的所有结点
与单链表一致（这里不能写(m!=NULL),因为在这条语句之前m并未初始化（是一个野指针）
<1>m 记录下一个结点
<2>释放当前结点
<3>n 移动到待删除结点
（4）注意清空完毕后保持空队的状态
将尾指针指向头结点（队空的标志）
确保 front->next 为空（保证头结点next域正确）

//6.链队列的清空
//本质为带头结点的单链表的清空操作（注意尾指针的更新）
bool ClearQueue(LinkQueue* q)
{
	//[0]判断链式队列是否存在
	if (q->front == NULL)
	{
		return false;//若不存在,则无法清空
	}

	//[1]定义两个临时指针n和m，
	// n指向待删除结点
	// m指向待删除结点的下一个结点
	QNodePtr n, m;
	
	//[2]初始化临时指针n指向首元结点
	n = q->front->next;

	//[3]循环删除除头结点以外的所有结点
	while (n != NULL) //与单链表一致（这里不能写(m!=NULL),因为在这条语句之前m并未初始化（是一个野指针）
	{
		m = n->next;// m 记录下一个结点

		free(n);//释放当前结点

		n = m;// n 移动到待删除结点
	}

	//[4]注意清空完毕后保持空队的状态
	q->rear = q->front;// 将尾指针指向头结点
	q->front->next = NULL;// 确保 front->next 为空
	return true;
}

2.8链队列的销毁

注意：传入链队列类型的指针,因为释放完队中所有空间后，需要置空 链队列类型中 的头尾指针

bool DestroyQueue(LinkQueue* q)

2.8.1算法步骤

（1）定义销毁指针p（作用：销毁待删除结点）
（2）循环删除链式队列中所有结点
<1> 头指针记录待删除结点的下一个结点
<2>释放当前待删除结点
<3> 将p指针指向下一个待删除结点
（3）销毁完毕后，置空链式队列的头尾指针

  • 本方法即单链表的销毁操作，但是要注意销毁完毕后置空头尾指针，避免悬挂指针问题
  • 还有一种方法，即p作为记录指针使用，用来记录待删除结点的下一个结点，这里不过多赘述，详见所有操作汇总
//7.0链队列的销毁(法一，定义临时销毁指针)
//注意：传入链队列类型的指针,因为释放完队中所有空间后，需要置空 链队列类型中 的头尾指针
bool DestroyQueue(LinkQueue* q)
{
	//[0]判断链式队列是否存在
	if (q->front == NULL)
	{
		return true;//若不存在，直接返回成功
	}

	//[1]定义销毁指针p（作用：销毁待删除结点）
	QNodePtr p=q->front;

	//[2]循环删除链式队列中所有结点
	while (p!= NULL)
	{
		q->front = p->next;//头指针记录待删除结点的下一个结点

		free(p);//释放当前待删除结点

		p = q->front;//将p指针指向下一个待删除结点
	}

	//[3]销毁完毕后，置空链式队列的头尾指针
	q->front = q->rear = NULL;
	return true;
}

2.9链队列的打印（从队头开始打印）

注意：不用传入链队列类型的指针,只进行访问操作，不进行修改操作

bool PrintQueue(LinkQueue q)

2.9.1算法步骤

（1）排除队列 为空队 的情况
（2）定义临时指针p指向首元结点
（3）循环打印链式队列中的元素

//8.链队列的打印（从队头开始打印）
//注意：不用传入链队列类型的指针,只进行访问操作，不进行修改操作
bool PrintQueue(LinkQueue q)
{
	//[0]排除链式队列不存在 
	if (q.front == NULL )
	{
		return false;
	}

	//[1]排除队列 为空队 的情况
	if (q.front == q.rear)
	{
		printf("空队！\n");
		return false;
	}
	//[2]定义临时指针p指向首元结点
	QNodePtr p = q.front->next;

	//[3]循环打印链式队列中的元素
	while (p != NULL)
	{
		printf("%d ", p->data);

		p = p->next;
	}

	return true;
}

2.10所有操作汇总：

//链式队列的实现（带头结点的 操作受限的单链表；包含头尾指针）
#include<stdio.h>
#include<stdlib.h>


#define bool int
#define true 1
#define false 0


typedef int QElemType;//队列元素类型


//链队列的结构类型定义
//<1>队列结点结构定义
typedef struct QNode
{
	QElemType data;//队结点数据域,用来存储队列元素
	struct QNode* next;//队结点指针域，用来指向下一个队结点
}QNode, *QNodePtr;
//QNode: 链队列结点类型,用来定义队结点
//QNodePtr: 链队列结点指针类型，用来定义队结点指针



//<2>队列链式定义
typedef struct
{
	QNodePtr front, rear;//定义链队的头指针，尾指针
}LinkQueue;
//LinkQueue:通过LinkQueue定义链队列类型；通过 定义出的链队列类型 访问队列的头指针，尾指针


//1.链队列的初始化
//注意：传入链队列类型的指针，因为初始化时要修改 链队列类型中 的头尾指针
bool InitQueue(LinkQueue * q)
{
	//[1]创建头结点 并 将头尾指针指向头结点
	q->front = q->rear = (QNodePtr)malloc(sizeof(QNode));

	if (!q->front)
	{
		return false;//内存分配失败
	}

	//[2]初始化链式队列头结点的指针域
	q->front->next = NULL;

	return true;
}



//2.求链队列的长度
//本质为带头结点的单链表的求长度操作
//注意：不传入链队列类型的指针，因为求长度时只访问 链队列类型中 的头指针
int QueueLength(LinkQueue q)
{
	//[0]判断链式队列是否存在
	if (q.front == NULL)
	{
		return 0;//链式队列不存在
	}

	//[1]定义并初始化临时指针p指向首元结点
	QNodePtr p = q.front->next;

	//[2]定义并初始化计数器为0(因为没有排除空队的情况)
	int count = 0;

	//[3]循环记录链式队的结点个数
	while (p!=NULL)
	{
		count++;

		p = p->next;
	}

	return count;
}



//3.链队列的入队
//本质为带头结点的单链表的尾插法操作(注意尾指针的更新)
//注意：传入链队列类型的指针，因为入队时要修改 链队列类型中 的尾指针
bool EnQueue(LinkQueue* q, QElemType e)
{
	//[0]判断链式队列是否存在
	if (q->front == NULL)
	{
		return false;
	}

	//[1]创建并初始化新结点s
	QNodePtr s = (QNodePtr)malloc(sizeof(QNode));
	
	if (!s)
	{
		return false;//内存分配失败
	}
	//<1>初始化新结点的数据域
	s->data = e;
	//<2>初始化新结点的指针域为NULL
	s->next = NULL;
	
	//[2]将新结点插入到队尾并更新尾指针
	q->rear->next = s;

	q->rear = s;

	return true;
}


//4.链队列的出队
//本质为带头结点的单链表的删除首元结点操作（注意尾指针的更新）
//注意：传入链队列类型的指针，因为出队时要修改 链队列类型中 的头指针
bool DeQueue(LinkQueue* q, QElemType* e)
{
	//[1]排除链式队列不存在 以及 为空队 的情况
	if (q->front == NULL||q->front == q->rear)
	{
		return false;
	}

	//[2]定义临时指针p指向待删除的首元结点
	QNodePtr p = q->front->next;

	//[3]弹出首元结点的数据
	*e = p->data;

	//[4]更新头结点next域的指向
	q->front->next = p->next;

	//[5]注意链式队列中只存在一个结点时，需要更新尾指针（尾指针指向头结点）
	if (q->rear == p)
	{
		q->rear = q->front;
	}

	//[6]销毁待删除首元结点空间
	free(p);

	return true;
}




//5.链队列的求队头元素
//注意：不用传入链队列类型的指针，因为取队头元素时要不修改 链队列类型中 的头尾指针
bool GetHead(LinkQueue q,QElemType *e)
{
	//[1]排除链式队列不存在 以及 为空队 的情况
	if (q.front == NULL || q.front == q.rear)
	{
		return false;
	}

	//[2]直接弹出首元结点的数据
	*e = q.front->next->data;
	return true;
}




//6.链队列的清空
//本质为带头结点的单链表的清空操作（注意尾指针的更新）
bool ClearQueue(LinkQueue* q)
{
	//[0]判断链式队列是否存在
	if (q->front == NULL)
	{
		return false;//若不存在,则无法清空
	}

	//[1]定义两个临时指针n和m，
	// n指向待删除结点
	// m指向待删除结点的下一个结点
	QNodePtr n, m;
	
	//[2]初始化临时指针n指向首元结点
	n = q->front->next;

	//[3]循环删除除头结点以外的所有结点
	while (n != NULL) //与单链表一致（这里不能写(m!=NULL),因为在这条语句之前m并未初始化（是一个野指针）
	{
		m = n->next;// m 记录下一个结点

		free(n);//释放当前结点

		n = m;// n 移动到待删除结点
	}

	//[4]注意清空完毕后保持空队的状态
	q->rear = q->front;// 将尾指针指向头结点
	q->front->next = NULL;// 确保 front->next 为空
	return true;
}






//7.0链队列的销毁(法一，定义临时销毁指针)
//注意：传入链队列类型的指针,因为释放完队中所有空间后，需要置空 链队列类型中 的头尾指针
bool DestroyQueue(LinkQueue* q)
{
	//[0]判断链式队列是否存在
	if (q->front == NULL)
	{
		return true;//若不存在，直接返回成功
	}

	//[1]定义销毁指针p（作用：销毁待删除结点）
	QNodePtr p=q->front;

	//[2]循环删除链式队列中所有结点
	while (p!= NULL)
	{
		q->front = p->next;//头指针记录待删除结点的下一个结点

		free(p);//释放当前待删除结点

		p = q->front;//将p指针指向下一个待删除结点
	}

	//[3]销毁完毕后，置空链式队列的头尾指针
	q->front = q->rear = NULL;
	return true;
}


//7.1链队列的销毁(法二，定义临时记录指针)
//注意：传入链队列类型的指针,因为释放完队中所有空间后，需要置空 链队列类型中 的头尾指针
bool DestroyQueue1(LinkQueue* q)
{
	//[0]判断链式队列是否存在
	if (q->front == NULL)
	{
		return true;//若不存在，直接返回成功
	}

	//[1]定义记录指针p（作用：记录待删除结点下一个结点）
	QNodePtr p;

	//[2]循环删除链式队列中所有结点
	while (q->front != NULL)
	{
		p = q->front->next;//p记录待删除结点下一个结点

		free(q->front);//释放待删除结点

		q->front = p;//将头指针指向下一个待删除结点
	}

	//[3]销毁完毕后，置空链式队列的头尾指针
	q->front = q->rear = NULL;
	return true;
}


//8.链队列的打印（从队头开始打印）
//注意：不用传入链队列类型的指针,只进行访问操作，不进行修改操作
bool PrintQueue(LinkQueue q)
{
	//[0]排除链式队列不存在 
	if (q.front == NULL )
	{
		return false;
	}

	//[1]排除队列 为空队 的情况
	if (q.front == q.rear)
	{
		printf("空队！\n");
		return false;
	}
	//[2]定义临时指针p指向首元结点
	QNodePtr p = q.front->next;

	//[3]循环打印链式队列中的元素
	while (p != NULL)
	{
		printf("%d ", p->data);

		p = p->next;
	}

	return true;
}


// 测试代码
int main() 
{
	LinkQueue q;//定义链式队列q
	QElemType e;

	// 初始化队列
	if (InitQueue(&q)) 
	{
		printf("链式队列初始化成功。\n");
	}

	// 入队
	for (int i = 1; i <= 5; i++) 
	{
		EnQueue(&q, i);
	}
	printf("输出入队后的元素: ");
	PrintQueue(q);

	// 获取队头元素
	if (GetHead(q, &e)) 
	{
		printf("队头元素：%d\n", e);
	}

	// 出队
	if (DeQueue(&q, &e)) 
	{
		printf("出队元素: %d\n", e);
	}
	printf("出队后的队列元素: ");
	PrintQueue(q);

	// 队列长度
	printf("队列长度: %d\n", QueueLength(q));

	// 清空队列
	if (ClearQueue(&q)) 
	{
		printf("队列清空成功！\n");
	}

	// 再次打印队列
	printf("清空后的队列: ");
	PrintQueue(q);


	// 销毁队列
	if (DestroyQueue(&q)) 
	{
		printf("队列销毁成功！\n");
	}

	return 0;
}

在这里插入图片描述

float_com
关注
  • 7
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链式队列实现
一个正在学习C/C++的博主
07-29 442
队列是一种线性数据结构，它遵循先进先出的原则。在队列中，新元素被添加到队列的末尾，而旧元素从队列的前端移除。队列的主要操作包括入队（enqueue）、出队（dequeue）等。int data;} Node;// 队列头指针Node* rear;// 队列尾指针} Queue;本文介绍了如何使用 C 语言实现链式队列。通过定义节点结构和队列结构，并实现基本的操作函数，我们能够有效地管理队列中的元素。链式队列由于其动态分配的特点，在处理不确定大小的数据集合时非常有用。
C++数据结构之链式队列实现
09-20
以下是对链式队列实现的详细解释： ### 1. 链式队列的基本概念 队列是一种线性数据结构，其操作特性是只允许在队列的一端（称为队尾）进行插入操作（入队），而在另一端（称为队头）进行删除操作（出队）。链式...
链式队列实现(c语言)
lixin203171613的博客
11-27 1490
队列是一个线性的数据结构，这个数据结构只从一端进行插入，另一端进行删除，禁止直接访问除这两端以外的一切数据。如图所示，队列就像一个管道一样，从一端输入，一端输出，先输入的就先输出。
链式队列的实现
PingBryant的博客
09-07 2452
链式队列的概念 1.1 链式队列的定义 链式队列是基于单链表（带头结点）的存储表示实现的队列。 1.2 链式队列中各元素的逻辑及存储关系 链式队列可以采用单链表作为其存储表示，因此，可以在链式队列的声明中用单链表定义它的存储空间。 链式队列的队头指针指向单链表的第一个结点，队尾指针指向单链表的最后一个结点。 注：链式队列的队头元素存放在单链表的第一个结点内，若要从队列中退出一个元素，必须从单链表中删去第一个结点，而存放着新元素的结点应插在队列的队尾，即单链表的最后一个结点后面，这个新节点将成为新的
数据结构学习【队列 链式结构 C++】链式队列实现
toro180的博客
01-11 510
数据结构链式队列c++实现
C语言实现链式队列
weixin_42937740的博客
03-11 704
链式队列（Linked Queue）是一种基于链表实现的队列数据结构。本文我们就分模块实现一下，然后编写一个测试代码进行测试
C++链式队列实现
Alexon Xu的博客
01-17 764
链式队列具有内存动态分配，内存利用率高的特点，在一些无法预先估计所需队列大小的场合使用链式队列是一个十分好的选择。下面是我最近学习链式队列的代码。注意这里的头结点不存储数据。 首先，要实现链式队列，首先要构造相应的数据结构，这里考虑使用两个指针分别指向队列的队头和队尾，队列使用单链表实现。代码如下：#include #include #include
【数据结构】C语言实现队列（链式队列）
SHLYYY
05-17 1196
结点定义：因为使用单链表实现队列，所以队列结点与单链表结点相同。} QNode;int size;} Queue;我们使用size变量记录队列中的元素个数，这样可以直接返回该值，但在插入和删除时要维护该size的值。assert(pq);链式队列的实现本质上是对单链表进行操作。入队和出队分别对应单链表的尾插和头删。因为是无头单向非循环的单链表，因此尾插时需要对空链表单独处理。又因为我们需要维护尾指针，因此头删时，删除最后一个元素时还需要对尾指针单独处理。这些在上面代码中都有所体现。
数据结构——链式队列
qq_59708493的博客
01-26 1276
6.链式队列功能实现 用数组实现队列的缺点： 用数组实现队列时，如果不移动，随着数据的不断读写，会出现假满队列的情况。即尾数组已满但头数组还是空的。循环队列也是一种数组，只是它在逻辑上把数组的头和尾相连，形成循环队列，当数组尾满的时候，要判断数组头是否为空，不为空继续存放数据，可以有效的利用资源。但是用循环队列有个小麻烦，不好判断数列是为空还是为满； 而链试队列就不存在上面的问题。“循环队列”最大优点就是节省空间和少分配空间，而链队列多了一点点地址存储开销。 比较 0.链式队列类的定义 #includ
循环顺序队列与链式队列实现
chocolate的博客
07-10 896
队列是一种先进先出的数据结构，分顺序存储结构和链式存储结构两种。顺序存储结构中广泛使用的是循环队列，也是队列使用中最多的一种。下面将分别实现这两种队列的基本操作。 #include<iostream> using namespace std; const int MaxSize = 100; class queue { public: queue() { front = 0...
十、数据结构——链式队列
qq_57737603的博客
07-24 3148
本篇文章详细介绍了数据结构中的链式队列。链式队列是一种通过链表实现的队列，具有动态增长和高效的特性。文章首先定义了链式队列的节点结构和队列结构，然后详细讲解了链式队列的基本操作，包括初始化队列、判断队列是否为空、入队操作、出队操作和获取队列长度。示例代码带有详细注释，演示了入队、出队、打印队列和获取队列长度的操作，帮助读者更好地理解链式队列的使用。链式队列适用于动态管理数据的场景，通过本文，读者可以掌握链式队列的概念和操作，并了解其在数据结构中的重要应用。文章还提醒读者注意动态内存管理和异常处理。
liunx多线程_生产者与消费者模型_链式队列实现.zip|多线程_生产者与消费者模型_链式队列实现.zip
12-02
fun.cpp中主要为队列读写功能的实现 struct Queue *init_queue();//初始化 void en_queue(struct Queue *q,void* data,size_t len);//向队列的尾部插入一个数据。 void de_queue(struct Queue *q);//删除头部一个...
链式队列实现例子
06-23
JAVA语言实现数据的链式结构 分享下挣挣人气
java队列实现方法(顺序队列,链式队列,循环队列)
08-28
Java 队列实现方法 Java 队列是一种常用的数据结构，用于实现先进先出（FIFO）或后进先出（LIFO）的操作。Java 中提供了多种实现队列的方法，包括顺序队列、链式队列和循环队列等。下面我们将详细介绍每种队列的...
数据结构
2301_80184169的博客
08-28 552
4.执行代码,复现段错误,产生包含出错信息的core文件(检查core文件是否生成)3.ulimit -c unlimited 不限制core文件的生成的大小。使用这种方法能够很好的解决段错误，在纠正和优化代码时效率显著提升。1.首先按照如下的方法配置Ubuntu，允许生成core文件。5.gdb a.out core 查看段错误产生的位置。2.重新编译代码并加入-g选项(允许进行GDB调试)
Python 数据结构：字典与集合的详细对比
08-31 502
在 Python 编程语言中，字典（dictionary）和集合（set）是两种非常核心且功能强大的数据结构。它们在处理数据时扮演着不同的角色，了解它们的区别对于编写高效、清晰的代码至关重要。本文将详细介绍字典和集合的特点、用法以及何时使用它们。
【数据结构】队列(Queue)
xiaochuan_bsj的博客
08-28 857
数组，双链表实现队列，附完整代码
数据结构（邓俊辉）学习笔记】串 10——BM_BC算法：坏字符
weixin_44399845的博客
08-28 856
BM_BC算法：坏字符
【手撕数据结构】二叉树的性质
最新发布
apple_61439616的博客
08-31 243
目录叶子节点和边的性质概念小试牛刀 叶子节点和边的性质 概念 可以看到度为0的节点如F没有边，度为1的节点如C有一条边，而度为2的节点如B有两条边。 那么设度为2的节点为a个，度为1的节点为b个。二叉树边 = 2a+b 另⼀⽅⾯，由于共有 a+b+c 个节点，所以边数等于 a+b+c-1 这里-1是因为： 综合上面两个公式，我们2a+b = a + b + c - 1; 推出c = a+1(c为度为0节点，a为度为2节点) 所以叶子结点n0 = n2 + 1; 小试牛刀 这道题已经告诉了我们度
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值