(三)数据结构之线性表的简单实现：队列

最新推荐文章于 2023-01-13 18:59:20 发布
最新推荐文章于 2023-01-13 18:59:20 发布
阅读量562 收藏
点赞数
分类专栏： C语言----数据结构与算法 数据结构与算法 文章标签： 数据结构 线性表 队列 顺序存储 链式存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TECH_PRO/article/details/78012076
版权

1、队列的简单定义

队列：具有一定操作约束的线性表；只能在一端插入，在另一端删除；先进先出：First In First Out（FIFO）。

2、队列的顺从存储实现

队列的顺序存储结构通常由一个一维数组和一个记录队列头元素位置的变量front以及一个记录队列尾元素的位置变量rear组成。为了不造成存储空间上的浪费常定义位循环队列。

2.1 基本数据结构

/* 定义队列的基本数据结果 */
#define MaxSize		20
typedef int ElementType;
typedef struct _Queue{
	ElementType Data[ MaxSize ];
	int rear;
	int front;
} Queue;

2.2 创建一个空队列

/* 创建一个空队列 */
Queue *CreatQueue()
{
	Queue *Q = (Queue*)malloc(sizeof(Queue));
	if(NULL != Q)
	{
		Q->front = 0;
		Q->rear = 0;
	}
	return Q;
}

2.3 插入操作

/* 向循环队列尾部插入一个元素 */
void AddQ( Queue *PtrQ, ElementType item)
{
	if ( IsFullQ(PtrQ) )
	{
		printf("The queue is full!\n");
		return;
	}
	PtrQ->rear = (PtrQ->rear+1)% MaxSize;
	PtrQ->Data[PtrQ->rear] = item;
}

2.4 删除操作

/* 删除循环队列的队头的元素 */
ElementType DeleteQ ( Queue *PtrQ )
{
	if ( IsEmptyQ(PtrQ) ) 
	{
		printf("The queue is empty!\n");
		return -1;
	} 
	else 
	{
		PtrQ->front = (PtrQ->front+1)% MaxSize;
		return PtrQ->Data[PtrQ->front];
	}
}

2.5 完整的示例代码实现

/* 循环队列的顺序存储实现 */
#include <stdio.h>
#include <stdlib.h>

/* 定义队列的基本数据结果 */
#define MaxSize		20
typedef int ElementType;
typedef struct _Queue{
	ElementType Data[ MaxSize ];
	int rear;
	int front;
} Queue;

/* 创建一个空队列 */
Queue *CreatQueue()
{
	Queue *Q = (Queue*)malloc(sizeof(Queue));
	if(NULL != Q)
	{
		Q->front = 0;
		Q->rear = 0;
	}
	return Q;
}

/* 消除一个队列 */
void DestroyQueue(Queue *PtrQ)
{
	if(NULL != PtrQ)
		free(PtrQ);
	PtrQ = NULL;
}

/* 判断队列是否为空，1为空，0非空 */
int IsEmptyQ( Queue *PtrQ )
{
	return (PtrQ->front == PtrQ->rear);
}

/* 判断队列是否为满，1为满，0为空 */
int IsFullQ( Queue *PtrQ )
{
	return ((PtrQ->rear+1)%MaxSize == PtrQ->front);
}

/* 向循环队列尾部插入一个元素 */
void AddQ( Queue *PtrQ, ElementType item)
{
	if ( IsFullQ(PtrQ) )
	{
		printf("The queue is full!\n");
		return;
	}
	PtrQ->rear = (PtrQ->rear+1)% MaxSize;
	PtrQ->Data[PtrQ->rear] = item;
}

/* 删除循环队列的队头的元素 */
ElementType DeleteQ ( Queue *PtrQ )
{
	if ( IsEmptyQ(PtrQ) ) 
	{
		printf("The queue is empty!\n");
		return -1;
	} 
	else 
	{
		PtrQ->front = (PtrQ->front+1)% MaxSize;
		return PtrQ->Data[PtrQ->front];
	}
}

/* 遍历一个循环队列 */
void TraversalQ( Queue *PtrQ )
{
	int front, rear, i;
	if(!IsEmptyQ(PtrQ))
	{
		front = PtrQ->front;
		rear = PtrQ->rear;
		for(i = front; i != rear; i = (i+1)%MaxSize)
			printf("%d ", PtrQ->Data[(i+1)%MaxSize]);
		printf("\n");
	}
}


/* 程序入口 */
int main()
{
	int i;
	ElementType temp;
	Queue *queue = NULL;

	/* 创建一个循环队列 */
	queue = CreatQueue();
	if(NULL == queue)
	{
		printf("CreatQueue is failed!\n");
		return -1;
	}

	/* 向循环队列中插入五个元素 */
	printf("Input 5 numbers : ");
	for(i = 0; i < 5; i++)
	{
		scanf("%d", &temp);
		AddQ(queue, temp);
	}

	printf("****************************************TraversalQ*******************************\n");
	TraversalQ(queue);

	printf("****************************************AddQ once********************************\n");
	printf("Input 1 number : ");
	scanf("%d", &temp);
	AddQ(queue, temp);
	TraversalQ(queue);

	printf("****************************************DeleteQ twice****************************\n");
	DeleteQ(queue);
	DeleteQ(queue);
	TraversalQ(queue);

	DestroyQueue(queue);	// 销毁一个循环队列

	return 0;
}

3、队列的链式存储实现

队列的链式存储结构也可以用一个单链表实现。删除和插入操作分别在链表的两头进行，执行删除的一端是表头，执行插入的一端是表尾。

3.1 基本数据结构实现

/* 定义链式队列的基本数据结构 */
typedef int ElementType;
typedef struct Node{
	ElementType Data;
	struct Node *Next;
}QNode;
typedef struct { 		/* 链队列结构 */
	QNode *rear; 		/* 指向队尾结点 */
	QNode *front; 		/* 指向队头结点 */
} LinkQueue;

3.2 创建一个空队列

/* 创建一个空队列 */
LinkQueue *CreatQueue()
{
	LinkQueue *Q = (LinkQueue *)malloc(sizeof(LinkQueue));
	if(NULL != Q)
	{
		Q->front = NULL;
		Q->rear = NULL;
	}
	return Q;
}

3.3 插入操作

/* 向队列尾部插入一个元素 */
void AddQ( LinkQueue *PtrQ, ElementType item)
{
	QNode *TempCell = NULL;

	TempCell = (QNode*)malloc(sizeof(QNode));
	if(NULL == TempCell)
	{
		printf("Malloc is failed!\n");
		return;
	}
	TempCell->Data = item;	// 赋值给分配的结点
	if ( IsEmptyQ(PtrQ) ) 	// 判断队列是否为空
	{
		PtrQ->rear = PtrQ->front= TempCell;
		TempCell->Next = NULL;
	}
	else
	{
		PtrQ->rear->Next = TempCell;
		TempCell->Next = NULL;
		PtrQ->rear = TempCell;
	}
}

3.4 删除操作

/* 从队列头部删除一个元素 */
ElementType DeleteQ ( LinkQueue *PtrQ )
{ 
	QNode *FrontCell;
	ElementType FrontElem;
	if ( IsEmptyQ(PtrQ) ) 
	{
		printf("The link queue is empty!\n"); 
		return -1;
	}
	FrontCell = PtrQ->front;
	if ( PtrQ->front == PtrQ->rear) 		/* 若队列只有一个元素 */
		PtrQ->front = PtrQ->rear = NULL; 	/* 删除后队列置为空 */
	else
		PtrQ->front = PtrQ->front->Next;
	FrontElem = FrontCell->Data;
	free( FrontCell ); 			/* 释放被删除结点空间 */
	return FrontElem;
}

3.5 完整的示例代码实现

/* 队列的链式存储实现 */
#include <stdio.h>
#include <stdlib.h>

/* 定义链式队列的基本数据结构 */
typedef int ElementType;
typedef struct Node{
	ElementType Data;
	struct Node *Next;
}QNode;
typedef struct { 		/* 链队列结构 */
	QNode *rear; 		/* 指向队尾结点 */
	QNode *front; 		/* 指向队头结点 */
} LinkQueue;

/* 创建一个空队列 */
LinkQueue *CreatQueue()
{
	LinkQueue *Q = (LinkQueue *)malloc(sizeof(LinkQueue));
	if(NULL != Q)
	{
		Q->front = NULL;
		Q->rear = NULL;
	}
	return Q;
}

/* 消除一个队列 */
void DestroyQueue(LinkQueue *PtrQ)
{
	while(!IsEmptyQ(PtrQ))
	{
		DeleteQ(PtrQ);
	}
	free(PtrQ);
	PtrQ = NULL;
}

/* 判断队列是否为空，1为空，0非空 */
int IsEmptyQ( LinkQueue *PtrQ )
{
	return (PtrQ->front == NULL);
}

/* 向队列尾部插入一个元素 */
void AddQ( LinkQueue *PtrQ, ElementType item)
{
	QNode *TempCell = NULL;

	TempCell = (QNode*)malloc(sizeof(QNode));
	if(NULL == TempCell)
	{
		printf("Malloc is failed!\n");
		return;
	}
	TempCell->Data = item;	// 赋值给分配的结点
	if ( IsEmptyQ(PtrQ) ) 	// 判断队列是否为空
	{
		PtrQ->rear = PtrQ->front= TempCell;
		TempCell->Next = NULL;
	}
	else
	{
		PtrQ->rear->Next = TempCell;
		TempCell->Next = NULL;
		PtrQ->rear = TempCell;
	}
}


/* 从队列头部删除一个元素 */
ElementType DeleteQ ( LinkQueue *PtrQ )
{ 
	QNode *FrontCell;
	ElementType FrontElem;
	if ( IsEmptyQ(PtrQ) ) 
	{
		printf("The link queue is empty!\n"); 
		return -1;
	}
	FrontCell = PtrQ->front;
	if ( PtrQ->front == PtrQ->rear) 		/* 若队列只有一个元素 */
		PtrQ->front = PtrQ->rear = NULL; 	/* 删除后队列置为空 */
	else
		PtrQ->front = PtrQ->front->Next;
	FrontElem = FrontCell->Data;
	free( FrontCell ); 			/* 释放被删除结点空间 */
	return FrontElem;
}

/* 遍历一个队列 */
void TraversalQ( LinkQueue *PtrQ )
{
	QNode *FrontCell;
	QNode *RearCell;
	if(!IsEmptyQ(PtrQ))
	{
		FrontCell = PtrQ->front;
		RearCell = PtrQ->rear;
		while(FrontCell != RearCell)	// 把前面n-1个结点元素值打印出来
		{
			printf("%d ", FrontCell->Data);
			FrontCell = FrontCell->Next;
		}
		printf("%d ", RearCell->Data);	// 把最后一个结点元素值打印出来
		printf("\n");
	}
}

/* 程序入口 */
int main()
{
	int i;
	ElementType temp;
	LinkQueue *queue = NULL;

	/* 创建一个循环队列 */
	queue = CreatQueue();
	if(NULL == queue)
	{
		printf("CreatQueue is failed!\n");
		return -1;
	}

	/* 向循环队列中插入五个元素 */
	printf("Input 5 numbers : ");
	for(i = 0; i < 5; i++)
	{
		scanf("%d", &temp);
		AddQ(queue, temp);
	}

	printf("****************************************TraversalQ*******************************\n");
	TraversalQ(queue);

	printf("****************************************AddQ once********************************\n");
	printf("Input 1 number : ");
	scanf("%d", &temp);
	AddQ(queue, temp);
	TraversalQ(queue);

	printf("****************************************DeleteQ twice****************************\n");
	DeleteQ(queue);
	DeleteQ(queue);
	TraversalQ(queue);

	DestroyQueue(queue);	// 销毁一个队列

	return 0;
}

TECH_PRO
关注
专栏目录
队列的线性表实现
w517565244live的专栏
05-26 187
问题： 请设计一个队列，要求满足： 1、初始时队列为空； 2、入队时，允许增加队列占用空间； 3、出队后，出队元素所占用的空间可重复使用，即整个队列所占用的空间只增不减； 4、入队操作和出队操作的时间复杂度始终保持O（1）。 请回答下列问题： 1）该队列是应该选择链式存储结构，还是应选择顺序存储结构？ 2）画出队列的初始状态，并给出判断队空和队满的条件 3）画出第一个元素入队后的队列状态。 4）给出入队操作和出队操作的基本过程。 解： （1）链式存储 （2） 判空： Q.front = Q.rear 判满
4.线性表之队列（手工实现）
/*Chen*/的博客
02-25 271
队列 队列(queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出(First In First Out)的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。 同样，作为一种特殊的线性表，队列也有顺序存储结构和链式存储结构两种类型。 队列顺序存储的不足： 假设一个队列有n个元素，则顺序存储的队列需要建立一个大于n的数组，并把队列所...
线性表——队列（java实现）
YIXIANG0234的博客
04-15 440
一，队列 队列也是一种线性表——受限的线性表，队列的数据操作是：插入数据在表的一端进行，称为队尾，删除数据在表的另一端进行，称为队首。队列是一种先进先出的数据结构。队列也可以采用两种方式来实现，即顺序表（顺序队列）和链表（链队列），这里我采用链表来实现，另外我还采用了数组实现的方式。 二，链表实现 public class MyQueue&amp;lt;T&amp;gt; { private...
线性表之队列的实现
liliugen的专栏
07-17 135
[code="java"]/** * Queue.java * 线性表之队列 * 队列有如下特点: * 先进先出 * 即,从尾部添加(push)新数据 * 从头部取出(pop)数据 */ /** * 队列(Queue)也是一种运算受限的线性表。 * 它只允许在表的一端进行插入，而在另一端进行删...
线性表之队列
zhangwang010的博客
06-10 271
队列的数组实现要使用模运算，关于模运算，请参加（...先挖个坑）。其实现原理是通过模运算使数组形成循环。这样就不用因为删除元素而移动数组了。就是数组的任意位置都可以是队列头和尾， 这样当要求一个head+1后的位置的算法是：head = （head+1）模数组长度。要求一个下标-n后的位置的算法是：新下标 = 旧下标+（数组长度-n）模数组长度。
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
线性表应用二：队列（线性表实训）
韶言大雅
04-28 2938
用前面已经实现的线性表来实现一个整数队列（队列里的数据是整数）。共需要补全三个函数（也是队列的基本功能）： 判断队列空queueEmpty、入列enQueue和出列deQueue。 相关知识 队列是一种功能受限的线性表，具有先进先出的特性。队列仅允许从一头出列（这一头称为队列头），从另外一头入列（队列尾）。 入列操作是将结点插入到队列尾（该结点称为新的队列尾）； 出列操作是从队列头删除头结点，并获...
数据结构——线性表之 栈 和 队列，详细解析
昵称就是昵称吧的博客
04-12 1944
可以先了解线性表的无头单向非循环链表(单链表)---数据结构——单链表的增加、删除、查找、修改，详细解析_昵称就是昵称吧的博客-CSDN博客，和线性表的带头双向循环链表---数据结构：带头双向循环链表——增加、删除、查找、修改，详细解析_昵称就是昵称吧的博客-CSDN博客 一、线性表之栈 1、栈的表示和实现 1.1栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除。操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO..
数据结构实验报告 线性表 串 队列 栈.doc
04-01
本实验报告的主题围绕线性表、串、队列和栈这四种基本的数据结构展开，旨在通过实践加深对这些概念的理解。线性表是一种线性的数据结构，其中元素按特定顺序排列，每个元素只有一个前驱和一个后继，除了第一个和最后...
C语言实现数据结构：线性表、栈、队列与字符串
本书详细介绍了如何用C语言实现各种基本的数据结构，包括线性表、栈、队列、串、数组和广义表等，并提供了丰富的算法实例。以下是各章节的主要知识点： 第2章 线性表 线性表是一种基本的数据结构，由n（n>=0）个...
线性表，栈，队列操作实现
11-29
线性表（数组），栈（数组），队列（链表）操作实现。
数据结构实现（C++版）
11-28
内含资源如下： 1.基本数据结构 1.1.Array ........... 动态数组 1.2.LinkedList ... 链表 1.3.BST .............. 二分搜索树 1.4.MapBST ..... 二分搜索树（用于实现映射） 1.5.AVLTree ...... AVL树 2.接口 2.1.Queue ........... 队列接口 2.2.Stack .............. 栈接口 2.3.Set .................. 集合接口 2.4.Map ............... 映射接口 2.5.Merger .......... 自定义函数接口 2.6.UnionFind ..... 并查集接口 3.高级数据结构 3.1.ArrayQueue .......................... 队列_基于动态数组实现 3.2.LinkedListQueue .................. 队列__基于链表实现 3.3.LoopQueue ........................... 循环队列_基于动态数组实现 3.4.PriorityQueue ....................... 优先队列_基于最大二叉堆实现 3.5.ArrayPriorityQueue ............. 优先队列_基于动态数组实现 3.6.LinkedListPriorityQueue ..... 优先队列_基于链表实现 3.7.ArrayStack ............................. 栈_基于动态数组实现 3.8.LinkedListStack ..................... 栈_基于链表实现 3.9.BSTSet ..................................... 集合_基于二分搜索树实现 3.10.LinkedListSet ....................... 集合_基于链表实现 3.11.BSTMap ................................ 映射_基于二分搜索树实现 3.12.AVLTreeMap ....................... 映射_ 基于AVL树实现 3.13.LinkedListMap .................... 映射_基于链表实现 3.14.MaxHeap ............................. 最大二叉堆 3.15.SegmentTree ...................... 线段树 3.16.Trie ......................................... 字典树 3.17.QuickFind ............................ 并查集_基于数组实现 3.18.QuickUnion ......................... 并查集_基于树思想实现
线性表：顺序队列算法实现
重庆李四
02-25 3042
顺序队列介绍顺序队列是队列的顺序存储结构，顺序队列实际上是运算受限的顺序表。我们知道队列是一种先将先出的数据结构，它是一种受限制的线性表，我们的顺序队列是一种队列，采用的是顺序存储结构。与其对应的是采用链式存储结构的队列 也就是链式队列。顺序队列通常采用一维数组进行存储。所以呢本次编写顺序队列 就采用前面封装好的动态数组呗。动态数组你知道么，不知道请看：数据结构与算法：动态数组（利用万能指针实现任...
队列的优化实现
ZhY_Rening的博客
02-15 1099
队列的优化方案
线性表 - 队列（数组和链表两种实现队列）
云梦归遥【qq_45834685】
05-13 370
线性表 - 队列（数组和链表两种实现队列）
【线性表】队列
小景的博客
12-12 409
目录 一、队列的定义 二、常见的三种队列及其实现 1、顺序队列 2、循环队列 3、动态顺序队列 4、链式队列 三、阻塞队列和并发队列 四、队列的应用场景 一、队列的定义 队列：同栈一样，队列也是一种“操作受限”的线性表，只不过栈的插入、删除操作被受限在表的一端，而队列的插入、删除操作则分别被受限于表的两端。 队列有两个最基本操作：入队enqueue()——将数据插入到队列尾部...
线性表-----队列
qq_41398448的博客
05-26 157
定义链队列typedef struct QNode { ElemType data; struct QNode *next; }QNode,*QueuePtr; typedef struct { QueuePtr front; //队头指针，指向队头元素 QueuePtr rear; //队尾指针，指向队尾元素 }LinkQueue;可以采用顺序表来储存定义的循...
线性表实现队列-数组实现
qq_51728241的博客
10-27 97
代码： #include <iostream> #include <cstdlib> using namespace std; const int maxn = 1010; typedef struct node { int data[maxn]; int front , tail; } * link; //初始化 void Init(link que) { que -> front = que -> tail = 0; } //入队 void Enter_que(
线性表实现队列的基本操作
最新发布
qq_67303660的博客
01-13 105
线性表实现循环队列的基本操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值