• 数据结构：顺序表的奥秘

    🎉个人名片：

    🐼作者简介：一名乐于分享在学习道路上收获的大二在校生
    🐻‍❄个人主页🎉：GOTXX
    🐼个人WeChat：ILXOXVJE
    🐼本文由GOTXX原创，首发CSDN🎉🎉🎉
    🕊系列专栏：零基础学习C语言----- 数据结构的学习之路
    🐓每日一句：如果没有特别幸运，那就请特别努力！🎉🎉🎉
    ————————————————

    🎉文章简介：

    🎉本篇文章对   用C语言实现顺序表 学习的相关知识进行分享！🎉

    如果您觉得文章不错，期待你的一键三连哦，你的鼓励是我创作动力的源泉，让我们一起加油，一起奔跑，让我们顶峰相见！！！🎉🎉🎉

    目录

    一.顺序表的概念及存储结构

    1.1储存结构

    二.顺序表的实现

    一.功能函数的实现

    1.初始化函数

    2.顺序表的销毁

    3.顺序表的打印

    4.扩容函数

    5.尾插函数

    6.尾删函数

    7.头插函数

    8.头删函数

    9.插入函数

    10.删除函数

    11.查找函数

    12.修改函数

    三.总代码

    四.顺序表的性能分析

    一.顺序表的概念及存储结构

    顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

    顺序表可以分为静态顺序表和动态顺序表。

    1.1储存结构

    静态顺序表：使用定长数组存储元素；

    动态顺序表：数组的大小是根据存储的数据个数，如果满了就动态开辟出来的，相对而言不会造成空间的浪费；

    二.顺序表的实现

    静态顺序表 只适用于确定知道需要存多少数据的场景；

    静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。例如：如果数组的大小定为200，却只储存了几十个数据，和动态的顺序表相比，空间浪费更大；所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

    一.功能函数的实现（含图解）

    1.初始化函数

    功能：对结构体内成员进行初始化操作；

    代码实现：

    1. void InitList(SL* s)
    2. {
    3. 	assert(s);        //断言，防止传入空指针
    4.  
    5. 	s->a = (SLDateType* )malloc(sizeof(SLDateType) * 4);  
    6. 	if (s->a == NULL)   //这里最开始开辟四个存储数据类型的大小
    7. 	{
    8. 		perror("malloc fail");
    9. 		exit(-1);
    10. 	}
    11. 	s->size = 0;            //存储的有效数据个数为0
    12. 	s->capacity = 4;       //空间置成4
    13. }

    2.顺序表的销毁

    功能：对动态开辟的空间进行销毁，空间释放

    代码实现：

    1. void DestoryList(SL* s)
    2. {
    3. 	assert(s);
    4.  
    5. 	free(s->a);       //释放动态开辟的空间
    6. 	s->a = NULL;      //置空
    7. 	s->capacity = s->size = 0;
    8. }

    3.顺序表的打印

    代码实现：

    1. void SListPrintf(SL* s)
    2. {
    3. 	assert(s);
    4.  
    5. 	if (s->size < 0)     //如果没有数据，则直接返回
    6. 	{
    7. 		return;
    8. 	}
    9. 	for (int i = 0; i < s->size; i++)
    10. 	{
    11. 		printf("%d ", s->a[i]);       //遍历依次打印
    12. 	}
    13. 	printf("\n");        //打印完换行
    14. }

    4.扩容函数

    功能：检查是否需要扩容

    代码实现：

    1. void CheckCapacity(SL* s)
    2. {
    3. 	assert(s);
    4.  
    5. 	if (s->capacity == s->size)    //相等则说明空间已经满了
    6. 	{
    7. 		SLDateType* tmp = realloc(s->a, sizeof(SLDateType)* 2 * s->capacity);  //二倍扩容
    8. 		if (tmp == NULL)    
    9. 		{
    10. 			perror("realloc fail");
    11. 			exit(-1);
    12. 		}
    13.  
    14. 		s->a = tmp;
    15. 		s->capacity *= 2;
    16.  
    17. 	}
    18. }

    5.尾插函数

    功能：在顺序表最后插入一个数据

    代码实现：

    1. void PushBack(SL* s, SLDateType n)
    2. {
    3. 	assert(s);
    4.  
    5. 	CheckCapacity(s);  //检查空间是否满
    6. 	s->a[s->size] = n;    //直接插入到数组最后
    7. 	s->size++;       //有效数据个数++
    8. }

    6.尾删函数

    功能: 删除顺序表的最后一个数据

    代码实现：

    1. void PopBack(SL* s)
    2. {
    3. 	assert(s);
    4. 	assert(s->size > 0);     //当数组中有效数据个数为0时，不能再删除
    5.  
    6. 	s->size--;         //数据个数--
    7.  
    8. }

    7.头插函数

    功能：在顺序表最前面插入一个数据

    代码实现：

    1. void PushFront(SL* s, SLDateType n)
    2. {
    3. 	assert(s);
    4. 	CheckCapacity(s);    //检查扩容
    5.  
    6. 	int end = s->size;    
    7. 	while (end>0) 
    8. 	{
    9. 		s->a[end] = s->a[end - 1];   //挪动数据
    10. 		end--;
    11. 	}
    12. 	s->a[0] = n;         
    13. 	s->size++;
    14. }

    图解：

    性能分析：头插一个数据，首先需要将全部数据一次往后挪一个位置，时间复杂度：O(N)   

    是在原数组上进行挪动的，空间复杂度：O(1)

    8.头删函数

    功能：删除表中第一个元素

    代码实现：

    1. void Popfront(SL* s)
    2. {
    3. 	assert(s);
    4. 	assert(s->size > 0);   //size为0时，不能再删除
    5.  
    6. 	for (int i = 0; i < s->size; i++)
    7. 	{
    8. 		s->a[i] = s->a[i+1];      //向前挪动数据
    9. 	}
    10.  
    11. 	s->size--;
    12. }

    图解：

    性能分析：头删一个数据，首先需要将全部数据一次往前挪一个位置，将第一个元素覆盖掉，时间复杂度：O(N)   

    是在原数组上进行挪动的，空间复杂度：O(1)

    9.插入函数

    功能：在某个位置插入一个数据

    代码实现：

    1.  
    2. void SListInsert(SL* s, int pos, SLDateType n)
    3. {
    4. 	assert(s);
    5. 	assert(pos >= 0 && pos <= s->size);    //判断pos合法
    6.  
    7. 	int end = s->size;
    8. 	int begin = pos;
    9. 	while (begin < end)
    10. 	{
    11. 		s->a[end] = s->a[end - 1];   //挪动数据
    12. 		end--;
    13. 	}
    14. 	s->a[pos] = n;       //修改数据
    15. 	s->size++;
    16. }

    图解：

    性能分析：中间插入一个数据和头插差不多，首先需要将该位置后面的全部数据依次往后挪一个位置，将该位置空出来，再将该数据插入，时间复杂度：O(N)   

    是在原数组上进行挪动的，空间复杂度：O(1)

    10.删除函数

    功能：删除数组中任何位置的数据

    代码实现：

    1. void SListErase(SL* s, int pos)
    2. {
    3. 	assert(s);
    4. 	assert(pos >= 0 && pos < s->size);    //pos范围合法判断
    5.  
    6. 	int cur = pos;
    7. 	while (cur < s->size)
    8. 	{
    9. 		s->a[cur] = s->a[cur+1];    //挪动位置
    10. 		cur++;
    11. 	}
    12. 	s->size--;
    13.  
    14. }

    图解：

    性能分析：删除一个数据与头删差不多，首先需要待删数据位置后面全部数据依次往前挪一个位置，将待删元素覆盖掉，时间复杂度：O(N)   

    是在原数组上进行挪动的，空间复杂度：O(1)

    11.查找函数

    功能：查找顺序表中某个数据，返回下标

    代码实现：

    1. int SListFind(SL* s,SLDateType n)
    2. {
    3. 	assert(s);
    4.  
    5. 	for (int i = 0; i < s->size; i++)    //遍历寻找
    6. 	{
    7. 		if (s->a[i] == n)     //找到了返回下标
    8. 		{ 
    9. 			return i;
    10. 		}
    11. 	}
    12.  
    13. 	printf("顺序表中无该数据\n");   
    14. 	exit(-1);
    15.  
    16. }

    性能分析：将数组中的数据遍历一遍；时间复杂度：O(N)

    空间复杂度：O(1)

    12.修改函数

    功能：修改数组中某个数据

    代码实现：

    1. void SListModify(SL* s, int pos,SLDateType n)
    2. {
    3. 	assert(s);
    4. 	assert(pos >= 0 && pos < s->size);
    5.  
    6. 	s->a[pos] = n;     //直接通过下标访问修改
    7. }

    三.总代码

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5.  
    6.  
    7. typedef int SLDateType;
    8.  
    9. struct SeqList
    10. {
    11. 	SLDateType* a;      //指向一个数组的指针
    12. 	int size;           //记录数据个数
    13. 	int capacity;       //记录容量，如果与数据个数相等就扩容
    14. };
    15.  
    16. typedef struct SeqList SL;
    17.  
    18.  
    19. void InitList(SL* s);
    20.  
    21. void SListPrintf(SL* s);
    22.  
    23. void PushBack(SL* s, SLDateType n);
    24. void PushFront(SL* s, SLDateType n);
    25. void PopBack(SL* s);
    26. void Popfront(SL* s);
    27.  
    28. int SListFind(SL* s,SLDateType n);
    29.  
    30. void SListModify(SL* s, int pos, SLDateType n);
    31. void SListErase(SL* s, int pos);
    32. void SListInsert(SL* s, int pos, SLDateType n);
    33.  
    34.  
    35. void DestoryList(SL* s);

    1. #include"SeqList.h"
    2.  
    3.  
    4.  
    5. void InitList(SL* s)
    6. {
    7. 	assert(s);        //断言，防止传入空指针
    8.  
    9. 	s->a = (SLDateType* )malloc(sizeof(SLDateType) * 4);  
    10. 	if (s->a == NULL)   //这里最开始开辟四个存储数据类型的大小
    11. 	{
    12. 		perror("malloc fail");
    13. 		exit(-1);
    14. 	}
    15. 	s->size = 0;            //存储的有效数据个数为0
    16. 	s->capacity = 4;       //空间置成4
    17. }
    18.  
    19. void SListPrintf(SL* s)
    20. {
    21. 	assert(s);
    22.  
    23. 	if (s->size < 0)     //如果没有数据，则直接返回
    24. 	{
    25. 		return;
    26. 	}
    27. 	for (int i = 0; i < s->size; i++)
    28. 	{
    29. 		printf("%d ", s->a[i]);       //遍历依次打印
    30. 	}
    31. 	printf("\n");        //打印完换行
    32. }
    33.  
    34.  
    35. void CheckCapacity(SL* s)
    36. {
    37. 	assert(s);
    38.  
    39. 	if (s->capacity == s->size)    //相等则说明空间已经满了
    40. 	{
    41. 		SLDateType* tmp = realloc(s->a, sizeof(SLDateType)* 2 * s->capacity);  //二倍扩容
    42. 		if (tmp == NULL)    
    43. 		{
    44. 			perror("realloc fail");
    45. 			exit(-1);
    46. 		}
    47.  
    48. 		s->a = tmp;
    49. 		s->capacity *= 2;
    50.  
    51. 	}
    52. }
    53.  
    54. void PushBack(SL* s, SLDateType n)
    55. {
    56. 	assert(s);
    57.  
    58. 	CheckCapacity(s);  //检查空间是否满
    59. 	s->a[s->size] = n;    //直接插入到数组最后
    60. 	s->size++;       //有效数据个数++
    61. }
    62.  
    63. void PushFront(SL* s, SLDateType n)
    64. {
    65. 	assert(s);
    66. 	CheckCapacity(s);    //检查扩容
    67.  
    68. 	int end = s->size;    
    69. 	while (end>0) 
    70. 	{
    71. 		s->a[end] = s->a[end - 1];   //挪动数据
    72. 		end--;
    73. 	}
    74. 	s->a[0] = n;         
    75. 	s->size++;
    76. }
    77.  
    78. void PopBack(SL* s)
    79. {
    80. 	assert(s);
    81. 	assert(s->size > 0);     //当数组中有效数据个数为0时，不能再删除
    82.  
    83. 	s->size--;         //数据个数--
    84.  
    85. }
    86.  
    87.  
    88. void Popfront(SL* s)
    89. {
    90. 	assert(s);
    91. 	assert(s->size > 0);   //size为0时，不能再删除
    92.  
    93. 	for (int i = 0; i < s->size; i++)
    94. 	{
    95. 		s->a[i] = s->a[i+1];      //向前挪动数据
    96. 	}
    97.  
    98. 	s->size--;
    99. }
    100.  
    101.  
    102. int SListFind(SL* s,SLDateType n)
    103. {
    104. 	assert(s);
    105.  
    106. 	for (int i = 0; i < s->size; i++)    //遍历寻找
    107. 	{
    108. 		if (s->a[i] == n)     //找到了返回下标
    109. 		{ 
    110. 			return i;
    111. 		}
    112. 	}
    113. 	printf("顺序表中无该数据\n");   
    114. 	exit(-1);
    115. }
    116.  
    117. void SListModify(SL* s, int pos,SLDateType n)
    118. {
    119. 	assert(s);
    120. 	assert(pos >= 0 && pos < s->size);
    121.  
    122. 	s->a[pos] = n;     //直接通过下标访问修改
    123. }
    124.  
    125.  
    126. void SListErase(SL* s, int pos)
    127. {
    128. 	assert(s);
    129. 	assert(pos >= 0 && pos < s->size);    //pos范围合法判断
    130.  
    131. 	int cur = pos;
    132. 	while (cur < s->size)
    133. 	{
    134. 		s->a[cur] = s->a[cur+1];    //挪动位置
    135. 		cur++;
    136. 	}
    137. 	s->size--;
    138.  
    139. }
    140.  
    141. void SListInsert(SL* s, int pos, SLDateType n)
    142. {
    143.  
    144. 	assert(s);
    145. 	assert(pos >= 0 && pos <= s->size);    //判断pos合法
    146.  
    147. 	int end = s->size;
    148. 	int begin = pos;
    149. 	while (begin < end)
    150. 	{
    151. 		s->a[end] = s->a[end - 1];   //挪动数据
    152. 		end--;
    153. 	}
    154.  
    155. 	s->a[pos] = n;       //修改数据
    156. 	s->size++;
    157. }
    158.  
    159.  
    160. void DestoryList(SL* s)
    161. {
    162. 	assert(s);
    163.  
    164. 	free(s->a);       //释放动态开辟的空间
    165. 	s->a = NULL;      //置空
    166. 	s->capacity = s->size = 0;
    167. }

    四.顺序表的性能分析

    问题：


    1. 中间/头部的插入删除，时间复杂度为O(N);
    2. 增容需要申请新空间，拷贝数据，释放旧空间,会有不小的消耗;
    3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间;

    思考：如何解决以上问题呢？

    下一章链表结构就可以解决这个问题；

  • 相关阅读:
    Codeforces Round #816 (Div. 2)
    关于遥感像元反射率的思考
    像Django一样开发FastAPI之: AppBoot 入门指南
    【Python 零基础入门】基础语法
    一文了解和使用nginx（附带图文）
    介绍一个.Net远程日志组件
    一、Unity环境安装
    git版本管理的使用
    宝塔面板搭建网站教程：Linux下使用宝塔一键搭建网站，内网穿透发布公网上线
    【Spring】IoC容器 控制反转 与 DI依赖注入 XML实现版本 第二期
  • 原文地址：https://blog.csdn.net/2301_77509762/article/details/136527603