• 【数据结构】——顺序表

    目录

    1.线性表

     2.顺序表

    2.1概念及结构

    3.静态顺序表

    4.动态顺序表

    1.定义一个顺序表

    2.顺序表的初始化和销毁

    3.顺序表尾插

    4.顺序表打印

    5.顺序表尾删

    6.顺序表头插

    7.顺序表头删

    8.在pos（任意）位置的插入

    9.在pos（任意）位置的删除

    5.简单的写一个菜单

    6.完整的动态顺序表代码

     6.1SeqList.h

     6.2SeqList.c

     6.3Test.c

    1.线性表

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

    线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...

    线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，

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

     2.顺序表

    2.1概念及结构

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

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

    顺序表一般可以分为：

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

    2. 动态顺序表：使用动态开辟的数组存储。

    顺序表的本质就是数组

    顺序表要求的是连续存储

    3.静态顺序表

    静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定了，空间开多了浪费，开少了不够用。因此现实生活场景基本不会用到静态顺序表

     

    接下来用代码看一看静态顺序表是怎么实现的：

    1. // 静态顺序表 -- 不太实用
    2. // N小了不够用，N大了可能浪费
    3. #define N  100
    4. //typedef struct shunxubiao//不能用拼英取名字
    5. typedef int SLDataType;//重命名结构中的数据类型，以便后期维护
    6. typedef struct SeqList
    7. {
    8. 	SLDataType a[N];
    9. 	int size; // 记录存储多少个有效数据
    10. }SL;
    11.  
    12. // STL命名风格
    13. //void SeqListInit(SL s);
    14.  
    15. void SLInit(SL s);
    16. void SLPushBack(SL s, SLDataType x);
    17.  
    18. //void SLWeicha(SL s, int x);//不能这样取名字

    4.动态顺序表

    相比于静态顺序表，动态顺序表能够改变内存空间的大小，因此不会出现内存过大或者太小的情况，更适用于平时日常生活的场景。

     接下来用代码看一看动态顺序表是怎么实现的：

    1.定义一个顺序表

    1. typedef int SLDataType;
    2. typedef struct SeqList
    3. {
    4. 	SLDataType* a;
    5. 	int size;       // 记录存储多少个有效数据
    6. 	int capacity;   // 空间容量大小 
    7. }SL;

    2.顺序表的初始化和销毁

    1. //顺序表初始化
    2. void SLInit(SL* ps)
    3. {
    4. 	assert(ps);
    5.  
    6. 	ps->a = NULL;
    7. 	ps->size = 0;
    8. 	ps->capacity = 0;
    9. }
    10.  
    11. //顺序表销毁
    12. void SLDestroy(SL* ps)
    13. {
    14. 	assert(ps);
    15.  
    16. 	//if (ps->a != NULL)
    17. 	if (ps->a)
    18. 	{
    19. 		free(ps->a);
    20. 		ps->a = NULL;
    21. 		ps->size = ps->capacity = 0;
    22. 	}
    23. }

    3.顺序表尾插

    1.先判断数组的容量够不够

    2.如果不够的话就需要扩容

    3.扩容完成之后，将想要插入的数据x插入到尾部

    1. void SLPushBack(SL* ps, SLDataType x)
    2. {
    3.     //版本1
    4. 	assert(ps);
    5.  
    6. 	// 扩容
    7. 	if (ps->size == ps->capacity)
    8. 	{
    9. 		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    10. 		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));
    11. 		if (tmp == NULL)
    12. 		{
    13. 			perror("realloc fail");
    14. 			exit(-1);//终止程序
    15. 		}
    16.  
    17. 		ps->a = tmp;
    18. 		ps->capacity = newCapacity;
    19. 	}
    20.  
    21. 	ps->a[ps->size] = x;
    22. 	ps->size++;
    23.  
    24.     //版本2
    25.     assert(ps);
    26.  
    27. 	SLCheckCapacity(ps);
    28.  
    29. 	ps->a[ps->size] = x;
    30. 	ps->size++;
    31.  
    32.     //版本3
    33.     SLInsert(ps, ps->size, x);
    34. }

    PS:

    探究realloc扩容是原地扩容还是异地扩容

     

    4.顺序表打印

    1. void SLPrint(SL* ps)
    2. {
    3. 	assert(ps);
    4.  
    5. 	for (int i = 0; i < ps->size; ++i)
    6. 	{
    7. 		printf("%d ", ps->a[i]);
    8. 	}
    9. 	printf("\n");
    10. }

    5.顺序表尾删

    PS：并不需要将尾部的那个数据置为0，因为有可能我们存的就是0

    我们只需要缩减数组的长度size就行了，缩减一次，就相当于尾部的数据被删除了

    那么下次我们尾插的时候，虽然这个数据还在，但是也会被覆盖掉

    要注意的是size为0的时候就不能进行尾删了

    1. void SLPopBack(SL* ps)
    2. {
    3.     //版本1
    4. 	assert(ps);
    5.  
    6. 	// 温柔的检查
    7. 	/*if (ps->size == 0)
    8. 	{
    9. 	return;
    10. 	}*/
    11.  
    12. 	// 暴力的检查
    13. 	assert(ps->size > 0);
    14.  
    15. 	//ps->a[ps->size - 1] = 0;
    16. 	ps->size--;
    17.  
    18.     //版本2
    19.     SLErase(ps, ps->size-1);
    20.     
    21. }

    6.顺序表头插

    在数组的头部插入一个数据

     

     如果空间满了就需要扩容，想到之前尾插的时候也需要扩容，因此可以将这两次扩容写成一个扩容函数

    1. //扩容函数
    2. void SLCheckCapacity(SL* ps)
    3. {
    4. 	assert(ps);
    5.  
    6. 	if (ps->size == ps->capacity)
    7. 	{
    8. 		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    9. 		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));
    10. 		if (tmp == NULL)
    11. 		{
    12. 			perror("realloc fail");
    13. 			exit(-1);
    14. 		}
    15.  
    16. 		ps->a = tmp;
    17. 		ps->capacity = newCapacity;
    18. 	}
    19. }
    1. void SLPushFront(SL* ps, SLDataType x)
    2. {
    3. 	//版本1
    4. 	assert(ps);
    5. 	//检查扩容
    6. 	SLCheckCapacity(ps);
    7.  
    8. 	// 挪动数据
    9. 	int end = ps->size - 1;
    10. 	while (end >= 0)
    11. 	{
    12. 		ps->a[end + 1] = ps->a[end];
    13. 		end--;
    14. 	}
    15.  
    16. 	ps->a[0] = x;
    17. 	ps->size++;
    18.  
    19. 	//版本2
    20. 	SLInsert(ps, 0, x);
    21. }

    7.顺序表头删

    删除头部的一个元素，将后面的元素整体向前挪动一个元素的空间，就能覆盖掉第一个元素

    分析图如下：

    （版本1的代码）

     代码如下：

    1. void SLPopFront(SL* ps)
    2. {
    3. 	//版本1
    4. 	assert(ps);
    5. 	assert(ps->size > 0);
    6.  
    7. 	int begin = 1;
    8. 	while (begin < ps->size)
    9. 	{
    10. 		ps->a[begin - 1] = ps->a[begin];
    11. 		begin++;
    12. 	}
    13.  
    14. 	ps->size--;
    15. 	
    16.     //版本2
    17. 	SLErase(ps, 0);
    18. }

    PS：越界是不一定报错的，尤其是越界读

          

     越界读只是去查看越界位置处的值，因此大部分编译器不会报错

    但是越界写是去改变越界位置处的值，这个是不被允许的，属于非法访问了，因此可能会被查出来，但是根据每个编译器查越界位置的监察位置不同，可能会导致查不出的情况，

    8.在pos（任意）位置的插入

     参考代码如下：

    1. // 在pos位置插入数据
    2. void SLInsert(SL* ps, int pos, SLDataType x)
    3. {
    4. 	assert(ps);
    5. 	assert(pos >= 0);
    6. 	assert(pos <= ps->size);
    7.  
    8. 	SLCheckCapacity(ps);
    9. 	int end = ps->size - 1;
    10. 	while (end >= pos)
    11. 	{
    12. 		ps->a[end + 1] = ps->a[end];
    13. 		end--;
    14. 	}
    15.  
    16. 	ps->a[pos] = x;
    17. 	ps->size++;
    18. }

    由于上面的代码实现的是任意位置插入，那么头插和尾插也属于任意位置中的两种特殊情况

    那么SLInsert（）能够被复用，去修改上面提到的尾插和头插的代码。 

    9.在pos（任意）位置的删除

     参考代码如下：

    1. // 删除pos位置数据
    2. void SLErase(SL* ps, int pos)
    3. {
    4. 	assert(ps);
    5. 	assert(pos >= 0);
    6. 	assert(pos < ps->size);
    7. 	//assert(ps->size > 0);
    8.  
    9. 	// 挪动数据覆盖
    10. 	int begin = pos + 1;
    11. 	while (begin < ps->size)
    12. 	{
    13. 		ps->a[begin - 1] = ps->a[begin];
    14. 		begin++;
    15. 	}
    16.  
    17. 	ps->size--;
    18. }

    既然pos（任意）位置的值都能被删除了，那么头删和尾删也只是SLErase函数的两者特殊情况，因此头删和尾删的代码能够被SLErase函数替换

     10.找顺序表中某个值

    上面的头删和尾删还有pos位置的删除都是通过下标来删除，但是实际生活中，又不是人人都是程序员，别人可能压根不懂下标的概念，那这个时候，我想删除数字10，应该怎么删除呢?

    这个时候我们就要去查找数字10对应的下标了，得到下标之后，就能调用上述的函数去删除10了

    参考代码如下：

    1. int SLFind(SL* ps, SLDataType x, int begin)
    2. {
    3. 	assert(ps);
    4.  
    5. 	for (int i = begin; i < ps->size; ++i)
    6. 	{
    7. 		if (ps->a[i] == x)
    8. 		{
    9. 			return i;
    10. 		}
    11. 	}
    12.  
    13. 	return -1;
    14. }
    15.  
    16. //找到x了，返回下标
    17. /找不到，返回-1

    5.简单的写一个菜单

    1. void menu()
    2. {
    3. 	printf("***********************************************\n");
    4. 	printf("1、尾插数据 2、尾删数据\n");
    5. 	printf("3、头插数据 4、头删数据\n");
    6. 	printf("5、打印数据 -1、退出\n");
    7. 	printf("***********************************************\n");
    8. }
    9.  
    10. int main()
    11. {
    12. 	SL s;
    13. 	SLInit(&s);
    14. 	int option = 0;
    15. 	int val = 0;
    16. 	do
    17. 	{
    18. 		menu();
    19. 		printf("请输入你的操作:>");
    20. 		scanf("%d", &option);
    21. 		switch (option)
    22. 		{
    23. 		case 1:
    24. 			printf("请依次输入你要尾插的数据，以-1结束");
    25. 			scanf("%d", &val);
    26. 			while (val != -1)
    27. 			{
    28. 				SLPushBack(&s, val);
    29. 				scanf("%d", &val);
    30. 			}
    31. 			break;
    32. 		case 2:
    33. 			SLPopBack(&s);
    34. 			break;
    35. 		case 3:
    36. 			break;
    37. 		case 4:
    38. 			break;
    39. 		case 5:
    40. 			SLPrint(&s);
    41. 			break;
    42. 		default:
    43. 			break;
    44. 		}
    45. 	} while (option != -1);
    46.  
    47. 	SLDestroy(&s);
    48.  
    49. 	return 0;
    50. }

    PS：对于初学数据结构的朋友来说，不建议去写菜单，菜单的本质就是便于非程序员使用者和计算机啊交互的，但是对于程序员来说，简洁的菜单反而不利于我们去发现代码中的BUG，不利于我们去调试代码，因此菜单尽量不要去写，要写的话，也只是整个代码的逻辑框架已经写完了，最后再去写菜单。

    6.完整的动态顺序表代码

     6.1SeqList.h

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #pragma once
    3. #include 
    4. #include 
    5. #include 
    6.  
    7.  
    8. // 动态顺序表 -- 按需扩空间
    9.  
    10. typedef int SLDataType;
    11. typedef struct SeqList
    12. {
    13. 	SLDataType* a;	// 指向动态开辟的数组
    14. 	int size;       // 记录存储多少个有效数据
    15. 	int capacity;   // 空间容量大小 
    16. }SL;
    17.  
    18. //顺序表打印
    19. void SLPrint(SL* ps);
    20. //顺序表初始化
    21. void SLInit(SL* ps);
    22. //顺序表销毁
    23. void SLDestroy(SL* ps);
    24. //顺序表尾插
    25. void SLPushBack(SL* ps, SLDataType x);
    26. //顺序表尾删
    27. void SLPopBack(SL* ps);
    28. //顺序表头插
    29. void SLPushFront(SL* ps, SLDataType x);
    30. //顺序表头删
    31. void SLPopFront(SL* ps);
    32.  
    33. //中间插入删除
    34. //在pos（任意）位置插入数据，
    35. void SLInsert(SL* ps, int pos, SLDataType x);
    36. //删除pos（任意）位置数据
    37. void SLErase(SL* ps, int pos);
    38.  
    39. //查找顺序表中x值的位置，返回下标
    40. //int SLFind(SL* ps, SLDataType x);
    41. // begin查找x的起始位置
    42. int SLFind(SL* ps, SLDataType x, int begin);
    43.  
    44. // B树  红黑树  哈希

     6.2SeqList.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include"SeqList.h"
    3.  
    4.  
    5. void SLPrint(SL* ps)
    6. {
    7. 	assert(ps);
    8.  
    9. 	for (int i = 0; i < ps->size; ++i)
    10. 	{
    11. 		printf("%d ", ps->a[i]);
    12. 	}
    13. 	printf("\n");
    14. }
    15. //扩容函数
    16. void SLCheckCapacity(SL* ps)
    17. {
    18. 	assert(ps);
    19.  
    20. 	if (ps->size == ps->capacity)
    21. 	{
    22. 		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    23. 		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));
    24. 		if (tmp == NULL)
    25. 		{
    26. 			perror("realloc fail");
    27. 			exit(-1);
    28. 		}
    29.  
    30. 		ps->a = tmp;
    31. 		ps->capacity = newCapacity;
    32. 	}
    33. }
    34.  
    35. void SLInit(SL* ps)
    36. {
    37. 	assert(ps);
    38.  
    39. 	ps->a = NULL;
    40. 	ps->size = 0;
    41. 	ps->capacity = 0;
    42. }
    43.  
    44. void SLDestroy(SL* ps)
    45. {
    46. 	assert(ps);
    47.  
    48. 	//if (ps->a != NULL)
    49. 	if (ps->a)
    50. 	{
    51. 		free(ps->a);
    52. 		ps->a = NULL;
    53. 		ps->size = ps->capacity = 0;
    54. 	}
    55. }
    56.  
    57. //时间复杂度O(1)--尽量用尾插，头差时间复杂度高
    58. void SLPushBack(SL* ps, SLDataType x)
    59. {
    60. 	//版本1
    61. 	//assert(ps);
    62.  
    63. 	// 扩容
    64. 	//if (ps->size == ps->capacity)
    65. 	//{
    66. 	//	int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    67. 	//	SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));
    68. 	//	if (tmp == NULL)
    69. 	//	{
    70. 	//		perror("realloc fail");
    71. 	//		exit(-1);//终止程序
    72. 	//	}
    73.  
    74. 	//	ps->a = tmp;
    75. 	//	ps->capacity = newCapacity;
    76. 	//}
    77.  
    78. 	//ps->a[ps->size] = x;
    79. 	//ps->size++;
    80.  
    81. 	//版本2
    82. 	//assert(ps);
    83.  
    84. 	//SLCheckCapacity(ps);
    85.  
    86. 	//ps->a[ps->size] = x;
    87. 	//ps->size++;
    88. 	
    89. 	//版本3
    90. 	SLInsert(ps, ps->size, x);
    91. }
    92.  
    93. void SLPopBack(SL* ps)
    94. {
    95. 	//版本1
    96. 	//assert(ps);
    97.  
    98. 	 温柔的检查
    99. 	///*if (ps->size == 0)
    100. 	//{
    101. 	//return;
    102. 	//}*/
    103.  
    104. 	 暴力的检查
    105. 	//assert(ps->size > 0);
    106.  
    107. 	ps->a[ps->size - 1] = 0;
    108. 	//ps->size--;
    109.  
    110. 	//版本2
    111.     SLErase(ps, ps->size - 1);
    112. 	
    113.  
    114. }
    115.  
    116. //时间复杂度O(N)
    117. void SLPushFront(SL* ps, SLDataType x)
    118. {
    119. 	版本1
    120. 	//assert(ps);
    121. 	检查扩容
    122. 	//SLCheckCapacity(ps);
    123.  
    124. 	 挪动数据
    125. 	//int end = ps->size - 1;
    126. 	//while (end >= 0)
    127. 	//{
    128. 	//	ps->a[end + 1] = ps->a[end];
    129. 	//	end--;
    130. 	//}
    131.  
    132. 	//ps->a[0] = x;
    133. 	//ps->size++;
    134.  
    135. 	//版本2
    136. 	SLInsert(ps, 0, x);
    137. }
    138.  
    139. void SLPopFront(SL* ps)
    140. {
    141. 	版本1
    142. 	//assert(ps);
    143. 	//assert(ps->size > 0);
    144.  
    145. 	//int begin = 1;
    146. 	//while (begin < ps->size)
    147. 	//{
    148. 	//	ps->a[begin - 1] = ps->a[begin];
    149. 	//	begin++;
    150. 	//}
    151.  
    152. 	//ps->size--;
    153. 	//版本2
    154. 	SLErase(ps, 0);
    155. }
    156.  
    157. // 在pos位置插入数据
    158. void SLInsert(SL* ps, int pos, SLDataType x)
    159. {
    160. 	assert(ps);
    161. 	assert(pos >= 0);
    162. 	assert(pos <= ps->size);
    163.  
    164. 	SLCheckCapacity(ps);
    165. 	int end = ps->size - 1;
    166. 	while (end >= pos)
    167. 	{
    168. 		ps->a[end + 1] = ps->a[end];
    169. 		end--;
    170. 	}
    171.  
    172. 	ps->a[pos] = x;
    173. 	ps->size++;
    174. }
    175.  
    176. // 删除pos位置数据
    177. void SLErase(SL* ps, int pos)
    178. {
    179. 	assert(ps);
    180. 	assert(pos >= 0);
    181. 	assert(pos < ps->size);
    182. 	//assert(ps->size > 0);
    183.  
    184. 	// 挪动数据覆盖
    185. 	int begin = pos + 1;
    186. 	while (begin < ps->size)
    187. 	{
    188. 		ps->a[begin - 1] = ps->a[begin];
    189. 		begin++;
    190. 	}
    191.  
    192. 	ps->size--;
    193. }
    194.  
    195. //int SLFind(SL* ps, SLDataType x)
    196. //{
    197. //	assert(ps);
    198. //
    199. //	for (int i = 0; i < ps->size; ++i)
    200. //	{
    201. //		if (ps->a[i] == x)
    202. //		{
    203. //			return i;
    204. //		}
    205. //	}
    206. //
    207. //	return -1;
    208. //}
    209.  
    210. int SLFind(SL* ps, SLDataType x, int begin)
    211. {
    212. 	assert(ps);
    213.  
    214. 	for (int i = begin; i < ps->size; ++i)
    215. 	{
    216. 		if (ps->a[i] == x)
    217. 		{
    218. 			return i;
    219. 		}
    220. 	}
    221.  
    222. 	return -1;
    223. }

     6.3Test.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include "SeqList.h"
    3.  
    4. void TestSeqList1()
    5. {
    6. 	SL sl;
    7. 	SLInit(&sl);
    8. 	SLPushBack(&sl, 1);
    9. 	SLPushBack(&sl, 2);
    10. 	SLPushBack(&sl, 3);
    11. 	SLPushBack(&sl, 4);
    12. 	SLPushBack(&sl, 5);
    13. 	SLPushBack(&sl, 5);
    14. 	SLPushBack(&sl, 5);
    15. 	SLPushBack(&sl, 5);
    16. 	SLPushBack(&sl, 5);
    17.  
    18.  
    19. 	SLPrint(&sl);
    20.  
    21. 	SLDestroy(&sl);
    22. }
    23.  
    24. void TestSeqList2()
    25. {
    26. 	/*SL* s = NULL;
    27. 	SLInit(s);*/
    28.  
    29. 	SL sl;
    30. 	SLInit(&sl);
    31. 	SLPushBack(&sl, 1);
    32. 	SLPushBack(&sl, 2);
    33. 	SLPushBack(&sl, 3);
    34. 	SLPushBack(&sl, 4);
    35. 	SLPrint(&sl);
    36.  
    37. 	SLPopBack(&sl);
    38. 	SLPrint(&sl);
    39.  
    40. 	SLPushBack(&sl, 8);
    41. 	SLPrint(&sl);
    42.  
    43. 	SLPopBack(&sl);
    44. 	SLPopBack(&sl);
    45. 	SLPopBack(&sl);
    46. 	SLPopBack(&sl);
    47. 	//SLPopBack(&sl);
    48.  
    49. 	SLPrint(&sl);
    50.  
    51. 	SLPushBack(&sl, 1);
    52. 	//SLPushBack(&sl, 2);
    53. 	SLPushBack(&sl, 2);
    54. 	SLPushBack(&sl, 2);
    55.  
    56.  
    57. 	SLDestroy(&sl);
    58. }
    59.  
    60. void TestSeqList3()
    61. {
    62. 	SL sl;
    63. 	SLInit(&sl);
    64.  
    65. 	SLPushFront(&sl, 1);
    66. 	SLPushFront(&sl, 2);
    67. 	SLPushFront(&sl, 3);
    68. 	SLPushFront(&sl, 4);
    69.  
    70. 	SLPrint(&sl);
    71.  
    72. 	SLPopFront(&sl);
    73. 	SLPopFront(&sl);
    74. 	SLPopFront(&sl);
    75. 	SLPopFront(&sl);
    76. 	//SLPopFront(&sl);
    77. 	SLPrint(&sl);
    78.  
    79. 	SLPushBack(&sl, 10);
    80. 	SLPrint(&sl);
    81.  
    82. 	SLDestroy(&sl);
    83. }
    84.  
    85. void TestSeqList4()
    86. {
    87. 	SL sl;
    88. 	SLInit(&sl);
    89. 	SLPushBack(&sl, 1);
    90. 	SLPushBack(&sl, 2);
    91. 	SLPushBack(&sl, 3);
    92. 	SLPushBack(&sl, 4);
    93. 	SLPrint(&sl);
    94.  
    95. 	SLInsert(&sl, 2, 20);
    96. 	SLPrint(&sl);
    97.  
    98. 	SLInsert(&sl, 5, 500);
    99. 	SLPrint(&sl);
    100.  
    101. 	SLInsert(&sl, 0, 500);
    102. 	SLPrint(&sl);
    103.  
    104. 	SLDestroy(&sl);
    105. }
    106.  
    107. void TestSeqList5()
    108. {
    109. 	SL sl;
    110. 	SLInit(&sl);
    111. 	SLPushBack(&sl, 1);
    112. 	SLPushBack(&sl, 2);
    113. 	SLPushBack(&sl, 3);
    114. 	SLPushBack(&sl, 4);
    115. 	SLPrint(&sl);
    116.  
    117. 	SLErase(&sl, 2);
    118. 	SLPrint(&sl);
    119.  
    120. 	SLErase(&sl, 2);
    121. 	SLPrint(&sl);
    122.  
    123. 	SLErase(&sl, 0);
    124. 	SLPrint(&sl);
    125.  
    126. 	SLDestroy(&sl);
    127. }
    128.  
    129. void TestSeqList6()
    130. {
    131. 	SL sl;
    132. 	SLInit(&sl);
    133. 	SLPushBack(&sl, 1);
    134. 	SLPushBack(&sl, 2);
    135. 	SLPushBack(&sl, 3);
    136. 	SLPushBack(&sl, 4);
    137. 	SLPushBack(&sl, 5);
    138. 	SLPushBack(&sl, 7);
    139. 	SLPushBack(&sl, 5);
    140. 	SLPushBack(&sl, 8);
    141. 	SLPushBack(&sl, 5);
    142. 	SLPrint(&sl);
    143.  
    144. 	/*int pos = SLFind(&sl, 5);
    145. 	if (pos != -1)
    146. 	{
    147. 		SLErase(&sl, pos);
    148. 	}
    149. 	SLPrint(&sl);*/
    150.  
    151. 	int pos = SLFind(&sl, 4, 0);
    152. 	if (pos != -1)
    153. 	{
    154. 		SLErase(&sl, pos);
    155. 	}
    156. 	SLPrint(&sl);
    157.  
    158. 	// 删除顺序表所有的5
    159. 	pos = SLFind(&sl, 5, 0);
    160. 	while (pos != -1)
    161. 	{
    162. 		SLErase(&sl, pos);
    163.  
    164. 		pos = SLFind(&sl, 5, pos);
    165. 	}
    166. 	SLPrint(&sl);
    167.  
    168. 	SLDestroy(&sl);
    169. }
    170.  
    171.  
    172.  
    173. void menu()
    174. {
    175. 	printf("***********************************************\n");
    176. 	printf("1、尾插数据 2、尾删数据\n");
    177. 	printf("3、头插数据 4、头删数据\n");
    178. 	printf("5、打印数据 -1、退出\n");
    179. 	printf("***********************************************\n");
    180. }
    181.  
    182. int main()
    183. {
    184.     //TestSeqList1()
    185.     //TestSeqList2()
    186.     //TestSeqList3()
    187.     //TestSeqList4()
    188.     //TestSeqList5()
    189.     //TestSeqList6()
    190. 	SL s;
    191. 	SLInit(&s);
    192. 	int option = 0;
    193. 	int val = 0;
    194. 	do
    195. 	{
    196. 		menu();
    197. 		printf("请输入你的操作:>");
    198. 		scanf("%d", &option);
    199. 		switch (option)
    200. 		{
    201. 		case 1:
    202. 			printf("请依次输入你要尾插的数据，以-1结束");
    203. 			scanf("%d", &val);
    204. 			while (val != -1)
    205. 			{
    206. 				SLPushBack(&s, val);
    207. 				scanf("%d", &val);
    208. 			}
    209. 			break;
    210. 		case 2:
    211. 			SLPopBack(&s);
    212. 			break;
    213. 		case 3:
    214. 			break;
    215. 		case 4:
    216. 			break;
    217. 		case 5:
    218. 			SLPrint(&s);
    219. 			break;
    220. 		default:
    221. 			break;
    222. 		}
    223. 	} while (option != -1);
    224.  
    225. 	SLDestroy(&s);
    226.  
    227. 	return 0;
    228. }
  • 相关阅读:
    11GR2 rac 2节点一键安装演示
    QT小记：警告Use multi-arg instead
    HashMap&ConcurrentHashMap
    Unity DOTS Component概述
    AtCoder Beginner Contest 254「E bfs」「F st表维护差分数组gcd」
    青藏高原连续日光诱导叶绿素荧光数据集（2000-2018）
    一种高效的同态加密方案及其应用-解读
    Java面试：全面掌握Java知识的捷径！
    Android studio 打包release版本 apk 换方式了？
    有哪些不起眼却赚钱的行业？
  • 原文地址：https://blog.csdn.net/luoheng1114/article/details/127626903