• 【数据结构初阶】二、 线性表里的顺序表

    =========================================================================

    相关代码gitee自取：

    C语言学习日记: 加油努力 (gitee.com)

     =========================================================================

    接上期：

    【数据结构初阶】一. 复杂度讲解_高高的胖子的博客-CSDN博客

     =========================================================================

                          

    1 . 线性表

                   

    线性表（linear list）是n个具有相同特性的数据元素的有限序列。

    线性表是一种在实际中广泛使用的数据结构，

    常见的线性表：顺序表、链表、栈、队列、字符串...

    顺序表示例：

                  

                  

    线性表在逻辑上是线性结构，也就说是连续的一条直线。

    但是在物理结构上并不一定是连续的，

    线性表在物理上存储时，通常以数组和链式结构的形式存储。

    链表示例：

             

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                 

    2 . 顺序表

    顺序表概念及结构：

                   

    顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，

    一般情况下采用数组存储，

    在数组上完成数据的增删查改，

    顺序表一般可以分为 静态顺序表 和 动态顺序表

                   

                   

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

                    

    因为静态顺序表使用定长数组存储元素，

    对空间的运用不够灵活，可能造成空间浪费或不够的问题，
    所以在实际情况下，静态顺序表并不常用（不够实用）

    示例：

                        

                        

    动态顺序表：使用动态开辟的数组存储元素

                 

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

    静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。

    所以现实中基本都是使用动态顺序表，根据需要动态地分配空间大小

    示例：

             

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                 

    3 .接口实现(实现动态顺序表)：

    （详细解释在注释，代码分文件放最后）

                    

    数据结构可以管理数据，

    通过 增删改查 等操作就可以实现管理数据

                  

    现在有了动态顺序表后，

    就可以对其进行增删改查等操作来实现动态顺序表

                          

                            

    --------------------------------------------------------------------------------------------------------------------------

                      

                          

    SLInit函数 -- 顺序表初始化

                          

                          

    --------------------------------------------------------------------------------------------------------------------------

                      

                          

    SLDestroy函数 -- 顺序表销毁

                          

                            

    --------------------------------------------------------------------------------------------------------------------------

                      

                          

    SLPrint函数 -- 测试函数

                          

                            

    --------------------------------------------------------------------------------------------------------------------------

                      

                          

    SLPushBack函数 -- 将值插入顺序表尾部（尾插）

    尾插函数SLPushBack测试：

                          

                            

    --------------------------------------------------------------------------------------------------------------------------

                      

                          

    上面尾插需要考虑空间不够进行扩容，

    后面的头插同样也需要考虑，

    所以可以在顺序表实现文件中设置一个内部函数SLCheckCapacity,

    在需要的时候直接调用该函数进行扩容操作

    ↓↓↓↓↓

                     

    SLCheckCapacity内部函数 -- 进行扩容操作

                          

                            

    --------------------------------------------------------------------------------------------------------------------------

                      

                          

    SLPopBack函数 -- 将值从顺序表尾部删除（尾删）

    尾删函数SLPopBack测试：

                          

                            

    --------------------------------------------------------------------------------------------------------------------------

                      

                          

    SLPushFront函数 -- 将值插入顺序表头部（头插）

    头插函数SLPushFront测试：

                          

                            

    --------------------------------------------------------------------------------------------------------------------------

                      

                          

    SLPopFront函数 -- 将值从顺序表头部删除（头删）

    头删函数SLPopFront测试：

                          

                            

    --------------------------------------------------------------------------------------------------------------------------

                      

                          

    SLInsert函数 -- 在指定位置（pos）插入想要的值（x）

    指定添加函数SLInsert测试：

                 

    这里写了指定位置插入SLInsert函数后，

    可以想到其实 头插 和 尾插 也是可以用 SLInsert函数 实现的，

    所以可以在头插和尾插函数中复用 SLInsert函数 来减少代码量

    ↓↓↓↓↓

                      

    复用SLInsert函数 -- 改写头插函数SLPushFront

                         

    复用SLInsert函数 -- 改写尾插函数SLPushBack

                          

                            

    --------------------------------------------------------------------------------------------------------------------------

                      

                          

    上面SLInsert函数中涉及了插入位置pos下标，

    有时在增删改查操作时，需要知道有效元素中某个元素的下标再进行操作，

    所以我们可以定义一个函数SLFind来查找该元素的下标

    ↓↓↓↓↓

                     

    SLFind函数 -- 查找x这个值在顺序表中的下标是多少

    查找函数SLFind测试：

                          

                            

    --------------------------------------------------------------------------------------------------------------------------

                      

                          

    SLErase函数 -- 删除指定位置（pos）的值

    删除指定位置函数SLErase测试：

                       

    完成指定删除SLErase函数后，

    头删 和 尾删 函数中也可以进行复用 SLErase函数 来减少代码量

    ↓↓↓↓↓

                      

    复用SLErase函数 -- 改写头删函数SLPopFront

                         

    复用SLErase函数 -- 改写尾删函数SLPopBack

                          

                            

    --------------------------------------------------------------------------------------------------------------------------

                      

                          

    SLModify函数 -- 把某个位置（pos）的值修改为某值（x）

    修改函数SLModify测试：

              

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                 

    4 . 对应代码

    SeqList.h -- 顺序表头文件

    1. #pragma once
    2.  
    3. 定义一个静态顺序表：使用定长数组存储元素
    4. 因为静态顺序表使用定长数组存储元素，对空间的运用不够灵活
    5. 所以在实际情况下，静态顺序表并不常用（不够实用）
    6. //
    7. //#define N 1000  //“表”的大小的值
    8. //typedef int SLDataType;  //定义顺序表中存储的类型，这里是int类型
    9. //
    10. //struct SeqList
    11. //{
    12. //	SLDataType a[N]; //定义表的大小
    13. //	int size; //记录表中存储了多少个有效数据
    14. //};
    15.  
    16.  
    17. //将需要的头文件都包含在 SeqList.h 头文件中
    18. #include 
    19. #include 
    20. #include 
    21.  
    22.  
    23. //定义一个动态顺序表：使用动态开辟的数组存储元素
    24. typedef int SLDataType;  //定义顺序表中存储的类型，这里是int类型
    25.  
    26. typedef struct SeqList
    27. {
    28. 	//定义一个顺序表类型的指针，指向动态开辟的数组
    29. 	SLDataType* a; 
    30. 	
    31. 	int size; //记录表中存储了多少个有效数据
    32. 	int capactity; //容量空间的大小
    33. }SL;
    34.  
    35.  
    36. //数据结构 --> 管理数据 --> 增删查改
    37.  
    38. //顺序表初始化  --  头文件中声明
    39. void SLInit(SL* ps); 
    40.  
    41. //顺序表销毁 --  头文件中声明
    42. //内存是动态开辟地，不销毁的话可能会导致内存泄漏)
    43. void SLDestroy(SL* ps);
    44.  
    45. //写一个测试函数(声明)，方便检查各步骤有没有问题：
    46. void SLPrint(SL* ps);
    47.  
    48. //尾插（声明） -- 将值插入顺序表尾部：
    49. void SLPushBack(SL* ps, SLDataType x);
    50.  
    51. //尾删（声明） -- 将值从顺序表尾部删除：
    52. void SLPopBack(SL* ps);
    53.  
    54. //头插（声明） -- 将值插入顺序表头部：
    55. void SLPushFront(SL* ps, SLDataType x);
    56.  
    57. //头删（声明） -- 将值从顺序表头部删除：
    58. void SLPopFront(SL* ps);
    59.  
    60. //在指定位置（pos）插入想要的值（x）
    61. void SLInsert(SL* ps, int pos, SLDataType x);
    62.  
    63. //查找x这个值在顺序表中的下标是多少：
    64. int SLFind(SL* ps, SLDataType x); //返回找到的下标
    65.  
    66. //删除指定位置（pos）的值：
    67. void SLErase(SL* ps, int pos);
    68.  
    69. //把某个位置（pos）的值修改为某值（x）
    70. void SLModify(SL* ps, int pos, SLDataType x);

                            

    --------------------------------------------------------------------------------------------------------------------------

                      

                          

    SeqList.c -- 顺序表实现文件

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. //包含我们写的 SeqList.h 头文件
    4. #include "SeqList.h"
    5.  
    6.  
    7. //顺序表初始化 -- 实现
    8. void SLInit(SL* ps)
    9. {
    10. 	//assert断言，防止接收空指针：
    11. 	assert(ps);
    12.  
    13. 	//初始化顺序表类型指针
    14. 	//初始化时要先开辟一些动态空间：
    15. 	//开辟的空间为顺序表类型，大小为4个顺序表类型的大小
    16. 	ps->a = (SLDataType*)malloc(sizeof(SLDataType)*4); 
    17. 	
    18. 	//顺序表作为一个独立的程序，之后可能会应用于其他程序，
    19. 	//所以要对开辟的动态空间进行检查：
    20. 	if (ps->a == NULL)
    21. 	{
    22. 		//可能开辟的空间过大 或 前面开辟太多空间不够再开辟
    23. 		perror("malloc failed");  //打印错误
    24.  
    25. 		//让程序以异常的形式结束程序
    26. 		//和 return 不同，return后主函数还会继续进行
    27. 		exit(-1);
    28. 	}
    29.  
    30. 	//将顺序表中的有效数据初始化为0：
    31. 	ps->size = 0;
    32.  
    33. 	//将已动态开辟的容量空间初始化为4：
    34. 	ps->capactity = 4;
    35. }
    36.  
    37.  
    38.  
    39. //顺序表销毁 -- 实现
    40. //内存是动态开辟地，不销毁的话可能会导致内存泄漏)
    41. void SLDestroy(SL* ps)
    42. {
    43. 	//assert断言，防止接收空指针：
    44. 	assert(ps);
    45.  
    46. 	//释放前面开辟的动态空间：
    47. 	free(ps->a);
    48. 	
    49. 	//将释放的指针置为空指针：
    50. 	ps->a = NULL;
    51.  
    52. 	//将已开辟的动态空间置为0，顺序表有效数据也置为0
    53. 	ps->capactity = ps->size = 0;
    54. }
    55.  
    56.  
    57.  
    58. //写一个测试函数(实现)，方便检查各步骤有没有问题：
    59. void SLPrint(SL* ps)
    60. {
    61. 	//assert断言，防止接收空指针：
    62. 	assert(ps);
    63.  
    64. 	//打印动态顺序表现有的有效数据：
    65. 	for (int i = 0; i < ps->size; i++)
    66. 	{
    67. 		printf("%d ", ps->a[i]);
    68. 	}
    69.  
    70. 	//打印完当前动态顺序表有效数据后进行换行：
    71. 	printf("\n");
    72. }
    73.  
    74.  
    75.  
    76. //在顺序表实现文件中设置一个内部函数SLCheckCapacity,
    77. //在需要的时候直接调用该函数进行扩容操作
    78. void SLCheckCapacity(SL* ps)
    79. {
    80. 	//assert断言，防止接收空指针：
    81. 	assert(ps);
    82.  
    83. 	//判断开辟的空间是否已满，满了再开辟：
    84. 	if (ps->size == ps->capactity)
    85. 		//顺序表有效个数 等于 已开辟容量空间
    86. 	{
    87. 		//使用 realloc函数 进行扩容，每次扩容2倍：
    88. 		SLDataType* tmp = (SLDataType*)realloc(ps->a, ps->capactity * 2 * (sizeof(SLDataType)));
    89. 		// realloc 是把空间扩容到第二个参数的大小，而不是直接把空间扩容第二个参数的大小
    90.  
    91. 		//同样进行检验：
    92. 		if (tmp == NULL)
    93. 		{
    94. 			//打印错误：
    95. 			perror("realloc failed");
    96. 			//出现错误直接终止程序：
    97. 			exit(-1);
    98. 		}
    99.  
    100. 		//realloc函数，有两种扩容情况：一种是原地扩容，另一种是异地扩容
    101. 		//原地扩容：扩容时看原空间后的内容有没有分配给别人，如果没有则把原空间后面的空间标记出来进行扩容，返回原空间的地址
    102. 		//异地扩容：如果扩容时原空间后面的内容已被分配，则另找一个足够原空间扩容后的空间进行存放，
    103. 		//		   原本的数据都搬到这个空间来，原空间会被释放，返回这个新空间的地址。
    104. 		//所以使用 realloc函数 扩容后，不要对原空间指针进行释放，
    105. 		//如果realloc执行后是原地扩容返回原空间指针，扩容后后对原空间指针释放就会出问题
    106.  
    107.  
    108. 		//把扩容返回的指针赋给原指针：
    109. 		ps->a = tmp;
    110.  
    111. 		//将已动态开辟的容量空间置为原来的2倍：
    112. 		ps->capactity *= 2;
    113. 	}
    114. }
    115.  
    116.  
    117.  
    118. //尾插（实现） -- 将值插入顺序表尾部：
    119. void SLPushBack(SL* ps, SLDataType x)
    120. {
    121. 	//assert断言，防止接收空指针：
    122. 	assert(ps);
    123.  
    124. 	调用内部函数进行扩容操作：
    125. 	//SLCheckCapacity(ps);
    126.  
    127. 	空间容量足够后将要插入尾部的值插入：
    128. 	//ps->a[ps->size] = x; 
    129. 	因为下标从0开始，所以size的值会等于现有元素下一位的下标
    130.  
    131. 	//ps->size++; //尾部插入元素后，更新顺序表中有效数据个数
    132.  
    133. 	//复用SLInsert函数 -- 改写尾插函数SLPushBack
    134. 	SLInsert(ps, ps->size, x); //在size位置插入就相当于尾插
    135. }
    136.  
    137.  
    138.  
    139. //尾删（实现） -- 将值从顺序表尾部删除：
    140. void SLPopBack(SL* ps)
    141. {
    142. 	//assert断言，防止接收空指针：
    143. 	assert(ps);
    144.  
    145. 	检查一下：如果有效数据size等于0，则不能继续删除了
    146. 	防止越界，可能一直删除到空间外了导致越界
    147. 	//
    148. 	检查方法一：太“温柔”，返回后不知道自己错了
    149. 	if (ps->size == 0)
    150. 	{
    151. 		return; //直接返回 即可
    152. 	}
    153. 	//
    154. 	检查方法二：使用断言，错误了会直接报错并给出错误信息
    155. 	//assert(ps->size > 0); //顺序表中有效数据大于0才进行下面的操作
    156.  
    157. 	直接有效数据size--即可
    158. 	尾插是也是用size插入的，所以下次添加时直接就覆盖了原来值
    159. 	//ps->size--;
    160.  
    161. 	不能局部释放，不能说不要末尾的值就把末尾的这个空间直接释放掉
    162. 	C++有个规定，malloc一次就要free一次，要free释放的话只能整体释放
    163. 	顺序表的物理内存是连续的，释放空间是不能“分期”的
    164.  
    165.  
    166. 	//复用SLErase函数 -- 改写尾删函数SLPopBack
    167. 	SLErase(ps, ps->size-1); //size-1 就是最末元素下标
    168. }
    169.  
    170.  
    171.  
    172. //头插（实现） -- 将值插入顺序表头部：
    173. void SLPushFront(SL* ps, SLDataType x)
    174. {
    175. 	//assert断言，防止接收空指针：
    176. 	assert(ps);
    177.  
    178. 	调用内部函数进行扩容操作：
    179. 	//SLCheckCapacity(ps);
    180.  
    181. 	将现有有效数据往后移一位，让出头位置：
    182. 	//int end = ps->size - 1; 
    183. 	size-1 有效个数-1，就相当于当前最后一个元素的下标
    184.  
    185. 	//while (end >= 0)
    186. 	//	//使用while循环循环移动各个有效元素，一直移到下标为0的元素
    187. 	//{
    188. 	//	ps->a[end + 1] = ps->a[end]; //end下标元素 移到 下一位上
    189. 	//	--end; //改变下标
    190. 	//}
    191.  
    192. 	将要插入头部的元素x插入头部：
    193. 	//ps->a[0] = x;
    194.  
    195. 	有效个数加一：
    196. 	//ps->size++;
    197.  
    198. 	Capacity在扩容函数SLCheckCapacity中就修改好了
    199.  
    200.  
    201. 	//复用SLInsert函数 -- 改写头插函数SLPushFront
    202. 	SLInsert(ps, 0, x); //在0位置插入就相当于头插
    203. }
    204.  
    205.  
    206.  
    207. //头删（实现） -- 将值从顺序表头部删除：
    208. void SLPopFront(SL* ps)
    209. {
    210. 	//assert断言，防止接收空指针：
    211. 	assert(ps);
    212.  
    213. 	因为要将头部的有效元素删除，
    214. 	所以直接把第一个有效元素后面的其他元素往前移一位就行了，
    215. 	覆盖掉第一个元素
    216.  
    217. 	先进行断言检查，防止没有元素还进行删除：
    218. 	//assert(ps->size > 0);
    219.  
    220. 	//int begin = 1; //从下标为1的元素开始往前移，把下标为0的元素覆盖
    221.  
    222. 	//while (begin < ps->size)
    223. 	//	//只要begin还小于有效元素个数就继续往前移
    224. 	//	//因为是从下标为1的元素开始移动，
    225. 	//	//所以最后就只有下标为0的元素没动
    226. 	//{
    227. 	//	//把当前begin下标的元素往前挪一位：
    228. 	//	ps->a[begin - 1] = ps->a[begin]; 
    229.  
    230. 	//	//当前begin下标元素移动后，begin++继续移动下一位：
    231. 	//	++begin;
    232. 	//}
    233. 	//
    234. 	因为第一个元素被覆盖，所以有效元素size--
    235. 	//ps->size--;
    236.  
    237.  
    238. 	//复用SLErase函数 -- 改写头删函数SLPopFront
    239. 	SLErase(ps, 0); //头元素下标是0
    240. }
    241.  
    242.  
    243.  
    244. //在指定位置（pos）插入想要的值（x）
    245. void SLInsert(SL* ps, int pos, SLDataType x)
    246. {
    247. 	//先使用assert检查pos是否合法：
    248. 	//在pos位置插入一个值后，顺序表还得是连续的
    249. 	assert(pos >= 0 && pos <= ps->size);
    250. 	//pos等于0 -- 相等于头插
    251. 	//pos等于size -- 相等于尾插
    252. 	
    253. 	//使用SLCheckCapacity进行扩容操作：
    254. 	SLCheckCapacity(ps);
    255.  
    256. 	//定义一个变量end，对应要移动元素的下标
    257. 	int end = ps->size - 1; //一开始对应最后一个元素的下标
    258.  
    259. 	while (end >= pos)
    260. 		//只要end下标对应的元素还在pos下标元素的右边
    261. 		//就把“end元素”向右移，移到pos下标无元素
    262. 	{
    263. 		//把“end元素”向右移
    264. 		ps->a[end + 1] = ps->a[end];
    265. 		
    266. 		//移动下标进行写一个元素的移动
    267. 		--end;
    268. 	}
    269.  
    270. 	//让出位置后，将接收的x插入pos位置：
    271. 	ps->a[pos] = x;
    272.  
    273. 	//有效元素+1：
    274. 	ps->size++;
    275. }
    276.  
    277.  
    278.  
    279. //查找x这个值在顺序表中的下标是多少：
    280. int SLFind(SL* ps, SLDataType x) //返回找到的下标
    281. {
    282. 	//assert断言，防止接收空指针：
    283. 	assert(ps);
    284.  
    285. 	//数据量不大的话直接暴力查找吧：
    286. 	for (int i = 0; i < ps->size; i++)
    287. 		//有几个有效元素就循环几次：
    288. 	{
    289. 		if (ps->a[i] == x)
    290. 			//该下标元素等于要找的值x则返回当前下标：
    291. 		{
    292. 			return i;
    293. 		}
    294. 	}
    295.  
    296. 	return -1; //表未找到该元素下标
    297. }
    298.  
    299.  
    300.  
    301. //删除指定位置（pos）的值：
    302. void SLErase(SL* ps, int pos)
    303. {
    304. 	//同样先使用assert检查pos是否合法：
    305. 	//这里检查条件pos不能像SLInsert一样等于size
    306. 	//因为size空了能插入（尾插），但不能删除
    307. 	assert(pos >= 0 && pos < ps->size);
    308.  
    309. 	//指定删除和头删的思路类似，
    310. 	//只要把pos后面的值往前覆盖，覆盖掉pos的值就好了：
    311.  
    312. 	int begin = pos + 1; //从pos+1的位置往前挪
    313. 	
    314. 	while (begin < ps->size)
    315. 		//一直移到size为止（不包括size位置）
    316. 	{
    317. 		ps->a[begin - 1] = ps->a[begin]; //往前挪
    318. 		++begin; //挪完继续挪下一个 
    319. 	}
    320.  
    321. 	ps->size--; //覆盖掉pos位置的值后，有效数字减一
    322. }
    323.  
    324.  
    325.  
    326. //把pos位置的值修改为x
    327. void SLModify(SL* ps, int pos, SLDataType x)
    328. {
    329. 	//同样先使用assert断言检查pos是否合法：
    330. 	assert(pos >= 0 && pos < ps->size);
    331.  
    332. 	//进行修改：
    333. 	ps->a[pos] = x;
    334. }

                            

    --------------------------------------------------------------------------------------------------------------------------

                      

                          

    test.c -- 测试函数

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. //包含我们写的 SeqList.h 头文件
    4. #include "SeqList.h"
    5.  
    6. //分组测试，测试不同的函数--SLPushBack 和 SLPopBack 函数
    7. void TestSeqList1()
    8. {
    9. 	SL sl;  //创建顺序表类型变量
    10.  
    11. 	//使用 SLInit函数 初始化顺序表类型变量
    12. 	//注意传递的是变量的地址，防止形参改变实参不改变
    13. 	SLInit(&sl);
    14.  
    15. 	//使用尾插函数SLPushBack：
    16. 	SLPushBack(&sl, 1);
    17. 	SLPushBack(&sl, 2);
    18. 	SLPushBack(&sl, 3);
    19. 	SLPushBack(&sl, 4);
    20. 	//此时再调用会进行扩容：
    21. 	SLPushBack(&sl, 5);
    22. 	SLPushBack(&sl, 6);
    23. 	//调用测试函数SPrint查看是否插入成功：
    24. 	SLPrint(&sl);
    25.  
    26. 	//测试尾删函数SLPopBack：
    27. 	SLPopBack(&sl);
    28. 	SLPopBack(&sl);
    29. 	//调用测试函数SPrint查看是否“删除”成功：
    30. 	SLPrint(&sl);
    31.  
    32. 	//测试完后使用SLDestroy函数销毁顺序表：
    33. 	SLDestroy(&sl);
    34. }
    35.  
    36. //分组测试，测试不同的函数--SLPushFront函数
    37. void TestSeqList2()
    38. {
    39. 	SL sl;  //创建顺序表类型变量
    40.  
    41. 	//使用 SLInit函数 初始化顺序表类型变量
    42. 	//注意传递的是变量的地址，防止形参改变实参不改变
    43. 	SLInit(&sl);
    44.  
    45. 	//使用尾插函数SLPushBack：
    46. 	SLPushBack(&sl, 1);
    47. 	SLPushBack(&sl, 2);
    48. 	SLPushBack(&sl, 3);
    49. 	SLPushBack(&sl, 4);
    50. 	//此时再调用会进行扩容：
    51. 	SLPushBack(&sl, 5);
    52. 	SLPushBack(&sl, 6);
    53. 	//调用测试函数SPrint查看是否插入成功：
    54. 	SLPrint(&sl);
    55.  
    56. 	//测试头插函数SLPushFront：
    57. 	SLPushFront(&sl, 10);
    58. 	SLPushFront(&sl, 20);
    59. 	//调用测试函数SPrint查看是否“删除”成功：
    60. 	SLPrint(&sl);
    61.  
    62. 	//测试完后使用SLDestroy函数销毁顺序表：
    63. 	SLDestroy(&sl);
    64. }
    65.  
    66.  
    67. //分组测试，测试不同的函数--SLPopFront函数
    68. void TestSeqList3()
    69. {
    70. 	SL sl;  //创建顺序表类型变量
    71.  
    72. 	//使用 SLInit函数 初始化顺序表类型变量
    73. 	//注意传递的是变量的地址，防止形参改变实参不改变
    74. 	SLInit(&sl);
    75.  
    76. 	//使用尾插函数SLPushBack：
    77. 	SLPushBack(&sl, 1);
    78. 	SLPushBack(&sl, 2);
    79. 	SLPushBack(&sl, 3);
    80. 	SLPushBack(&sl, 4);
    81. 	//此时再调用会进行扩容：
    82. 	SLPushBack(&sl, 5);
    83. 	SLPushBack(&sl, 6);
    84. 	//调用测试函数SPrint查看是否插入成功：
    85. 	SLPrint(&sl);
    86.  
    87. 	//测试头删函数SLPopFront：
    88. 	SLPopFront(&sl);
    89. 	SLPopFront(&sl);
    90. 	//调用测试函数SPrint查看是否“删除”成功：
    91. 	SLPrint(&sl);
    92.  
    93. 	//测试完后使用SLDestroy函数销毁顺序表：
    94. 	SLDestroy(&sl);
    95. }
    96.  
    97. //分组测试，测试不同的函数--SLInsert函数
    98. void TestSeqList4()
    99. {
    100. 	SL sl;  //创建顺序表类型变量
    101.  
    102. 	//使用 SLInit函数 初始化顺序表类型变量
    103. 	//注意传递的是变量的地址，防止形参改变实参不改变
    104. 	SLInit(&sl);
    105.  
    106. 	//使用尾插函数SLPushBack：
    107. 	SLPushBack(&sl, 1);
    108. 	SLPushBack(&sl, 2);
    109. 	SLPushBack(&sl, 3);
    110. 	SLPushBack(&sl, 4);
    111. 	//此时再调用会进行扩容：
    112. 	SLPushBack(&sl, 5);
    113. 	SLPushBack(&sl, 6);
    114. 	//调用测试函数SPrint查看是否插入成功：
    115. 	SLPrint(&sl);
    116.  
    117. 	//测试指定增加函数SLInsert：
    118. 	SLInsert(&sl, 2, 100);
    119. 	//调用测试函数SPrint查看是否“删除”成功：
    120. 	SLPrint(&sl);
    121.  
    122. 	//int x;
    123. 	//scanf("%d", &x);
    124. 	//int pos = SLFind(&sl, x);
    125. 	//if (pos != -1)
    126. 	//{
    127. 	//	SLInsert(&sl, pos, x * 10);
    128. 	//}
    129. 	//SLPrint(&sl);
    130.  
    131. 	//测试完后使用SLDestroy函数销毁顺序表：
    132. 	SLDestroy(&sl);
    133. }
    134.  
    135.  
    136. //分组测试，测试不同的函数--SLFind函数
    137. void TestSeqList5()
    138. {
    139. 	SL sl;  //创建顺序表类型变量
    140.  
    141. 	//使用 SLInit函数 初始化顺序表类型变量
    142. 	//注意传递的是变量的地址，防止形参改变实参不改变
    143. 	SLInit(&sl);
    144.  
    145. 	//使用尾插函数SLPushBack：
    146. 	SLPushBack(&sl, 1);
    147. 	SLPushBack(&sl, 2);
    148. 	SLPushBack(&sl, 3);
    149. 	SLPushBack(&sl, 4);
    150. 	//此时再调用会进行扩容：
    151. 	SLPushBack(&sl, 5);
    152. 	SLPushBack(&sl, 6);
    153. 	//调用测试函数SPrint查看是否插入成功：
    154. 	SLPrint(&sl);
    155.  
    156. 	//测试指定增加函数SLFind：
    157. 	int pos = SLFind(&sl, 2);
    158. 	
    159. 	printf("2在元素中是第%d个元素", pos+1);
    160.  
    161. 	//测试完后使用SLDestroy函数销毁顺序表：
    162. 	SLDestroy(&sl);
    163. }
    164.  
    165. //分组测试，测试不同的函数--SLErase函数
    166. void TestSeqList6()
    167. {
    168. 	SL sl;  //创建顺序表类型变量
    169.  
    170. 	//使用 SLInit函数 初始化顺序表类型变量
    171. 	//注意传递的是变量的地址，防止形参改变实参不改变
    172. 	SLInit(&sl);
    173.  
    174. 	//使用尾插函数SLPushBack：
    175. 	SLPushBack(&sl, 1);
    176. 	SLPushBack(&sl, 2);
    177. 	SLPushBack(&sl, 3);
    178. 	SLPushBack(&sl, 4);
    179. 	//此时再调用会进行扩容：
    180. 	SLPushBack(&sl, 5);
    181. 	SLPushBack(&sl, 6);
    182. 	//调用测试函数SPrint查看是否插入成功：
    183. 	SLPrint(&sl);
    184.  
    185. 	int x;
    186. 	scanf("%d", &x);
    187. 	//配合SLFind函数，找到顺序表中某个值的下标
    188. 	int pos = SLFind(&sl, x);
    189. 	//再使用SLErase函数通过下标删除该值
    190. 	if (pos != -1)
    191. 	{
    192. 		SLErase(&sl, pos);
    193. 	}
    194. 	SLPrint(&sl);
    195.  
    196. 	//测试完后使用SLDestroy函数销毁顺序表：
    197. 	SLDestroy(&sl);
    198. }
    199.  
    200.  
    201. //分组测试，测试不同的函数--SLModify函数
    202. void TestSeqList7()
    203. {
    204. 	SL sl;  //创建顺序表类型变量
    205.  
    206. 	//使用 SLInit函数 初始化顺序表类型变量
    207. 	//注意传递的是变量的地址，防止形参改变实参不改变
    208. 	SLInit(&sl);
    209.  
    210. 	//使用尾插函数SLPushBack：
    211. 	SLPushBack(&sl, 1);
    212. 	SLPushBack(&sl, 2);
    213. 	SLPushBack(&sl, 3);
    214. 	SLPushBack(&sl, 4);
    215. 	//此时再调用会进行扩容：
    216. 	SLPushBack(&sl, 5);
    217. 	SLPushBack(&sl, 6);
    218. 	//调用测试函数SPrint查看是否插入成功：
    219. 	SLPrint(&sl);
    220. 	
    221. 	//测试指定增加函数SLInsert：
    222. 	SLModify(&sl, 2, 100);
    223. 	//调用测试函数SPrint查看是否“删除”成功：
    224. 	SLPrint(&sl);
    225.  
    226. 	//测试完后使用SLDestroy函数销毁顺序表：
    227. 	SLDestroy(&sl);
    228. }
    229.  
    230. //菜单：
    231. void menu()
    232. {
    233. 	printf("********************************\n");
    234. 	printf("1、尾插			2、头插\n");
    235. 	printf("3、头删			4、尾删\n");
    236. 	printf("7、打印			-1、退出\n");
    237. 	printf("********************************\n");
    238. }
    239.  
    240.  
    241. int main()
    242. {
    243. 	//先创建一个顺序表：
    244. 	SL sl;
    245.  
    246. 	//再对其进行初始化：
    247. 	SLInit(&sl);
    248.  
    249. 	//创建一个变量接收菜单选项：
    250. 	int option = 0;
    251.  
    252. 	do
    253. 	{
    254. 		//使用菜单：
    255. 		menu();
    256. 		//打印提示信息：
    257. 		printf("请选择想要进行的操作的序号：>");
    258. 		//接收序号：
    259. 		scanf("%d", &option);
    260. 		
    261. 		printf("\n");
    262.  
    263. 		if (option == 1)
    264. 		{
    265. 			printf("请依次输入你要插入的数据个数:>");
    266. 			int n = 0; //接收数据个数
    267. 			scanf("%d", &n); //接收数据个数
    268. 			
    269. 			printf("\n");
    270. 			printf("请依次输入你要插入的数据\n");
    271.  
    272. 			//知道数据个数后，直接使用for循环循环接收数据
    273. 			int x = 0;
    274. 			for (int i = 0; i < n; i++)
    275. 			{
    276. 				scanf("%d", &x);
    277. 				SLPushBack(&sl, x);
    278. 			}
    279. 		}
    280. 		else if (option == 7)
    281. 		{
    282. 			SLPrint(&sl);
    283. 		}
    284.  
    285. 	} while (option != -1);
    286. 	
    287.  
    288. 	//最后销毁顺序表：
    289. 	SLDestroy(&sl);
    290.  
    291.  
    292. 	//TestSeqList1();
    293. 	//TestSeqList2();
    294. 	//TestSeqList3();
    295. 	//TestSeqList4();
    296. 	//TestSeqList5();
    297. 	//TestSeqList6();
    298. 	//TestSeqList7();
    299.  
    300. 	return 0;
    301. }
  • 相关阅读:
    在kubernetes里使用seccomp限制容器的系统调用
    kubernetes之crontab
    Redis缓存穿透、缓存雪崩和缓存击穿
    金融行业软文怎么写，如何让金融软文在发布上有好效果？
    王道计网：数据链路层
    javaIO流07：处理流BufferedReader和BufferedWriter，Buffer拷贝
    Java校园跑腿小程序校园代买帮忙外卖源码社区外卖源码
    机器学习——推荐系统和强化学习
    SpringMVC的请求处理流程及核心组件
    java架构知识点-中间件（学习笔记）
  • 原文地址：https://blog.csdn.net/weixin_63176266/article/details/132699782