数据结构--队列的实现（C语言）

最新推荐文章于 2022-10-10 09:20:46 发布
最新推荐文章于 2022-10-10 09:20:46 发布
阅读量296 收藏 3
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c语言 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/COOL_jack/article/details/117990943
版权

目录

声明

以下内容仅供学习，如有侵权，联系作者删除。
参考文献：王道考研系列数据结构、B站up主：C语言技术网
链接: C语言技术网

一 队列的基本概念

1.队列的基本定义

队列（Queue）：也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。
队头（Front）：允许删除的一端。
队尾（Rear）：允许插入的一端。
空队列：不含任何元素的空表。

2.队列的基本操作

由以下代码给出。

二 队列的顺序存储结构

牺牲一个存储单元的方案：
int front;	//	队列的头指针
int rear;	//	队列的尾指针，指向队尾的下一个元素
初始化：front = rear = 0;
队空：front == rear
队满：((rear+1) % MAXSIZE) == front
队长：(rear - front +MAXSIZE) % MAXSIZE

1.循环队列代码实现（C语言）

/*
 * 程序名：seqqueue1.c，此程序演示循环队列的数组实现，队尾指针指向队尾的下一个元素，没有length的辅助变量。
 * 作者：jack 日期：20210617
 * 参考作者：C语言技术网(www.freecplus.net), B站UP主：C语言技术网
*/
#include <stdio.h>
#include <string.h>

#define MAXSIZE 10     // 循环队列的最大长度，最多可以存放MAXSIZE-1个元素

typedef int ElemType;  // 自定义队列的数据元素为整数

typedef struct Queue
{
	ElemType data[MAXSIZE];  // 用数组存储循环队列中的元素
	int front;               // 队列的头指针
	int rear;				 // 队列的尾指针，指向队尾的下一个元素
}SeqQueue, *PSeqQueue;

// 循环队列QQ的初始化操作
void InitQueue(PSeqQueue QQ);

// 清空循环队列
void ClearQueue(PSeqQueue QQ);

// 销毁循环队列QQ。
void DestroyQueue(PSeqQueue QQ);

// 求循环队列的长度，返回值：>=0-队列QQ元素的个数
int LengthQueue(PSeqQueue QQ);

// 判断循环队列是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PSeqQueue QQ);   

// 判断循环队列是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqQueue QQ);

// 元素入队，返回值：0-失败；1-成功。
int InQueue(PSeqQueue QQ, ElemType *ee);

// 元素出队，返回值：0-失败；1-成功。
int OutQueue(PSeqQueue QQ, ElemType *ee);

// 打印循环队列中全部的元素。
void PrintQueue(PSeqQueue QQ);                    

// 获取队头元素，返回值：0-失败；1-成功。
// 只查看队头元素的值，元素不出队。
int GetHead(PSeqQueue QQ, ElemType *ee);

int main()
{
	SeqQueue Q;     // 创建循环队列

	InitQueue(&Q);  // 初始化循环队列

	ElemType e;     // 创建一个数据元素
	printf("元素（1、2、3、4、5）入队。\n");
	e=1;  InQueue(&Q, &e);
	e=2;  InQueue(&Q, &e);
	e=3;  InQueue(&Q, &e);
	e=4;  InQueue(&Q, &e);
	e=5;  InQueue(&Q, &e);
	printf("队列的长度是%d\n",LengthQueue(&Q));

	PrintQueue(&Q);

	if (OutQueue(&Q,&e)==1)  printf("出队的元素值为%d\n",e);
	if (OutQueue(&Q,&e)==1)  printf("出队的元素值为%d\n",e);
	if (OutQueue(&Q,&e)==1)  printf("出队的元素值为%d\n",e);
	if (OutQueue(&Q,&e)==1)  printf("出队的元素值为%d\n",e);
	if (OutQueue(&Q,&e)==1)  printf("出队的元素值为%d\n",e);

	printf("队列的长度是%d\n",LengthQueue(&Q));
	PrintQueue(&Q);

	printf("元素（11、12、13、14、15）入队。\n");
	e=11;  InQueue(&Q, &e);
	e=12;  InQueue(&Q, &e);
	e=13;  InQueue(&Q, &e);
	e=14;  InQueue(&Q, &e);
	e=15;  InQueue(&Q, &e);

	printf("队列的长度是%d\n",LengthQueue(&Q));

	PrintQueue(&Q);

	// 只查看队头元素的值，元素不出队。
	if (GetHead(&Q,&e)==1)  printf("队头的元素值为%d\n",e);

	return 0;
}

// 初始化循环队列
void InitQueue(PSeqQueue QQ)
{
	ClearQueue(QQ);
}

// 清空循环队列
void ClearQueue(PSeqQueue QQ)
{
	if (QQ == NULL)  return;  // 检查空指针

	memset(QQ->data, 0, sizeof(ElemType)*MAXSIZE);  // 数组元素清零
	QQ->front = QQ->rear = 0;
}

// 销毁循环队列QQ。
void DestroyQueue(PSeqQueue QQ)
{
	// 静态循环队列无需释放内存，不需要销毁操作

	ClearQueue(QQ); // 清空循环队列
}

// 求循环队列的长度，返回值：>=0-队列QQ元素的个数
int LengthQueue(PSeqQueue QQ)
{
	if (QQ == NULL)  return 0;  // 检查空指针

	return (QQ->rear - QQ->front + MAXSIZE)%MAXSIZE;
}

// 判断循环队列是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PSeqQueue QQ)
{
	if (QQ == NULL)  return 0;  // 检查空指针

	if (QQ->front == QQ->rear) return 1;

	return 0;
}

// 判断循环队列是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqQueue QQ)
{
	if (QQ == NULL)  return 0;  // 检查空指针

	if( ((QQ->rear+1)%MAXSIZE) == QQ->front )  return 1;

	return 0;
}

// 元素入队，返回值：0-失败；1-成功
int InQueue(PSeqQueue QQ, ElemType *ee)
{
	if ((QQ == NULL) || (ee == NULL))  return 0;  // 检查空指针
	if (IsFull(QQ) == 1)  { printf("循环队列已满，不能插入。\n"); return 0; }
	
	memcpy(QQ->data+QQ->rear, ee, sizeof(ElemType));
	QQ->rear = (QQ->rear+1)%MAXSIZE;
	return 1;
}

// 元素出队，返回值：0-失败；1-成功
int OutQueue(PSeqQueue QQ, ElemType *ee)
{
	if ((QQ == NULL) || (ee == NULL))  return 0;  // 检查空指针
	if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return 0; }

	memcpy(ee, QQ->data+QQ->front, sizeof(ElemType));  // 采用指针运算
	QQ->front = (QQ->front+1)%MAXSIZE;  // 队列头指针后移
	return 1;
}

// 打印循环队列中全部的元素
void PrintQueue(PSeqQueue QQ)
{
	if (QQ == NULL)  return;  // 检查空指针
	if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return; }
	int kk;
	for (kk = 0; kk < LengthQueue(QQ); kk++)
	{
		// 用数组的下标访问。
		printf("data[%d],value=%d\n",(QQ->front+kk)%MAXSIZE,QQ->data[(QQ->front+kk)%MAXSIZE]);     

		// 采用指针运算也可以。
		// printf("data[%d],value=%d\n",(QQ->front+kk)%MAXSIZE,*(QQ->data+(QQ->front+kk)%MAXSIZE));
	}
}

// 获取队头元素，返回值：0-失败；1-成功
// 只查看队头元素的值，元素不出队
int GetHead(PSeqQueue QQ, ElemType *ee)
{
	if ( (QQ == NULL) || (ee == NULL) ) return 0;   // 检查空指针
	if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return 0; }

	memcpy(ee,&QQ->data[QQ->front],sizeof(ElemType));  // 用数组的下标访问
	// memcpy(ee,QQ->data+QQ->front,sizeof(ElemType));    // 采用指针运算
	return 1;
}

顺序存储运行结果如下：

在这里插入图片描述

三 队列的链式存储结构

1.代码实现（C语言）

/*
 * 程序名：linkqueue1.c，此程序演示队列的链表实现（带头结点）
 * 作者：jack 日期：20210617
 * 参考作者：C语言技术网(www.freecplus.net), B站UP主：C语言技术网
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAXSIZE 10

typedef int ElemType;

typedef struct LNode
{
	ElemType data;
	struct LNode *next;
}LNode;

typedef struct 
{
	LNode *front, *rear;
}LinkQueue, *PLinkQueue;

// 队列QQ的初始化操作
int InitQueue(PLinkQueue QQ);

// 清空队列
void ClearQueue(PLinkQueue QQ);

// 销毁队列QQ。
void DestroyQueue(PLinkQueue QQ);

// 求队列的长度，返回值：>=0-队列QQ元素的个数
int LengthQueue(PLinkQueue QQ);

// 判断队列是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PLinkQueue QQ);   

// 判断队列是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PLinkQueue QQ);

// 元素入队，返回值：0-失败；1-成功。
int InQueue(PLinkQueue QQ, ElemType *ee);

// 元素出队，返回值：0-失败；1-成功。
int OutQueue(PLinkQueue QQ, ElemType *ee);

// 打印队列中全部的元素。
void PrintQueue(PLinkQueue QQ);                    

// 获取队头元素，返回值：0-失败；1-成功。
// 只查看队头元素的值，元素不出队。
int GetHead(PLinkQueue QQ, ElemType *ee);

int main()
{
	LinkQueue Q;  // 创建队列
	memset(&Q,0,sizeof(LinkQueue));
	InitQueue(&Q);

	ElemType e;     // 创建一个数据元素
	printf("元素（1、2、3、4、5）入队。\n");
	e=1;  InQueue(&Q, &e);
	e=2;  InQueue(&Q, &e);
	e=3;  InQueue(&Q, &e);
	e=4;  InQueue(&Q, &e);
	e=5;  InQueue(&Q, &e);
	printf("队列的长度是%d\n",LengthQueue(&Q));

	PrintQueue(&Q);

	if (OutQueue(&Q,&e)==1)  printf("出队的元素值为%d\n",e);
	if (OutQueue(&Q,&e)==1)  printf("出队的元素值为%d\n",e);
	if (OutQueue(&Q,&e)==1)  printf("出队的元素值为%d\n",e);
	if (OutQueue(&Q,&e)==1)  printf("出队的元素值为%d\n",e);
	if (OutQueue(&Q,&e)==1)  printf("出队的元素值为%d\n",e);

	printf("队列的长度是%d\n",LengthQueue(&Q));
	PrintQueue(&Q);

	printf("元素（11、12、13、14、15）入队。\n");
	e=11;  InQueue(&Q, &e);
	e=12;  InQueue(&Q, &e);
	e=13;  InQueue(&Q, &e);
	e=14;  InQueue(&Q, &e);
	e=15;  InQueue(&Q, &e);

	printf("队列的长度是%d\n",LengthQueue(&Q));

	PrintQueue(&Q);

	// 只查看队头元素的值，元素不出队。
	if (GetHead(&Q,&e)==1)  printf("队头的元素值为%d\n",e);

	return 0;
}

// 初始化队列，返回值：0-失败；1-成功
int InitQueue(PLinkQueue QQ)
{
	LNode *head = (LNode *)malloc(sizeof(LNode));  // 分配头结点
	if (head == NULL)  return 0;			// 内存不足，返回失败

	head->next = NULL;		// 头结点的下一结点暂时不存在，置空
	QQ->front = QQ->rear = head;
	return 1;
}

// 清空队列
void ClearQueue(PLinkQueue QQ)
{
	if (QQ == NULL)  return;  // 检查空指针
	if (QQ->front == NULL) { printf("队列QQ未初始化。\n"); return; } // 队列未初始化
	// 清空队列QQ是指释放链表全部的数据结点，但保留头结点
	LNode *tmp = QQ->front->next;
	LNode *tmpnext;

	while(tmp != NULL)
	{
		tmpnext = tmp->next;  // tmpnext保存下一结点的地址
		free(tmp);			  // 释放当前结点。
		tmp = tmpnext;		  // tmp指针移动到下一结点
	}
	QQ->rear=QQ->front;       // 尾指针指向头结点
	QQ->front->next=NULL;
}

// 销毁队列QQ。
void DestroyQueue(PLinkQueue QQ)
{
	if (QQ == NULL)  return;  // 检查空指针
	if (QQ->front == NULL) { printf("队列QQ未初始化。\n"); return; } // 队列未初始化
	// 清空队列QQ是指释放链表全部的数据结点，但保留头结点
	LNode *tmp = QQ->front;
	LNode *tmpnext;

	while(tmp != NULL)
	{
		tmpnext = tmp->next;  // tmpnext保存下一结点的地址
		free(tmp);			  // 释放当前结点。
		tmp = tmpnext;		  // tmp指针移动到下一结点
	}
	QQ->rear=QQ->front=NULL;  // 防止野指针
	return;
}

// 求队列的长度，返回值：>=0-队列QQ元素的个数
int LengthQueue(PLinkQueue QQ)
{
	if (QQ == NULL)  return 0;	    // 检查空指针
	if (QQ->front == NULL) { printf("队列QQ未初始化。\n"); return 0; } // 队列未初始化

	LNode *tmp = QQ->front->next;  // 头结点不算，从第1个结点开始
	int length = 0;
	while(tmp != NULL)
	{
		length++;
		tmp = tmp->next;
	}
	return length;
}

// 判断队列是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PLinkQueue QQ)
{
	if (QQ == NULL)  return 0;  // 检查空指针
	if (QQ->front == NULL) { printf("队列QQ未初始化。\n"); return 0; } // 队列未初始化

	if (QQ->front->next == NULL) return 1;

	return 0;
}

// 判断队列是否已满，链式队列不存在队满的说法
int IsFull(PLinkQueue QQ)
{
	if (QQ == NULL)  return 0;  // 检查空指针

	return 0;
}

// 元素入队，返回值：0-失败；1-成功
int InQueue(PLinkQueue QQ, ElemType *ee)
{
	if ((QQ == NULL) || (ee == NULL))  return 0;  // 检查空指针
	if (QQ->front == NULL) { printf("队列QQ未初始化。\n"); return 0; } // 队列未初始化
	
	LNode *tmp = (LNode *)malloc(sizeof(LNode));
	if (tmp == NULL)  return 0;

	memcpy(&tmp->data, ee, sizeof(ElemType));
	tmp->next = NULL;
	
	QQ->rear->next = tmp;
	QQ->rear = tmp;
	return 1;
}

// 元素出队，返回值：0-失败；1-成功
int OutQueue(PLinkQueue QQ, ElemType *ee)
{
	if ((QQ == NULL) || (ee == NULL))  return 0;  // 检查空指针
	if (QQ->front == NULL) { printf("队列QQ未初始化。\n"); return 0; } // 队列未初始化
	if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return 0; }

	LNode *tmp = QQ->front->next;
	memcpy(ee, &tmp->data, sizeof(ElemType));  // 采用指针运算
	QQ->front->next = tmp->next;  // 队列头指针后移

	// 如果出队的是最后一个结点。
	if (QQ->rear==tmp) QQ->rear=QQ->front;

	free(tmp);

	return 1;
}

// 打印队列中全部的元素
void PrintQueue(PLinkQueue QQ)
{
	if (QQ == NULL)  return;  // 检查空指针
	if (QQ->front == NULL) { printf("队列QQ未初始化。\n"); return; } // 队列未初始化

	LNode *pp = QQ->front->next;
	while(pp != NULL)
	{
		printf("%-3d", pp->data);  // 如果元素ee为结构体，这行代码要修改
		pp = pp->next;
	}
	printf("\n");
}

// 获取队头元素，返回值：0-失败；1-成功
// 只查看队头元素的值，元素不出队
int GetHead(PLinkQueue QQ, ElemType *ee)
{
	if ( (QQ == NULL) || (ee == NULL) ) return 0;   // 检查空指针
	if (QQ->front == NULL) { printf("队列QQ未初始化。\n"); return 0; } // 队列未初始化
	if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return 0; }

	memcpy(ee,&QQ->front->next->data,sizeof(ElemType));
	
	return 1;
}

链式存储运行结果如下：
在这里插入图片描述

四 小结

1.栈和队列都已经介绍完毕，接下来介绍栈和队列的应用。

jack学编程
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
队列线性表的c语言实现方式 seqqueue.h 和 seqqueue.c
chen1540524015的博客
07-09 2046
.h 文件#ifndef _SEQ_QUEUE_H_ #define _SEQ_QUEUE_H_ #include <stdio.h> #include <stdlib.h> #include <string.h>typedef void Queue;#ifndef bool #define bool int #define true 1 #define false 0 #endifQueue* S
队列的基本操作c语言代码大全,数据结构――队列（循环队列）的基本操作（实现链队列逐一取出c语言代码）...
weixin_36221113的博客
05-17 229
队列队列是一种重要的线性结构，与栈相同也需要顺序表或者链表作为基础。队列是先进先出(first in first out)FIFO的线性表。所有数据从队列的一端进入，从另一端离开。队列中允许插入数据一端称队尾(rear)，允许数据离开的一端称队头(front)既可以是顺序表也可以是链表创建一个空队列入队列操作出队列操作实例分析/***********************************...
队列的操作实验（数据结构）
木头博客
10-10 4362
本文为数据结构队列的操作实验，益掌握队列存储结构的表示和实现方法，队列的入队和出队等基本操作的算法实现，及编程实现对循环链队列的入队和出队操作。
C语言-队列queue顺序存储和链式存储
代码黑洞
04-03 350
理解队列 队列是一种特殊的先进先出的线性表，队列的操作只能在队头和队尾操作，即队尾插入数据，队头取数据。 队列的顺序存储 队列的顺序存储类似线性表的顺序存储 //SeqQueue.h #pragma once typedef void SeqQueue; //创建队列 SeqQueue* SeqQueue_Create(int capacity...
c语言-顺序队列
Xiaoweidumpb
11-29 187
#include"SeqQueue.h" void main(){ Queue Q; IniQueue(&Q); ElemType v; for(int i=1;i<=5;++i){ EnQueue(&Q,i); } ShowQueue(&Q); DeQueue(&Q); ShowQueue(&Q); GetHead(&Q,&v); prin
数据结构-循环队列-C语言实现循环队列-数据结构学习
最新发布
05-27
C语言实现的数据结构中的循环队列 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件，以及测试用的main.c文件 用于C语言以及数据结构的学习 循环队列的.c和.h文件实现了以下功能： 创建循环队列 入队列...
C语言-数据结构-栈队列实现
03-10
本主题关注的是如何使用C语言来实现数据结构中的栈和队列，这是两种基础但非常重要的抽象数据类型（ADT）。 栈（Stack）是具有后进先出（LIFO）特性的数据结构。它类似于一个堆叠的盘子，最新的元素被放在顶部，...
数据结构-队列的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 队列的部分实现代码，详细介绍参考数据结构--队列的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
c语言数据结构-栈队列数组完美版资料.ppt
11-14
本资源摘要信息主要关于C语言数据结构中的栈、队列和数组三个基本概念。...栈、队列和数组是C语言数据结构中的三个基本概念，栈的实现需要考虑到实际情况，栈的应用非常广泛，栈的优点和缺点需要被正确地考虑。
C语言数据结构链表队列的实现
12-31
C语言数据结构链表队列的实现 1.写在前面 　队列是一种和栈相反的，遵循先进先出原则的线性表。 　本代码是严蔚敏教授的数据结构书上面的伪代码的C语言实现代码。 　分解代码没有包含在内的代码如下： #include #...
数据结构 队列详解和代码演示
菜鸟心声：学的不仅是技术，更是梦想！
12-05 523
数据结构 队列和链表详解和代码演示 1.队列 常用数据结构之一，队列是一个有序列表，可以用数组或是链表来实现 遵循先进先出的原则，双端队列可以两头进和两头出，现在的栈，便是使用双端队列Deque来实现
数据结构——循环队列和链队——c语言代码实现
❀雾里看花花里看雾❀
07-11 510
嗨喽，csdn的小伙伴们，我又来啦~ 这一周因为生产实习，我可谓是被生活磨平了棱角呢！ 本来还想瘦个几斤对吧，结果跑步不想跑，跳绳不想跳，买了一个瑜伽垫觉得睡着比床还舒服，是我本人了哈哈哈哈哈，果然生产队的????都不敢这么歇！ 今天周日对吧，本来应该是休息的时间 生产实习之外的自我学习时间，我！！！我开始追综艺了！！！罪恶啊！！！但是但是但是《心动的信号》怎么可以这么甜哈哈哈哈哈，从第一季追到第四季，是我本人了！！！太罪恶了！！ 最近还在磕CP，《你微笑时很美》哈哈哈许凯和程潇，nice啊！！话说我怎么喜
【数据结构】队列的基本操作（C语言版）
上上谦. 的博客
04-03 6373
文章目录前言前情回顾 前言 在学过 “栈” 这个数据结构之后，本篇博客将继续介绍另一个常见的数据结构 ——— “队列”。本篇还将继续带来几道OJ题对栈和队列进行巩固。 前情回顾 栈的基本操作 + OJ练习 （C语言版） ...
数据结构之队（循环队列）的基本操作和实现
BaoITcore的博客
11-13 6196
引言：这篇文章的末尾有完整的实现代码，前面还是先进行分步实现，即我们探讨一下为什么要这样做，以及我们应该怎么样一步一步的实现循环队列。 目录 一、队列的概念 二、队的基本操作 三、对于队的操作，了解若干个规则 四、对队列的基本操作进行实现 （1）、队的初始化 （2）、判断队是否为空 （3）、求队列的长度 （4）、入队操作 （5）、出队操作 （6）、求队首元素 （7）、主函数 （8）、运行结果 （9）、完整代码 总结 一、队列的概念 我们可以把队列理解...
队列的链表实现（C语言）
Jeaten
07-29 930
队列 为了阅读方便和保持内容的完整性，这部分使用了队列的数组实现（C语言）中的内容 队列是一种允许在一端（队尾，rear）进行插入操作，另一端（队头，front）进行删除操作的数据结构。 插入：在队尾进行，也称为入队 删除：在队头进行，也称为出队 队列的示意图如下： 队列只能在一端进行插入，另一端进行删除，从示意图可以看出，队列里的元素是按照入队的顺序出队的（因此队列经常被用在排队等候类的应用中）。 根据队列的特征，队列也被称为先进先出（First In First Out，FIFO）列表。 队列的操
C语言使用链表队列实现初始化，出队列，入队列，取队头，遍历
Bo_Sir的博客
11-05 1698
C语言使用链表队列实现初始化，出队列，入队列，取队头，遍历 1.C语言使用链表队列实现初始化，出队列，入队列，取队头，遍历 #include<stdio.h> #include<stdlib.h> #include<malloc.h> typedef int DataType; typedef struct Node{ DataType data; struct Node *next; }Nod
链队列的表示和实现
Bee_Darker的博客
10-25 1052
1.链队列的表示 typedef  struct QNode {     QElemType      data;     struct   QNode   *next; }QNode, *QueuePtr; typedef  struct {    QueuePtr   *front;          //队头指针    QueuePtr   *rear;         ...
数据结构（C语言版）——4.3、链式队列实现
weixin_41600504的博客
10-07 458
4.1、链式队列实现 4.1.1、链式队列说明 和单链表类似。链式队列即用一组任意的存储单元存储栈的数据元素。每个结点包括存放数据元素的数据域，和指示下一个队列结点的指针域。 对于队尾元素而言，由于其没有下一个结点，故队尾结点的指针域始终为 NULL ，其数据域存放最后一个入队的数据元素（头出尾入），由于元素通过队尾入队，附设一个队尾指针（ rear ）。 为了操作方便，这里给链队列添加一个头结点，并令头指针（ front ）指向头结点。链队列示意图如下图所示。 注：可将链式队列结构看成带头结点的单链表
数据结构--队--循环队列和链队c++
日常记录
03-31 121
【代码】数据结构--队--循环队列和链队c++
数据结构归并算法详解-C语言实现
"归并排序算法的C语言实现及其在数据结构中的重要性" 在计算机科学中，数据结构和算法是核心部分，它们是解决问题的基础。《数据结构(C语言版)》由严蔚敏和吴伟民编著，清华大学出版社出版，详细介绍了数据结构的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值