C_栈和队列(ADT)-队列的非循环(带头指针)顺序表示和实现

最新推荐文章于 2022-03-23 10:45:50 发布
最新推荐文章于 2022-03-23 10:45:50 发布
阅读量404 收藏
点赞数
分类专栏： 数据结构__栈和队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37243410/article/details/76890134
版权

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。


顺序队列一次性要分配大量保证够用的空间，效率较高，因为是基于数组的，长度也是固定的。可以实现变长，但是一般代价较高。

队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表。




出列元素时不移动元素，只改变队头元素的位置

优点：带头指针非循环队列，在出队元素时，只改变头指针的位置，不移动元素，可以简化操作，节约时间

缺点：队列的每个存储空间自始自终只能存储一个队列元素。即使这个队列元素出列后，存储空间浪费较大


队列的定义：

struct SqQueue2
{
	QElemType *base;		//初始化的动态分配内存空间
	int front;				//头指针，若队列不空，指向队列的头元素
	int rear;				//尾指针， 若队列不空，指向队列尾元素的下一个位置
	int queuesize;			//当前分配的存储容量(以sizeof(QElemType)为单位) 
};


基本操作的函数定义：

/*操作结果：构造一个空队列Q*/
void InitQueue(SqQueue2 &Q)

/*初始条件：队列Q存在*/
/*操作结果：销毁队列Q，Q不再存在*/
void DestroyQueue(SqQueue2 &Q)

/*初始条件：队列Q存在*/ 
/*操作结果：将Q清为空队列*/
Status ClearQueue(SqQueue2 &Q)

/*初始条件：队列Q存在*/
/*操作结果：若队列为空队列，则返回TRUE，否则返回FALSE*/
Status QueueEmpty(SqQueue2 Q)

/*初始条件：队列Q存在*/
/*操作结果：若队列不为空，则用e返回Q的队头元素，并返回OK，否则返回FALSE*/
Status GetHead(SqQueue2 Q,QElemType &e)

/*初始条件：队列Q存在*/
/*操作结果：返回队列的长度*/
int QueueLength(SqQueue2 Q)

/*初始条件：队列Q存在*/
/*操作结果：插入元素e为Q的新的队尾元素*/
void EnQueue(SqQueue2 &Q,QElemType e)

/*初始条件:队列Q存在*/
/*操作结果：若队列不为空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR*/
Status DeQueue(SqQueue2 &Q,QElemType &e)

/*初始条件：队列Q存在*/
/*操作结果：从队头到队尾依次对队列中每个元素调用函数vi()*/
void QueueTraverse(SqQueue2 Q,void(*vi)(QElemType))

下面是函数的实现


构造一个空队列Q

/*操作结果：构造一个空队列Q*/
void InitQueue(SqQueue2 &Q)
{
	Q.base=(QElemType*)malloc(QUEUE_INIT_SIZE*sizeof(QElemType));
	if(!Q.base){
		printf("构造空队列失败!操作退出!\n");
		exit(0);
	}else{
		Q.front=Q.rear=0;
		Q.queuesize=QUEUE_INIT_SIZE;			
	}
}


销毁队列Q

/*初始条件：队列Q存在*/
/*操作结果：销毁队列Q，Q不再存在*/
void DestroyQueue(SqQueue2 &Q)
{
	if(Q.base)
		free(Q.base);
	Q.base=NULL;
	Q.front=Q.rear=Q.queuesize=0;
}

将Q清为空队列 

/*初始条件：队列Q存在*/ 
/*操作结果：将Q清为空队列*/
Status ClearQueue(SqQueue2 &Q)
{
	Q.front=Q.rear=0;
	return OK;
}

队队列进行判空 

/*初始条件：队列Q存在*/
/*操作结果：若队列为空队列，则返回TRUE，否则返回FALSE*/
Status QueueEmpty(SqQueue2 Q)
{
	if(Q.front==Q.rear)				//队列为空的标志
		return TRUE;
	else
		return FALSE; 
}

返回队头元素 

/*初始条件：队列Q存在*/
/*操作结果：若队列不为空，则用e返回Q的队头元素，并返回OK，否则返回FALSE*/
Status GetHead(SqQueue2 Q,QElemType &e)
{
	if(Q.front==Q.rear)				//队列空
		return ERROR;
	e=Q.base[Q.front];
	return OK; 
}

返回队列长度 

/*初始条件：队列Q存在*/
/*操作结果：返回队列的长度*/
int QueueLength(SqQueue2 Q)
{
	return (Q.rear-Q.front);
}

插入新的队尾元素 

/*初始条件：队列Q存在*/
/*操作结果：插入元素e为Q的新的队尾元素*/
void EnQueue(SqQueue2 &Q,QElemType e)
{
	if(Q.rear==Q.queuesize)
	{//队列满，增加存储单元 
		Q.base=(QElemType*)realloc(Q.base,(Q.queuesize+QUEUE_INIT_SIZE)*sizeof(QElemType)); 
		if(!Q.base)			//增加单元失败
		exit(0);	
	}
	Q.base[Q.rear++]=e; 
}

删除队列的队头元素 

/*初始条件:队列Q存在*/
/*操作结果：若队列不为空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR*/
Status DeQueue(SqQueue2 &Q,QElemType &e)
{
	if(Q.front==Q.rear)		//队列空
		return ERROR;
	e=Q.base[Q.front++];
	return OK; 
}

正序遍历队列 

/*初始条件：队列Q存在*/
/*操作结果：从队头到队尾依次对队列中每个元素调用函数vi()*/
void QueueTraverse(SqQueue2 Q,void(*vi)(QElemType))
{
	int i=Q.front;
	while(i!=Q.rear)
		vi(Q.base[i++]);
	printf("\n");
}



嗯下面就是在VC中的测试：

#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define QUEUE_INIT_SIZE 10	//队列存储空间的初始化分配量
#define QUEUE_INCREMENT 2	//队列存储空间的分配增量
typedef int QElemType;
typedef int Status;
struct SqQueue2
{
	QElemType *base;		//初始化的动态分配内存空间
	int front;				//头指针，若队列不空，指向队列的头元素
	int rear;				//尾指针， 若队列不空，指向队列尾元素的下一个位置
	int queuesize;			//当前分配的存储容量(以sizeof(QElemType)为单位) 
};

void vi(QElemType e)
{
	printf("%d \n",e);
}

void print(QElemType i)
{
	printf("%d ",i);
}

/*操作结果：构造一个空队列Q*/
void InitQueue(SqQueue2 &Q)
{
	Q.base=(QElemType*)malloc(QUEUE_INIT_SIZE*sizeof(QElemType));
	if(!Q.base){
		printf("构造空队列失败!操作退出!\n");
		exit(0);
	}else{
		Q.front=Q.rear=0;
		Q.queuesize=QUEUE_INIT_SIZE;			
	}
}

/*初始条件：队列Q存在*/
/*操作结果：销毁队列Q，Q不再存在*/
void DestroyQueue(SqQueue2 &Q)
{
	if(Q.base)
		free(Q.base);
	Q.base=NULL;
	Q.front=Q.rear=Q.queuesize=0;
}

/*初始条件：队列Q存在*/ 
/*操作结果：将Q清为空队列*/
Status ClearQueue(SqQueue2 &Q)
{
	Q.front=Q.rear=0;
	return OK;
}

/*初始条件：队列Q存在*/
/*操作结果：若队列为空队列，则返回TRUE，否则返回FALSE*/
Status QueueEmpty(SqQueue2 Q)
{
	if(Q.front==Q.rear)				//队列为空的标志
		return TRUE;
	else
		return FALSE; 
} 

/*初始条件：队列Q存在*/
/*操作结果：若队列不为空，则用e返回Q的队头元素，并返回OK，否则返回FALSE*/
Status GetHead(SqQueue2 Q,QElemType &e)
{
	if(Q.front==Q.rear)				//队列空
		return ERROR;
	e=Q.base[Q.front];
	return OK; 
} 

/*初始条件：队列Q存在*/
/*操作结果：返回队列的长度*/
int QueueLength(SqQueue2 Q)
{
	return (Q.rear-Q.front);
}

/*初始条件：队列Q存在*/
/*操作结果：插入元素e为Q的新的队尾元素*/
void EnQueue(SqQueue2 &Q,QElemType e)
{
	if(Q.rear==Q.queuesize)
	{//队列满，增加存储单元 
		Q.base=(QElemType*)realloc(Q.base,(Q.queuesize+QUEUE_INIT_SIZE)*sizeof(QElemType)); 
		if(!Q.base)			//增加单元失败
		exit(0);	
	}
	Q.base[Q.rear++]=e; 
}

/*初始条件:队列Q存在*/
/*操作结果：若队列不为空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR*/
Status DeQueue(SqQueue2 &Q,QElemType &e)
{
	if(Q.front==Q.rear)		//队列空
		return ERROR;
	e=Q.base[Q.front++];
	return OK; 
} 


/*初始条件：队列Q存在*/
/*操作结果：从队头到队尾依次对队列中每个元素调用函数vi()*/
void QueueTraverse(SqQueue2 Q,void(*vi)(QElemType))
{
	int i=Q.front;
	while(i!=Q.rear)
		vi(Q.base[i++]);
	printf("\n");
}	

int main()
{
	int i;
	int n;
	int ch;
	QElemType k;
	SqQueue2 Q;
	InitQueue(Q);
	printf("成功构造非循环队列Q!\n");
	printf("请输入队列中初始存在的个数：");
	scanf("%d",&n);
	printf("请依次输入数据元素:\n");
	for(i=1;i<=n;i++)
	{
		scanf("%d",&k);
		EnQueue(Q,k);					//依次入队k个元素 
	}
	printf("****************************\n");
	printf("1、增加元素\n2、判空队列\n3、队列长度\n");
	printf("4、队头元素\n5、队头出列\n6、清空队列\n");
	printf("7、打印队列\n8、销毁队列\n0、退出操作\n"); 
	printf("****************************\n");
	printf("请选择要进行的操作：");
	while(scanf("%d",&ch)&&ch!=0)
	{
		if(ch==1){
			printf("请输入要进队的元素:");
			scanf("%d",&k);
			EnQueue(Q,k);
			printf("%d元素成功进入队头!\n");
		}
		if(ch==2){
			if(QueueEmpty(Q))
				printf("这是一个空队列!\n");
			else
				printf("这不是一个空队列!\n"); 
		}
		if(ch==3){
			printf("队列的长度为：%d\n",QueueLength(Q));
		}
		if(ch==4){
			int d;
			if(GetHead(Q,d))
				printf("队头元素是%d\n",d);
			else
				printf("这是一个空队列!\n");
		}
		if(ch==5){
			int d;
			if(DeQueue(Q,d))
				printf("队头元素%d成功出列!\n",DeQueue(Q,d));
			else
				printf("操作失败!\n");
		}
		if(ch==6){
			if(ClearQueue(Q))
				printf("队列成功清空!\n");
		}
		if(ch==7){
			printf("队列中的元素为：");
			QueueTraverse(Q,print);
		}
		if(ch==8)
		{
			DestroyQueue(Q);
			printf("队列成功销毁，操作退出!\n");
			exit(0);
		} 
	printf("请选择要进行的操作：");
	}
	printf("成功退出操作!\n");
	return 0;
}



Cynical丶Gary
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C和指针---ADT:链表、堆栈、队列和树
m0_49416708的博客
08-17 146
1.内存分配 ADT如何获取内存来存储值？三种方案：静态数组、动态分配的数组和动态分配的链式结构。 静态数组要求结构的长度固定，而且长度必须在编译时确定，方案简单，最不容易出错 动态数组，可在运行中决定数组长度， 链式结构提供最大程度的灵活性，每个元素在需要时才单独进行分配，除了不能超过机器的可用内存之外，这种方式对元素的数量几乎没有什么限制，但链式结构的链接字段需要消耗一定的内存。 2.堆栈 堆栈（stack）最鲜明的特点是其后进先出的方式 2.1 堆栈接口 基本的堆栈操作通常被称为push和pop。pu
栈的top指针指向哪里_栈和队列
weixin_39893042的博客
12-03 1万+
栈： 后进先出（Last In First Out，LIFO）的线性序列，称为“栈”。栈也是一种线性表，只不过它是操作受限的线性表，只能在一端进出操作。进出的一端称为栈顶（top）,另一端称为栈底（base）。栈可以用顺序存储，也可以用链式存储，分别称为顺序栈和链栈。顺序栈： 顺序栈需要两个指针，base表示栈底指针（指向首地址或基地址），top表示栈顶指针。（top指针永远指向...
ADT - 顺序队列（Squencial Queue）
Chook_lxk的博客
10-29 648
//ADT Squencial Queue #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define
三、栈和队列
太白
03-23 536
3.1栈 3.1.1抽象数据类型栈的定义 栈是限定仅在表尾进行插入或删除操作的线性表。因此，表尾端称为栈顶(top)，相应的，表头端称为栈底(bottom)。不含元素的空表称为空栈。 栈是后进先出的线性表。 3.1.2栈的表示和实现 与线性表类似，栈也有两种存储表示方法。顺序栈和链式栈。 顺序栈：栈的顺序存储结构是利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针top指示栈顶元素在顺序栈中的位置。 非空栈中的栈顶指针始终在栈顶元素的下一个位置上。 链式栈 3.
顺序队列(非循环)的基本操作
u011831120的专栏
12-23 704
/* 顺序队列(非循环)的基本操作(9个) */ Status InitQueue(SqQueue *Q) { /* 构造一个空队列Q */ (*Q).base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType)); if(!(*Q).base) /* 存储分配失败 */ exit(OVERFLOW); (*Q).front
Queue_ADT-Linked_List:队列ADT的C程序-链接列表
04-16
Queue_ADT-Linked_List 队列ADT的C程序-链接列表C是一种通用的过程计算机编程语言，支持带有静态类型系统的结构化编程，词法变量范围和递归。 通过设计，C提供了可有效映射到典型机器指令的构造。 在链接队列中，...
C语言 表、栈和队列详解及实例代码
01-20
C语言 表、栈和队列详解 表ADT  形如A1,A2,A3…An的表，这个表的大小为n，而大小为0的表称为空表，非空表中，Ai+1后继Ai，Ai-1前驱Ai，表ADT的相关操有PrintList打印表中的元素；CreateEmpty创建一个空表；Find...
数据结构 第3章 栈和队列.ppt
06-17
顺序栈的顺序存储表示可以使用数组实现，指向表尾的指针可以作为栈顶指针。 栈的应用举例： 1. 评价表达式的计算 2. 语法分析 3. 进栈出栈的操作 队列是一种特殊的线性表，它限定在表尾进行插入，在表头进行删除...
颜色分类leetcode-Python_Data_Structures:在Python中实现不同的数据结构或算法，包括ADT、哈希表、链表、排
07-06
带头指针的单个 LL 双LL带头指针 带有头尾指针的圆形 LL 单元测试来测试所有 3 种类型和每个操作 二叉搜索树操作： 插 插入列表 找 删除 遍历BFS 遍历DFSpreorder 遍历DFSinorder 遍历DFS后序 复制树 查找最小值 求...
算法：算法C语言实现 第1-4部分 基础知识、数据结构、排序及搜索
05-25
第三部分“排序”（第6～11章）按章节顺序分别讨论基本排序方法（如选择排序、插入排序、冒泡排序、希尔排序等）、快速排序方法、归并和归并排序方法、优先队列与堆排序方法、基数排序方法以及特殊用途的排序方法，...
已知Q是一个非空队列，S是一个空栈。仅用队列和栈的ADT函数和少量工作变量，编写一个算法，将队列Q中的所有元素逆置
05-28
已知Q是一个非空队列，S是一个空栈。仅用队列和栈的ADT函数和少量工作变量，编写一个算法，将队列Q中的所有元素逆置
栈，队列的基本操作
06-08
栈，队列的基本操作以及运用队列实现看病挂号的小系统（C语言）
队列相关习题及详解(选择题和综合题) ——数据结构
热门推荐
Amour
10-31 3万+
队列的基本概念队列的定义队列（Queue）：队列简称队，也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队；删除元素称为出队或离队。这和我们日常生活中的排队是一致的，最早排队的也是最早离队的。其操作的特性是先进先出（First In First Out, FIFO），故又称为先进先出的线性表。队头（Front）：允许删除的一端，又称为首队 队
栈和队列基本概念，顺序栈的表示和实现
qq_45918426的博客
02-15 655
文章目录栈队列顺序栈顺序栈的存储结构顺序栈的基本操作初始化入栈出栈取栈顶元素 栈 栈（stack）是限定仅在表尾进行插入或删除操作的线性表。其表尾称为栈顶（top），表头称为栈底（bottom）。不含元素的栈称为空栈。 假设栈S=（a1,a2,a3,…,an），a1则为栈底元素，an为栈顶元素，元素按a1,a2,a3,…,an的顺序进栈，按an,…,a3,a2,a1的顺序出栈，如上图所示，所以栈...
C++中不使用循环清空一个栈或队列的数据
nibolyoung的博客
12-23 1139
来源：https://stackoverflow.com/questions/40201711/how-can-i-clear-a-stack-in-c-efficiently/40201744 C++STL中有队列queue和栈stack两个模板类，但是这两个类都没有像数组vector一样的clear()函数，传统方法清空一个队列或栈，使用循环： 队列： queue<int> q; ...
栈和队列指针状态
weixin_44123667的博客
05-07 1306
栈和队列指针状态（按严蔚敏版数据结构的要求） 只写了主要易考的（其实是为了方便我，哈哈），写的很随意可能有些没写对的地方请大家指正 一、栈 1、顺序栈（Top始终在元素的下一位置） 栈空：Top==0 入栈：S[Top++]=x 出栈：x=S[- -Top] 栈满：Top == MAXSIZE 2、共享栈 栈空：top1==-1&&top2==MAXSIZE 1号入栈：s[top1...
c语言循环队列ADT的实现及应用
最新发布
06-02
循环队列的实现可以使用数组来存储元素，定义一个结构体来表示队列，其中包含队列的头指针、尾指针和数组元素。下面是循环队列ADT的实现： ``` typedef struct { int *base; // 队列的存储空间 int front; // 队...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值