数据结构——顺序表

已于 2023-08-01 12:19:32 修改
阅读量95 收藏 1
点赞数
分类专栏： 数据结构与算法笔记 文章标签： 数据结构 c语言
于 2023-08-01 12:19:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58640056/article/details/132039542
版权

1.1 顺序表

1.1.1 定长顺序表
（1）结构体定义
/*===========结构体定义==========*/
#define ElemType int
#define MaxSize 10

typedef struct List{
	ElemType data[MaxSize]; // 数组
	int len; // 长度
}List;
（2）初始化
/*===========初始化===============*/
List* List_Init(void){
	/*为List分配堆内存*/
	List *L = malloc(sizeof(List));
	/*动态分配失败处理*/
	if(L == NULL){
		fprintf(stderr,"Init malloc is error\n");
		return NULL;
	}
	/*数组长度指向0*/
	L->len = 0;
	
	/*测试*/
	puts("Init_List is success");
	return L;
}
（3）清空
/*==============清空==============*/
void List_Clear(List *L){
	/*清空只需要将长度置0*/
	L->len = 0;
	/*测试*/
	puts("Clear_List is success");
}
（4）销毁
/*===========销毁============*/
void List_Destory(List *L){
	/*已销毁判断*/
	if(L == NULL){
		fprintf(stderr,"Destory List is error, List can not be destory\n");
		exit(1);
	}
	/*释放L，并置为空指针*/
	free(L);
	L = NULL;
	
	/*测试*/
	puts("Destory List is success");
}
（5）获取长度
/*=========打印长度============*/
int List_GetLen(const List *L){
	return L->len;
}
（6）判断是否为空
/*===========判断是否为NULL===========*/
bool List_IsEmpty(const List *L){
	if(L->len == 0){
		return true;
	}
	return false;
}
（7）判断是否已满
/*==========判断是否已满=============*/
bool List_IsFull(const List *L){
	if(L->len == MaxSize){
		return true;
	}
	return false;
}
（8）头插式创建
/*==========头插式创建============*/
bool List_CreatHead(List *L, ElemType arr[], int length){
	int i = 0;
	
	/*长度判断*/
	if(L->len + length > MaxSize){
		fprintf(stderr,"Length of List is not enough\n");
		return false;
	}
	
	/*元素全部向后移动length个位置，空出前length位置*/
	for(i = L->len - 1;i >= 0;i--){
		L->data[i + length] = L->data[i];
	}
	
	/*将length个元素逆序复制到头部前length空间*/
	for(i = 0;i < length;i++){
		L->data[i] = arr[length - i - 1];
	}
	/*长度加length*/
	L->len += length;
	
	return true;
}
（9）尾插式创建
/*=============尾插式创建==============*/
bool List_CreatTail(List *L, ElemType arr[], int length){
	int i= 0;
	/*长度判断*/
	if(L->len + length > MaxSize){
		fprintf(stderr,"Length of List is not enough\n");
		return false;
	}
	/*遍历元素赋值*/
	for(i = 0;i < length;i++){
		L->data[i + L->len] = arr[i]; 
		
	}
	
	/*长度加length*/
	L->len += length;
	
	return true;
}
（10）查找元素
/*==============查找元素，返回下标==========*/
int List_IndexOf(const List *L, ElemType e){
	int i = 0;
	for(i = 0;i < L->len;i++){
		if(L->data[i] == e){
			/*查找成功*/
			return i;
		}
	}
	/*查找失败*/
	return -1;
}
（11）获取第loc个元素
/*===========获取第loc个元素===========*/
ElemType List_GetElem(const List *L, int loc){
	/*判断是否越界*/
	if(loc < 1 || loc > L->len){
		fprintf(stderr,"the index is not suitable\n");
		exit(1);
	}
	/*返回loc - 1位置元素*/
	return L->data[loc - 1];
}
（12）在loc位置插入元素
/*=======在loc位置插入元素=====*/
bool List_Insert(List *L, int loc, ElemType e){
	int i = 0;
	/*判断是否越界*/
	if(loc < 1 || loc > L->len + 1){
		fprintf(stderr,"the index is not suitable\n");
		return false;
	}
	/*将loc - 1起的元素全部向后搬运一个位置*/
	for(i = L->len;i >= loc;i --){
		L->data[i] = L->data[i - 1];
	}
	/*插入元素*/
	L->data[loc - 1] = e;
	/*长度加1*/
	L->len ++;
	return true;
}
（13）删除loc位置元素
/*===========删除第loc个元素============*/
bool List_Delete(List *L, int loc, ElemType *e){
	int i = 0;
	/*判断是否越界*/
	if(loc < 1 || loc > L->len){
		fprintf(stderr,"the index is not suitable\n");
		return false;
	}
	/*e保留删除值*/
	*e = L->data[loc - 1];
	
	/*将loc位置元素前前搬运一个位置*/
	for(i = loc; i < L->len; i ++){
		L->data[i - 1] = L->data[i];
	}
	/*长度减一*/
	L->len --;
	return true;
}
（14）修改第loc位置元素
/*============修改第loc个元素============*/
bool List_Modify(List *L, int loc, ElemType e){
	/*判断是否越界*/
	if(loc < 1 || loc > L->len){
		fprintf(stderr,"the index is not suitable\n");
		return false;
	}
	L->data[loc - 1] = e;
	return true;
}
（15）打印顺序表
/*==============打印================*/
void List_Show(const List *L){
	int i = 0;
	for(i = 0;i < L->len;i++){
		printf("%d\t",L->data[i]);
	}
	putchar('\n');
}
1.1.2 变长顺序表
（1）结构体定义
/*===========结构体定义==========*/
#define ElemType int
#define InitSize 10  // 初始长度

typedef struct List{
	ElemType *data; // 数组
	int len; // 目前元素所占长度
	int size; // 当前最大长度
}List;
（2）初始化
/*===========初始化===============*/
void List_Init(List* L){
	/*为data分配堆内存，长度为初始长度*/
	L->data = malloc(sizeof(ElemType) * InitSize);
	/*动态分配失败处理*/
	if(L->data == NULL){
		fprintf(stderr,"Init malloc is error\n");
		exit(1);
	}
	/*数组长度指向0*/
	L->len = 0;
	/*最大长度为初始长度*/
	L->size = InitSize;
	
	/*测试*/
	puts("Init_List is success");
}
（3）清空
/*==============清空==============*/
void List_Clear(List *L){
	/*已销毁判断*/
	if(L->data == NULL){
		fprintf(stderr,"Destory List is error, List can not be destory\n");
		exit(1);
	}
	/*清空只需要将长度置0*/
	L->len = 0;
	/*测试*/
	puts("Clear_List is success");
}
（4）销毁
/*===========销毁============*/
void List_Destory(List *L){
	/*已销毁判断*/
	if(L->data == NULL){
		fprintf(stderr,"Destory List is error, List can not be destory\n");
		exit(1);
	}
	/*释放L->data，并置为空指针*/
	free(L->data);
	L->data = NULL;
	
	/*表的最大容量设置为-1*/
	L->size = -1;
	L->len = -1;
	
	/*测试*/
	puts("Destory List is success");
}
（5）获取长度
/*=========获取长度============*/
int List_GetLen(const List *L){
	/*已销毁判断*/
	if(L->data == NULL){
		fprintf(stderr,"Destory List is error, List can not be destory\n");
		exit(1);
	}
	if(L->size == -1){
		fprintf(stderr,"list is not exist\n");
	}
	return L->len;
}
（6）判断是否为空
/*===========判断是否为NULL===========*/
bool List_IsEmpty(const List *L){
	/*链表已销毁*/
	if(L->size == -1){
		fprintf(stderr,"list is not exist\n");
		exit(1);
	}
	if(L->len == 0){
		return true;
	}
	return false;
}
（7）数组扩容
/*=============数组扩容===========*/
void List_Malloc(List *L, int length){
	int len = L->len + length;
	ElemType *new_data = NULL;
	int i = 0;
	/*链表已销毁*/
	if(L->size == -1){
		fprintf(stderr,"list is not exist\n");
		exit(1);
	}
	/*判断是否需要扩容*/
	while(L->size < len){
		/*两倍扩容*/
		L->size *= 2;
	}
	/*分配新数组用来存扩容的内容*/
	new_data = malloc(sizeof(ElemType) * L->size);
	/*将旧数组的内容拷贝过来*/
	for(i = 0;i < L->len;i++){
		new_data[i] = L->data[i];
	}
	/*释放旧的data*/
	free(L->data);
	/*L->data修改位new_data*/
	L->data = new_data;
}
（8）头插式创建
/*==========头插式创建============*/
bool List_CreatHead(List *L, ElemType arr[], int length){
	int i = 0;
	
	/*链表已销毁*/
	if(L->size == -1){
		fprintf(stderr,"list is not exist\n");
		exit(1);
	}
	
	/*长度判断*/
	if(L->len + length > L->size){
		/*扩容*/
		List_Malloc(L,length);
	}
	
	/*元素全部向后移动length个位置，空出前length位置*/
	for(i = L->len - 1;i >= 0;i--){
		L->data[i + length] = L->data[i];
	}
	
	/*将length个元素逆序复制到头部前length空间*/
	for(i = 0;i < length;i++){
		L->data[i] = arr[length - i - 1];
	}
	/*长度加length*/
	L->len += length;
	
	return true;
}
（9）尾插式创建
/*=============尾插式创建==============*/
bool List_CreatTail(List *L, ElemType arr[], int length){
	int i= 0;
	
	/*链表已销毁*/
	if(L->size == -1){
		fprintf(stderr,"list is not exist\n");
		exit(1);
	}
	
	/*长度判断*/
	if(L->len + length > L->size){
		/*扩容*/
		List_Malloc(L,length);
	}
	
	/*遍历元素赋值*/
	for(i = 0;i < length;i++){
		L->data[i + L->len] = arr[i]; 
		
	}
	
	/*长度加length*/
	L->len += length;
	
	return true;
}
（10）查找元素
/*==============查找元素，返回下标==========*/
int List_IndexOf(const List *L, ElemType e){
	int i = 0;
	/*链表已销毁*/
	if(L->size == -1){
		fprintf(stderr,"list is not exist\n");
		exit(1);
	}
	for(i = 0;i < L->len;i++){
		if(L->data[i] == e){
			/*查找成功*/
			return i;
		}
	}
	/*查找失败*/
	return -1;
}
（11）获取第loc个元素
/*===========获取第loc个元素===========*/
ElemType List_GetElem(const List *L, int loc){
	/*链表已销毁*/
	if(L->size == -1){
		fprintf(stderr,"list is not exist\n");
		exit(1);
	}
	/*判断是否越界*/
	if(loc < 1 || loc > L->len){
		fprintf(stderr,"the index is not suitable\n");
		exit(1);
	}
	/*返回loc - 1位置元素*/
	return L->data[loc - 1];
}
（12）在loc位置插入元素
/*=======在loc位置插入元素=====*/
bool List_Insert(List *L, int loc, ElemType e){
	int i = 0;
	/*链表已销毁*/
	if(L->size == -1){
		fprintf(stderr,"list is not exist\n");
		exit(1);
	}
	
	/*判断是否越界*/
	if(loc < 1){
		fprintf(stderr,"the index is not suitable\n");
		return false;
	}
	/*扩容*/
	List_Malloc(L,1);
	
	/*将loc - 1起的元素全部向后搬运一个位置*/
	for(i = L->len;i >= loc;i --){
		L->data[i] = L->data[i - 1];
	}
	/*插入元素*/
	L->data[loc - 1] = e;
	/*长度加1*/
	L->len ++;
	return true;
}
（13）删除loc位置元素
/*===========删除第loc个元素============*/
bool List_Delete(List *L, int loc, ElemType *e){
	int i = 0;
	/*链表已销毁*/
	if(L->size == -1){
		fprintf(stderr,"list is not exist\n");
		exit(1);
	}
	/*判断是否越界*/
	if(loc < 1 || loc > L->len){
		fprintf(stderr,"the index is not suitable\n");
		return false;
	}
	/*e保留删除值*/
	*e = L->data[loc - 1];
	
	/*将loc位置元素前前搬运一个位置*/
	for(i = loc; i < L->len; i ++){
		L->data[i - 1] = L->data[i];
	}
	/*长度减一*/
	L->len --;
	return true;
}
（14）修改第loc位置元素
/*============修改第loc个元素============*/
bool List_Modify(List *L, int loc, ElemType e){
	/*链表已销毁*/
	if(L->size == -1){
		fprintf(stderr,"list is not exist\n");
		exit(1);
	}
	/*判断是否越界*/
	if(loc < 1 || loc > L->len){
		fprintf(stderr,"the index is not suitable\n");
		return false;
	}
	L->data[loc - 1] = e;
	return true;
}
（15）打印顺序表
/*==============打印================*/
void List_Show(const List *L){
	int i = 0;
	/*链表已销毁*/
	if(L->size == -1){
		fprintf(stderr,"list is not exist\n");
		exit(1);
	}
	for(i = 0;i < L->len;i++){
		printf("%d\t",L->data[i]);
	}
	putchar('\n');
}
古予一
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构---顺序表
方池安夏的博客
03-06 1014
目录顺序表原理顺序表的算法实现顺序表的初始化顺序表增加元素顺序表插入元素顺序表删除元素顺序表销毁顺序表遍历完整代码 顺序表原理 顺序表是简单的一种线性结构，逻辑上相邻的数据在计算机内的存储位置也是相邻的，可以 快速定位第几个元素，中间不允许有空值，插入、删除时需要移动大量元素。 顺序表的三个要素： 用elems记录存储位置的基地址 分配一段连续的存储空间size 用length记录实际的元素个数，即顺序表的长度 顺序表的算法实现 顺序表的初始化 #include <stdio.h> #
数据结构初阶——顺序表
m0_64607843的博客
04-29 1万+
博客写到这里，关于C语言的相关内容就告一段落了，从这篇开始，跟我一起进入一个全新的领域吧。把顺序表的代码放到了结尾。击鼓进军数据结构！！！
＜数据结构＞ 顺序表
bit_zyx的博客
03-13 9647
目录 一、顺序表介绍 二、准备工作 1、创建顺序表 2、初始化顺序表 3、检测是否需要扩容 4、销毁顺序表 5、打印顺序表 三、四大功能 1、增加数据 头插 尾插 指定下标插入 2、删除数据 头删 ...
数据结构：顺序表的基本操作
热门推荐
Keep Fighting All The Time
05-03 10万+
线性表的顺序存储 顺序表的线性存储示意图 C语言定义线性表的顺序存储结构 线性表的顺序存储        线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中，即：通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。采用顺序存储结构存储的线性表通常简称为顺序表。        顺序存
数据结构篇——顺序表
handsomeRE的博客
06-16 809
数据结构篇——顺序表
数据结构——顺序表的合并
qq_45966201的博客
02-02 1万+
数据结构——顺序表的合并 具体要求：写一个函数，其函数的功能是将非递增顺序表LA和LB合并到非递增顺序表LC中 数据结构—顺序表的操作之合并顺序表 一、顺序表的结构 首先要定义的是顺序表的结构体，只有先定义了顺序表的结构体类型，才可以继续进行下一步操作 #define maxsize 100 typedef struct { int elem[maxsize];//线性表元素 int last;//线性表长度 }SeqList; 二、顺序表的操作 1.生成顺序表 在有了顺序表的结构之后，
数据结构——顺序表（C语言编写）
新手小白
09-17 7994
数据结构，顺序表应用 插入、删除、合并...
数据结构——顺序表（定义、实现）
weixin_62677583的博客
12-19 3053
这里写目录标题一级目录二级目录三级目录 一级目录 二级目录 三级目录
数据结构——顺序表的建立和基本操作
06-16
顺序表的建立和基本操作，主要含有顺序表的定义，顺序表的初始化，顺序表的插入操作，删除操作，按位查找和按值查找操作的算法，以及完整的函数调用流程。数据结构的代码实现。
【数据结构-二位前缀和】【二分查找】【枚举优化】力扣1292. 元素和小于等于阈值的正方形的最大边长
sjsjs11的博客
09-04 907
这道题的精髓在于二分查找的使用，由于我们要找到最大的边长，那么我们是不是通常来想，需要遍历从1到矩阵较短边长度的正方形边长，然后把边长一个个去矩阵中寻找是否有合适的正方形。输入：mat = [[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2]], threshold = 1。输入：mat = [[1,1,3,2,4,3,2],[1,1,3,2,4,3,2],[1,1,3,2,4,3,2]], threshold = 4。
数据结构（五）----树（含堆）
weixin_73579966的博客
09-04 1071
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的.1.最上面的称为根结点，它没有前驱结点。2.除了根结点，其余结点被分成多个互不相交的集合，其中每个集合又是一棵子树，这些子树的根节点只有一个前驱，可以有0或多个后继3.树是递归定义的。一棵树：子树不能相交总的来说，二叉树的主要难点在于链式二叉树，而其中最重要的思想在于——递归，把大事化为一个重复递归的小事，而贯穿其中的方法是：画图。
数据结构(6.4_6)——拓扑排序
m0_65240792的博客
09-04 315
AOV网：用顶点表示活动的网。用DAG图(有向无环图)表示一个工程，顶点表示活动，有向边<Vi,Vj>表示活动Vi必须先于vj进行回顾：入度即为以顶点为终点的边的数目 代码思路：通过for循环将所有度为0结点的indgree[]下标压入栈中，并初始化print[]数组，使其所有元素为-1，方便记录，再将count指向第一个print数组元素，任何进行while判断，如果栈不为空，则将栈顶元素i弹出栈并进入print数组，count指向下一个数组元素，再通过for循环遍历图中i的所有邻结点，将其度-1，若
数据结构-栈、队列-详解
2401_86587256的博客
09-04 1161
数据结构初阶部分，栈和队列的详解
数据结构（1）数据结构基础（单向链表）
weixin_68239724的博客
09-03 660
数据结构是一组用来保存一种或多种特定关系的数据的集合。其主要目的是组织和存储数据，以便于高效的访问和修改。程序 = 数据结构 + 算法单向链表是一种线性数据结构，由一系列节点构成，每个节点包含数据部分和指向下一个节点的指针。它是一种灵活的存储方式，相比于数组，单向链表不需要连续的内存空间。
数据结构——单链表实现和注释浅解
最新发布
hedhjd的博客
09-07 215
【代码】数据结构——单链表实现和注释浅解。
考研系列-408真题数据结构篇(18-23)
Nelson_hehe的博客
09-04 235
此文章是本人在备考过程中408真题数据结构部分（2018年-2023年）的易错题及相应的知识点整理，后期复习也尝尝用到，对于知识提炼归纳理解起到了很大的作用，分享出来希望帮助到大家~
数据结构--经典排序之选择排序（超详细！！）
2301_79381549的博客
09-04 679
它的工作原理是，首先在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。.如果在交换之前，max恰好是begin，那么由于begin位置的值已经被交换出去，我们需要更新max为min的位置。.接着，我们使用Swap函数将begin位置的值与最小值进行交换，这样确保了begin位置始终是已排序的最小值。.Swap 函数是一个简单的值交换函数，它接受两个整数的指针，并交换它们所指向的值。
大学软件工程课堂：数据结构实验——顺序表与链表应用
具体任务是用这两种数据结构实现课本算法2.2——合并两个非递减有序序列，同时分析其时间性能。这不仅锻炼了他们的编程技能，还提升了对算法效率的评估能力。 每个实验报告会由指导教师评阅，评价标准涉及实验目的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值