数据结构C语言—线性表【队列】静态顺序队列（定义结构体变量实现）（具有自动调整功能防止假溢出）【2021-11-14】

最新推荐文章于 2022-10-15 21:23:12 发布
最新推荐文章于 2022-10-15 21:23:12 发布
阅读量1.1k 收藏 3
点赞数 7
分类专栏： 数据结构-C语言 文章标签： 数据结构 c语言 静态顺序队列 假溢出 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54698498/article/details/121316588
版权

数据结构C语言—线性表【队列】静态顺序队列（定义结构体变量实现）（具有自动调整功能防止假溢出）


【注1】实现了一个自动调整队列在队列空间分布的函数，解决普通数组的静态队列假溢出状态；
【注2】自动调整函数的被动触发：在入队函数调用时（遇到假溢出先调整再入队）、在出队函数调用时（遇到假溢出先调整再出队）；
【注3】自动调整函数的主动执行：手动调用自动调整函数Status AutoMemory_Queue(SqQueuePonit Q)即可。
【注4】由于测试极限与假溢出情况需要，故只将队列空间数组元素个数设置为6（MAXSIZE），使用时可修改该宏定义！

SqQueuestatic.h

#define MAXSIZE 6
#define NOINIT -1 
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE 1
#define OVERFLOW 1

typedef int Status;
typedef int DataType;
typedef int *Pt;
typedef struct SqQueue
{
	DataType rear;//指向队尾元素的下一个顺序位置（以数组元素下表作为指针）
	DataType front;// 指向队头的指针（以数组元素下表作为指针） 
	DataType length;//队列中元素的个数，即队列长度 
	DataType data[MAXSIZE];//队列数组元素个数，为定值分配空间
}SqQueue,*SqQueuePonit;

Status InitQueue(SqQueuePonit Q);//初始化一个空静态顺序队列Q，成功返回OK，否则返回ERROR 
Status ClearQueue(SqQueuePonit Q);//清空静态顺序队列Q，返回OK；静态顺序队列Q未初始化（NOINIT）;队尾指针等于队头指针——空状态标志
//Status DestoryQueue(SqQueuePonit Q);//销毁一个队列Q 

Status IsEmptyQueue(SqQueuePonit Q);//判断一个队列是否为空，是空（TRUE），不是空（FALSE）;静态顺序队列Q未初始化（NOINIT） 
DataType QueueLength(SqQueuePonit Q);//返回队列Q的元素个数，即队列长度，静态顺序队列Q未初始化（NOINIT）

Status GetTop_Queue(SqQueuePonit Q,Pt e);//若队列不空，用*e返回队列Q头的元素，返回OK；若队列空（ERROR）；静态顺序队列Q未初始化（NOINIT）   
Status Push_Queue(SqQueuePonit Q,DataType e);//若队列不满，将e入队列，返回OK；队列满，返回ERROR；静态顺序队列Q未初始化（NOINIT）  
Status Pop_Queue(SqQueuePonit Q,Pt e);//若队列不空，将队列头元素出队列，即删除队列顶元素，用*e返回其值，返回OK；若队列空（ERROR）；静态顺序队列Q未初始化（NOINIT）  
Status QueueTraverse(SqQueuePonit Q,Status (*Visit)(SqQueuePonit Q,DataType p));//队列不空，对每个元素调用Visist()，返回OK；若队列空（ERROR）；静态顺序队列Q未初始化（NOINIT） 

Status Visit(SqQueuePonit Q,DataType p);//遍历调用函数 

//下面是一个判断当前队列空间是否处于假溢出（假满）状态
Status IsVirFull_Queue(SqQueuePonit Q); 

//下面是一个静态顺序队列空间的自动调整函数，防止假溢出（假满）状态
Status AutoMemory_Queue(SqQueuePonit Q);

SqQueuestatic.c

#include "SqQueuestatic.h" 
#include <stdio.h>

Status InitQueue(SqQueuePonit Q)//初始化一个空静态顺序队列Q，成功返回OK，否则返回ERROR 
{
	puts("\n|<=====================开始【初始化队列】操作！=====================>|");
	Q->front = 0;//默认起始从数组0位置增长队列 
	Q->rear = Q->front;//队列为空标志，队尾指针始终指向实际队尾元素的下一个顺序位置 
	Q->length = 0;//队列长度置为0 
	for(int i = 0;i<MAXSIZE;i++)//给静态数组队列的每个元素赋初始值
	{
		(Q->data)[i]=0;
	}
	puts("|<=====================完成【初始化队列】操作！=====================>|");
	return OK; 
}
Status ClearQueue(SqQueuePonit Q)//清空静态顺序队列Q，返回OK；静态顺序队列Q未初始化（NOINIT）;队尾指针等于队头指针——空状态标志
{
	if(Q->front >= MAXSIZE || Q->front < 0 || Q->rear > MAXSIZE || Q->rear < 0 || Q->front > Q->rear)
	{
		puts("\n|!===========静态顺序队列【未初始化】不能执行【清空】操作===========!|");
		return  NOINIT;
	}
	puts("\n|<===================开始【清空】静态顺序队列！=====================>|");
	Q->front=Q->rear=0;//空队列状态标志,默认起始从数组0位置增长队列 
	Q->length = 0;//队列长度置为0 
	puts("|<===================【清空】静态顺序队列完成！=====================>|");
	return OK; 	
}
//Status DestoryQueue(SqQueuePonit Q);//销毁一个队列Q 

Status IsEmptyQueue(SqQueuePonit Q)//判断一个队列是否为空，是空（TRUE），不是空（FALSE）;静态顺序队列Q未初始化（NOINIT） 
{
	if(Q->front >= MAXSIZE || Q->front < 0 || Q->rear > MAXSIZE || Q->rear < 0 || Q->front > Q->rear)
	{
		puts("\n|!===========静态顺序队列【未初始化】不能执行【判空】操作===========!|");
		return  NOINIT;
	}
	if(Q->front==Q->rear)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}	
}
DataType QueueLength(SqQueuePonit Q)//返回队列Q的元素个数，即队列长度，静态顺序队列Q未初始化（NOINIT）
{
	if(Q->front >= MAXSIZE || Q->front < 0 || Q->rear > MAXSIZE || Q->rear < 0 || Q->front > Q->rear)
	{
		puts("\n|!===========静态顺序队列【未初始化】不能执行【求长】操作===========!|");
		return  NOINIT;
	}
	return Q->length = Q->rear - Q->front; 	
}

Status GetTop_Queue(SqQueuePonit Q,Pt e)//若队列不空，用*e返回队列Q头的元素，返回OK；若队列空（ERROR）；静态顺序队列Q未初始化（NOINIT）   
{
	if(Q->front >= MAXSIZE || Q->front < 0 || Q->rear > MAXSIZE || Q->rear < 0 || Q->front > Q->rear)
	{
		*e = -6699;
		puts("\n|!===========静态顺序队列【未初始化】不能执行【获头】操作===========!|");
		return  NOINIT;
	}
	if(IsEmptyQueue(Q) == TRUE)
	{
		*e=-6699;
		puts("\n|!===========静态顺序队列【是空队列】不能执行【获头】操作===========!|");
		return  ERROR;
	}
	else
	{
		*e=Q->data[Q->front];
		printf("当前静态顺序队列Q中，队头元素是：%d\n",*e);
		return OK;
	}
}
Status Push_Queue(SqQueuePonit Q,DataType e)//若队列不满，将e入队列，返回OK；队列满，返回ERROR；静态顺序队列Q未初始化（NOINIT） 
{
	if(Q->front >= MAXSIZE || Q->front < 0 || Q->rear > MAXSIZE || Q->rear < 0 || Q->front > Q->rear)
	{
		puts("\n|!===========静态顺序队列【未初始化】不能执行【入队】操作===========!|");
		return  NOINIT;
	}
	//printf("%d,%d\n",QueueLength(Q) == MAXSIZE,Q->rear == MAXSIZE);
	if(QueueLength(Q) == MAXSIZE && Q->rear == MAXSIZE)
	{
		puts("\n|!===========静态顺序队列【队列真满】不能执行【入队】操作===========!|");
		return  ERROR;
	}
	else if(IsVirFull_Queue(Q) == TRUE)
	{
		puts("\n|!===========静态顺序队列【队列假满】开始执行【自调】操作===========!|");
		AutoMemory_Queue(Q);
		puts("\n|!===========静态顺序队列【自动调整】已经执行【完毕】操作===========!|");
		Q->data[(Q->rear)++] = e;
		(Q->length)++;
		puts("\n|-===========静态顺序队列【加入队列】已经执行【完毕】操作===========>|");
		return OK;
	} 
	else
	{
		puts("\n|<===========静态顺序队列【有剩空间】开始执行【入队】操作===========-|");
		Q->data[(Q->rear)++] = e;
		(Q->length)++;
		puts("\n|-===========静态顺序队列【加入队列】已经执行【完毕】操作===========>|");
		return OK;
	}
	return ERROR;
}
Status Pop_Queue(SqQueuePonit Q,Pt e)//若队列不空，将队列头元素出队列，即删除队列顶元素，用*e返回其值，返回OK；若队列空（ERROR）；静态顺序队列Q未初始化（NOINIT） 
{
	if(Q->front >= MAXSIZE || Q->front < 0 || Q->rear > MAXSIZE || Q->rear < 0 || Q->front > Q->rear)
	{
		*e = -6699;
		puts("\n|!===========静态顺序队列【未初始化】不能执行【出队】操作===========!|");
		return  NOINIT;
	}
	if(IsEmptyQueue(Q) == TRUE)
	{
		*e=-6699;
		puts("\n|!===========静态顺序队列【是空队列】不能执行【出队】操作===========!|");
		return  ERROR;
	}
	else if(IsVirFull_Queue(Q) == TRUE)
	{
		puts("\n|!===========静态顺序队列【队列假满】开始执行【自调】操作===========!|");
		AutoMemory_Queue(Q);
		puts("\n|!===========静态顺序队列【自动调整】已经执行【完毕】操作===========!|");
		puts("\n|!===========静态顺序队列【空间正常】开始执行【出队】操作===========!|");
		*e=(Q->data)[(Q->front)++];
		printf("Q-FRONT:%d",Q->front);
		(Q->length)--;
		puts("\n|!===========静态顺序队列【空间正常】已经执行【完毕】操作===========!|");
		return OK;
	} 
	else
	{
		puts("\n|!===========静态顺序队列【空间正常】开始执行【出队】操作===========!|");
		*e=(Q->data)[(Q->front)++];
		printf("Q-FRONT:%d",Q->front);
		(Q->length)--;
		puts("\n|!===========静态顺序队列【空间正常】已经执行【完毕】操作===========!|");
		return OK;
	}
	return ERROR;
}
Status QueueTraverse(SqQueuePonit Q,Status (*Visit)(SqQueuePonit Q,DataType p))//队列不空，对每个元素调用Visist()，返回OK；若队列空（ERROR）；静态顺序队列Q未初始化（NOINIT） 
{
	if(Q->front >= MAXSIZE || Q->front < 0 || Q->rear > MAXSIZE || Q->rear < 0 || Q->front > Q->rear)
	{
		puts("\n|!===========静态顺序队列【未初始化】不能执行【遍历】操作===========!|");
		return  NOINIT;
	}
	if(IsEmptyQueue(Q) == TRUE)
	{
		puts("\n|<=====================开始【全遍历队列】操作！=====================>|");
		printf("队头指针----->%d：空<-----队尾巴指针\n",Q->front); 
		puts("|<=====================完成【全遍历队列】操作！=====================>|");
		return ERROR;
	} 
	else
	{
		puts("\n|<=====================开始【全遍历队列】操作！=====================>|");
		DataType p;
		printf("队尾指针----->%d\n",Q->rear); 
		for(p = Q->rear-1;p != Q->front - 1;p--)
		{
//			printf("p=%d\n",p);
			Visit(Q,p);
		}
		puts("|<=====================完成【全遍历队列】操作！=====================>|");
		return OK;
	}	
}

Status Visit(SqQueuePonit Q,DataType p)//遍历调用函数
{
	if(p == Q->front)
	{
		printf("队头指针----->%d:%d\n",p,(Q->data)[p]);
	}
	else
	{
		printf("              %d:%d\n",p,(Q->data)[p]);
	}
	return OK;	
}

//下面是一个判断当前队列空间是否处于假溢出（假满）状态
Status IsVirFull_Queue(SqQueuePonit Q)
{
	//只要rear指针指向数组MAXSIZE位置且队列长度小于队列空间数组长度，就视为处于假溢出状态 
	if(Q->front >= MAXSIZE || Q->front < 0 || Q->rear > MAXSIZE || Q->rear < 0 || Q->front > Q->rear)
	{
		puts("\n|!===========静态顺序队列【未初始化】不能执行【判假】操作===========!|");
		return  NOINIT;
	}
	if(Q->rear == MAXSIZE && QueueLength(Q) < MAXSIZE)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

//下面是一个静态顺序队列空间的自动调整函数，防止假溢出（假满）状态
Status AutoMemory_Queue(SqQueuePonit Q)
{
	//自动调整操作可以在任意已经初始化状态后使用 
	//将处于假溢出状态的整个队列的front对齐到数组0位置，即将整个队列在数组空间中下拉
	int i;
	int t = Q->front;
	if(Q->front >= MAXSIZE || Q->front < 0 || Q->rear > MAXSIZE || Q->rear < 0 || Q->front > Q->rear)
	{
		puts("\n|!===========静态顺序队列【未初始化】不能执行【自调】操作===========!|");
		return  NOINIT;
	} 
	puts("\n###@@!===========静态顺序队列【开始】【自动调整】操作===========!@@###");
	for(i = 0;i < MAXSIZE;i++,t++)
	{
		if(t == Q->rear)
		{
			break;
		}
		else
		{
			Q->data[i] = Q->data[t];
		}
	}
	Q->front = 0;
	Q->rear = i;
	puts("###@@!===========静态顺序队列【完成】【自动调整】操作===========!@@###");
	return OK;
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include "SqQueuestatic.h" 
/* 线性表——顺序队列（静态分配）【自编代码】 */ 
int main() 
{
	SqQueue Q;
	int e;
	
	GetTop_Queue(&Q,&e); 
	ClearQueue(&Q);
	AutoMemory_Queue(&Q);
	if(IsEmptyQueue(&Q) == TRUE)
	{
		printf("Q是空队列！\n");
	}
	else if(IsEmptyQueue(&Q) == FALSE) 
	{
		printf("Q不是空队列！\n");
	}
	QueueLength(&Q);
	Push_Queue(&Q,888);
	Pop_Queue(&Q,&e);
	QueueTraverse(&Q,Visit); 
	
	puts("\n为了方便测试极限情况与队列假溢出状态，设置队列空间数组元素个数为6（MAXSIZE）！");
	InitQueue(&Q);

	GetTop_Queue(&Q,&e); 
	AutoMemory_Queue(&Q);
	if(IsEmptyQueue(&Q) == TRUE)
	{
		printf("Q是空队列！\n");
	}
	else if(IsEmptyQueue(&Q) == FALSE) 
	{
		printf("Q不是空队列！\n");
	}
	printf("Q长度是:%d\n",QueueLength(&Q));
	Push_Queue(&Q,888);
	Pop_Queue(&Q,&e);
	QueueTraverse(&Q,Visit); 
	ClearQueue(&Q);
	
	
	puts("请按先后顺序，输入要入队的元素（空格分隔，f结束）：");
	while(1)
	{
		int n,k;
		k=scanf("%d",&n);
		if(k==0)
		{
			break;
		}
		Push_Queue(&Q,n);
	}
	QueueTraverse(&Q,Visit); 
	GetTop_Queue(&Q,&e); 


	puts("测试再入队一个元素999：\n");
	Push_Queue(&Q,999);
	QueueTraverse(&Q,Visit); 
	printf("Q长度：%d\n",QueueLength(&Q));
	
	puts("测试再入队一个元素666：\n");
	Push_Queue(&Q,666);
	QueueTraverse(&Q,Visit); 
	printf("Q长度是:%d\n",QueueLength(&Q));
	GetTop_Queue(&Q,&e); 
	
	puts("测试执行出队一个元素：\n");
	Pop_Queue(&Q,&e);
	QueueTraverse(&Q,Visit); 
	printf("Q长度是:%d\n",QueueLength(&Q));
	
	puts("测试执行出队一个元素：\n");
	Pop_Queue(&Q,&e);
	QueueTraverse(&Q,Visit); 
	QueueTraverse(&Q,Visit); 
	GetTop_Queue(&Q,&e); 
	
	puts("测试再入队一个元素777：\n");
	Push_Queue(&Q,777);
	QueueTraverse(&Q,Visit); 
	
	puts("测试执行出队一个元素：\n");
	Pop_Queue(&Q,&e);
	QueueTraverse(&Q,Visit); 
	GetTop_Queue(&Q,&e); 
	
	puts("测试执行出队一个元素：\n");
	Pop_Queue(&Q,&e);
	QueueTraverse(&Q,Visit); 
	GetTop_Queue(&Q,&e); 
	
	puts("\n手动调用一次自调操作："); 
	AutoMemory_Queue(&Q);
	QueueTraverse(&Q,Visit); 
	printf("Q长度是:%d\n",QueueLength(&Q));
	
	ClearQueue(&Q);
	QueueTraverse(&Q,Visit); 
	
	return 0;
}

运行结果示例

由于程序运行测试输出过多，因此分段截图，按顺序放置：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

------------------------------------------------------第八次发文章有点激动啊！-----------------------------------------------------
-----------------------------------------------------【数据结构代码自编练习】------------------------------------------------------
----------------------------------------------------------------【TDTX】-----------------------------------------------------------------

TDTX
关注
  • 7
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
数据结构与算法 c语言 线性表-静态链表
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
C语言实现静态队列
08-05 587
队列包含两种： 1、动态队列。（是链表实现，不存满的情况。默认链表可以无穷大。 2、静态队列。（数组实现。难道较上面的大。本文也是讲此种 ：静态循环队列 静态循环队列 typedef struct Queue { int *pBase;///数组（应为数组的名字也是第一个元素的指针 int front;////头下标 int rear; //尾下标 int...
数据结构//C——静态队列（数组）
qq_62819483的博客
01-26 567
静态队列通常必须是 循环队列 init_enqueue_dequeue_traverse
静态环形队列（C语言）
pingxiaozhao的博客
01-03 606
typedef struct //数据内容根据实际可以随意变更 { int a; int b; int c; char str[100]; }DataDef #define BUFFER_LEN 20 //环形队列长度 static int Read = 0; //读计数 static in...
特殊线性表——队列（C语言）
xianyu4625的博客
06-07 253
目录队列的逻辑结构队列的顺序存储结构及实现如何该进出队的时间性能假溢出如何解决假溢出循环队列入队（伪代码）循环队列出队（伪代码）顺序存储代码队列的链式存储结构及其实现链式存储代码循环队列与链队列的比较代码如下： 队列的链式存储结构及其实现 链式存储代码 代码如下： 循环队列与链队列的比较...
【线性表】之队列(C语言)
半生瓜のblog
06-08 370
队列队列的概念结构定义初始化销毁队尾入队头出队头出队头数据队尾数据是否为空返回数据个数全部代码 队列的概念 队列只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出的FIFO(First in First Out)。 入队列：进行插入操作的一端称为队尾。 出队列：进行删除操作的一端称为队头。 同样可以使用链表或者数组 数组：不是适合，队头出数据需要挪动数据。 链表：适合单链表，单链表头删效率很高。 结构定义 typedef int QueueDataType; typede
数据结构C语言版线性表算法2.4-数据结构c语言版严蔚敏顺序线性表12个基本操作及算法的实现... 定义线性表节点的结构.pdf
04-18
数据结构C语言版线性表算法2.4-数据结构c语言版严蔚敏顺序线性表12... 定义线性表节点的结构.pdf数据结构C语言版线性表算法2.4-数据结构c语言版严蔚敏顺序线性表12个基本操作及算法的实现... 定义线性表节点的结构.pdf
数据结构--线性表的顺序存储结构（c语言实现）
06-17
c语言实现的线性表顺序存储结构，包括初始化，设置线性表的值，增，删，改，查。
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
12-02
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
c语言实现线性表的算法-数据结构算法代码实现——线性表的定义（一） 定义线性表节点的结构.pdf
04-18
c语言实现线性表的算法-数据结构算法代码实现——线性表的定义（一） 定义线性表节点的结构.pdf
STL中的序列式容器——queue（队列）
hyl1181的博客
09-13 356
STL中的序列式容器——queue（队列） queue，即“队列”。队列是一种先进先出（FIFO）的元素序列，访问和删除都只能对队顶的元素（即最先一个被加入队列的元素）进行，但是元素只能被添加到队尾。队列内的元素不能访问，如果一定要访问队列内的元素，只能将其上方的元素全部从队列中删除，使之变成队列顶元素才可以。 queue是C++ STL的一个重要成员，使用它时需要包含头文件： #include <queue>; queue是容器适配器的一种，容器适配器中的数据是以FIFO 的方式组织的。 一
数据结构（C语言）2.线性表——队列
wt_nothing的博客
10-15 274
数据结构C语言——队列，队列的相关知识，队列的C语言实现，用栈实现队列，用队列实现栈，循环队列的实现
C语言 数据结构之静态队列
黑色低级高中生的博客
10-24 281
StaticQueue.c #include "StaticQueue.h" #include <stdio.h> #include <stdlib.h> int main(int argc, char* argv[]) { Queue queue; Queue* q = &queue; //-----输入4来测试-----// InitQueu...
C语言实现静态数组队列
Hong_smallgod的博客
09-10 374
C语言实现静态数组队列
静态队列——基于C语言
qq_38705421的博客
08-12 185
最近复习了C语言的相关知识，实现了数据结构中的静态队列。 下面是Main.c文件： #include "StaticQueue.h" #include <stdio.h> int main() { StaticQueue* queue = StaticQueueCreate(); if(queue != NULL) { int i, len = -1, data = -1; for(i = 0; i < StaticQueueCapacity(queue)
C语言-数据结构-循环队列(静态队列)
406156440的博客
08-03 652
静态队列(循环队列) 问题: 假设队列一共有7个元素位置 0 1 2 3 4 5 6 1. 参数: front永远指向底层第一个元素 rear(永远指向的是下一个元素位置) 2. 入队问题: 判断是都rear是否到头,如果到头了该怎么指向?既r此时已经指向6了 答: r = (r + 1) % 数组长度 3. 出队问题:判断出队到头了,fro...
c语言静态循环数组实现队列,数据结构基础(五)-C语言实现循环队列-静态
weixin_39773239的博客
05-21 104
数据结构基础(5)--C语言实现循环队列--静态#include#include#includetypedef struct Queue{int * PBase;//指向数组第一个元素的指针int front;//队列头部元素下标int rear;//队列尾部元素下标}QUEUE;/***初始化队列，实现队列的数组长度为6。**/void initQueue(QUEUE * pQ){pQ->...
队列——C语言实现（静态数组）
New_Teen的博客
05-21 952
队列是一种先进先出的数据结构 下面将展示我用普通的静态数组实现的队列 1.首先先写一个队列的接口（queue.h） /* 一个队列模块的接口 */ #include <stdlib.h> #define QUEUE_TYPE int /*队列元素的类型*/ /* ** create_queue ** 创建一个队列，参数为队列可以存储元素的最大数量 ** 这个函数只适用于动态分配数组的队列版本 */ void create_queue(size_t size); /* ** destroy_
数据结构 - 队列静态顺序存储结构
陆讯
04-29 2109
队列的基本概念1 队列的基本概念 队列(Queue)：也是运算受限的线性表。是一种先进先出(First In First Out ，简称FIFO)的线性表。只允许在表的一端进行插入，而在另一端进行删除。 队首(front) ：允许进行删除的一端称为队首。 队尾(rear) ：允许进行插入的一端称为队尾。 　　例如：排队购物。操作系统中的作业排队。先进入队列的成员总是先
数据结构c语言线性表
最新发布
10-26
C语言中的线性表是一种常见的数据结构，它是由一组相同数据类型的元素组成的有限序列。...在C语言中，可以使用结构体来定义线性表的数据结构，然后通过函数来实现线性表的各种操作，例如插入、删除、查找等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值