• DS线性表之顺序表

    前言 

    上一期我们介绍了什么是数据结构和算法，以及介绍了算法效率问题即什么是时空复杂度~和时空复杂度的计算方式以及常见的时空复杂度的例题详解，本期我们来介绍一下线性表中的顺序表~！

    本期内容介绍

    什么是线性表？

    顺序表的概念以及分类

    静态顺序表的实现

    动态顺序表的实现

    顺序表存在问题

    目录

    前言 

    本期内容介绍

    一、什么是线性表？

    二、顺序表

    顺序表的概念以及结构分类

    三、静态顺序表的实现

    静态顺序表的申明

    静态顺序表的初始化

    静态顺序表的销毁

    静态顺序表的打印

    静态顺序表的尾插

    静态顺序表的尾删

    静态顺序表的头插

    静态顺序表的头删

    静态顺序表的排序

    静态顺序表在pos位置插入

    静态顺序表在pos位置删除

    静态顺序表查找指定元素x

    静态顺序表中修改指定pos位置的元素

    全部源码：

    四、动态顺序表的实现

    动态顺序表的申明

    动态顺序表的初始化

    动态顺序表的销毁

    动态顺序表的打印

    动态顺序表的尾插

    动态顺序表的尾删

    动态顺序表的头插

    动态顺序表的头删

    动态顺序表的排序

    动态顺序表在pos位置插入

    动态顺序表在pos位置删除

    动态顺序表中查找指定元素x

    动态顺序表中修改指定pos位置的元素

    全部源码：

    五、顺序表的问题

    一、什么是线性表？

    线性表(Linear List)是N个具有相同特性的数据元素的集合！线性表在逻辑上是线性结构，即是一条连续的线，但在其物理结构上是不一定连续的~！常见的线性表有：顺序表、链表、栈、队列、串等

    为什么说是逻辑结构上是连续的，物理结构上是不一定连续的呢？我们在C语言自定义类型详解的那一期介绍过一个东西叫结构体的自引用，我们当时说过他就是链表，他的开辟在堆上要动态开辟（由操作系统随机分配）~！所以整个链表可能不是连续的！而在当时写通讯录的时候他那个实际上就是顺序表！我在来画个图解释一下上面这句话：

    二、顺序表

    顺序表的概念以及结构分类

    顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构！一般情况下使用数组存储，在数组上进行各种运算即增删查改（通过各个接口）！

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

    静态顺序表：存储数据的个数是固定的

    动态顺序表：存储数据的个数不是固定的不够了可以扩容

    OK，我们各写一个来look一look：

    静态顺序表：

    1. #define MAX 10
    2. typedef int SLDataType;
    3. typedef struct SeqList
    4. {
    5. 	SLDataType data[MAX];
    6. 	int size;//顺序表的元素个数
    7. }SeqList;

    动态顺序表：

    1. typedef int SLDataType;
    2. typedef struct SeqList
    3. {
    4. 	SLDataType* data;
    5. 	int size;//顺序表的元素个数
    6. 	int capacity;//顺序表的容量
    7. }SeqList;

    这里你可能还有一些疑问，例如不就是在数组上增删查改吗？我直接在数组上进行操作不就行啦吗？OK，那你在进行操作的时候你如何知道你的数组中目前有几个元素？用什么判定???好像没有办法吧！你只能在定义一个变量来记录他当当中的元素个数，那这样为什么不直接用顺序表呢？？？对吧，一步到位，你只管操作其他不用担心~！另外还有就是：顺序表的存储一定是连续的，你只能挨着存而数组不一定你可以在不同位置存！！！！

    三、静态顺序表的实现

    OK，我们还是采用多文件编程：申明等都放在.h文件,实现在.c文件，测试在test.c中

    一开始我们得先有一个顺序表吧：

    静态顺序表的申明

    1. #define MAX 15
    2. typedef int SeqDataType;
    3.  
    4. typedef struct SeqList
    5. {
    6. 	SeqDataType data[MAX];
    7. 	int size;
    8. }SL;

    静态顺序表的初始化

    这里它的底层是个数组嘛！我们可以用个循环做，也可以直接用memset来初始化，我们一开始把数组中的每个元素都置0，size也置0；

    1. //初始化
    2. void SLInit(SL* ps)
    3. {
    4. 	assert(ps);
    5.  
    6. 	memset(ps->data, 0, sizeof(int) * MAX);
    7. 	ps->size = 0;
    8. }

    这里你可能会想为什么形参要用指针呢？这里还是那个问题：形参和实参的问题，形参的改变不影响实参！要在外部改变实参则要要传指针！

    静态顺序表的销毁

    有初始化必有销毁嘛~！那这个静态顺序表如何销毁呢？由于它的开辟在栈上，不能用free所以我们只需要把它的数组内容置0，size置0即可~！（size置0也可以，不要让他访问了），这里直接调用初始化即可：

    1. //销毁
    2. void SLDestory(SL* ps)
    3. {
    4. 	assert(ps);
    5. 	SLInit(ps);
    6. }

    为了后续的直接的看结果我们在这里可以再来实现一个打印函数：

    静态顺序表的打印

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

    静态顺序表的尾插

    尾插就比较简单了，因为size是记录数组的有效元素的个数的，在数组中加一个元素size就会++一下，所以size是下一个元素的下标，所以我么只需要在size位置插入即可，但由于存储的大小是固定的，你在插入前得判断能不能插万一顺序表已经满了，你还插什么插！

    1. //尾插
    2. void SLPushBack(SL* ps, SeqDataType x)
    3. {
    4. 	assert(ps);
    5. 	
    6. 	if (ps->size == MAX)
    7. 	{
    8. 		printf("顺序表已满无法插入!\n");
    9. 		exit(-1);
    10. 	}
    11. 	//assert(MAX == ps->size);
    12.  
    13. 	ps->data[ps->size] = x;
    14. 	ps->size++;
    15. }

    当然这里的判断满的情况也有两种，"温柔的检查"和"暴力检查"，其实我个人比较喜欢暴力检查的，满了的话直接结束程序，而且我们前面也介绍过assert断言失败也会告诉你在哪个文件的第几行出问题了~！当然要是讲究人性化的话，if是更好的~！这里都可以！

    静态顺序表的尾删

    尾删和尾插一样简单，由于你访问的时候是小于size的所以你只需要，让size--，此时在访问就访问不到最后一个元素了~！这也就相当于尾删了~！当然你也要在删除时判断，如果顺序表已经为空了，你还删除、、、这好像不合理吧~！所以当顺序表为空时就不要删了，那什么时候是顺序表为空呢？我们说过size是下一个元素的下标，当下一个元素的下标为0时，就说明当前元素的下表为-1，但下标不可能为-1所以就只能说明当前有效元素的个数为0,size没有++，所以当szie == 0时就说明顺序表一空不能删除~！

    1. void SLPopBack(SL* ps)
    2. {
    3. 	assert(ps);
    4.  
    5. 	if (ps->size  == 0)
    6. 	{
    7. 		printf("顺序表为空无法删除!\n");
    8. 		exit(-1);
    9. 	}
    10.  
    11. 	ps->size--;
    12. }

    当然这里也可以用暴力检查~！

    OK，我们还是养成好习惯，写两个测试两个：

    尾插没有问题，再来看看尾删：

    静态顺序表的头插

    既然是插入那就要考虑是否已经是满的情况，如果是满的情况直接退出不然插入~！

    1. //头插
    2. void SLPushFront(SL* ps, SeqDataType x)
    3. {
    4. 	assert(ps);
    5.  
    6. 	if (ps->size == MAX)
    7. 	{
    8. 		printf("顺序表已满无法插入!\n");
    9. 		exit(-1);
    10. 	}
    11.  
    12. 	int i = 0;
    13. 	for (i = ps->size; i > 0; i--)
    14. 	{
    15. 		ps->data[i] = ps->data[i - 1];
    16. 	}
    17.  
    18. 	ps->data[i] = x;
    19. 	ps->size++;
    20. }

    静态顺序表的头删

    删除的时候和以前一样一定要考虑顺序表已经为空的情况~！为空直接退出不删了~！

    1. //头删
    2. void SLPopFront(SL* ps)
    3. {
    4. 	assert(ps);
    5.  
    6. 	if (ps->size == 0)
    7. 	{
    8. 		printf("顺序表为空无法删除!\n");
    9. 		exit(-1);
    10. 	}
    11. 	//assert(ps->size);
    12.  
    13. 	for (int i = 0; i < ps->size; i++)
    14. 	{
    15. 		ps->data[i] = ps->data[i+1];
    16. 	}
    17.  
    18. 	ps->size--;
    19. }

    OK，还是来测试一下：

    OK，头插头删是没有问题了~！

    静态顺序表的排序

    我们这里的排序采用qsort当然用其他的排序也可以~！

    1. int cmp(const void* a, const void* b)
    2. {
    3. 	return *(int*)a - *(int*)b;
    4. }
    5.  
    6. //排序
    7. void SLSort(SL* ps)
    8. {
    9. 	assert(ps);
    10. 	assert(ps->size);
    11.  
    12. 	qsort(ps->data, ps->size, sizeof(int), cmp);
    13. }

    静态顺序表在pos位置插入

    插入必须判断是否已经满的情况，这里还有注意pos的合理性，因为pos是位置不是下标所以pos和数组下标差1（如下图），如果pos的位置小于1，顺序表的位置是从1开始的怎么可能小于1？不合理直接退出，pos大于或等于顺序表的最大长度，这也不合理吧~！顺序表的位置和数组的下标差1，你都大于等于最大下标了（假设满了无法插入了，即使不满顺序表也不让随意插入）

    1. //在pos位置插入x
    2. void SLInsert(SL* ps, int pos, SeqDataType x)
    3. {
    4. 	assert(ps);
    5.  
    6. 	if (pos < 1 || pos >= MAX || ps->size >= MAX)
    7. 	{
    8. 		printf("pos非法或顺序表已满!\n");
    9. 		exit(-1);
    10. 	}
    11.  
    12. 	int i = 0;
    13. 	for (i = ps->size; i >= pos; i--)
    14. 	{
    15. 		ps->data[i] = ps->data[i-1];
    16. 	}
    17. 	ps->data[pos-1] = x;
    18. 	ps->size++;
    19. }

    静态顺序表在pos位置删除

    删除必须判断是否已经是空的情况~！以及和上面一样pos不可能是小于1的，删除顺序表之外的东西直接退出，还有就是所删的位置是数组和法但不是顺序表的有效数据区这也不能删除~！

    1. //删除pos位置
    2. void SLErase(SL* ps, int pos)
    3. {
    4. 	assert(ps);
    5.  
    6. 	
    7. 	if (ps->size == 0 || pos < 1 || pos >= MAX || pos >= ps->size)
    8. 	{
    9. 		printf("pos非法或顺序表为空无法删除!\n");
    10. 		exit(-1);
    11. 	}
    12.  
    13. 	for (int i = pos-1; i < ps->size; i++)
    14. 	{
    15. 		ps->data[i] = ps->data[i + 1];
    16. 	}
    17.  
    18. 	ps->size--;
    19. }

    OK，还是来测试一把：

    OK，排序以及在pos位置插入删除都正常~！我们下来在写几个：

    静态顺序表查找指定元素x

    这个接口就实现起来很简单了，只需要遍历一遍数组即可（在没有排序的情况下），如果是排了序的情况直接二分查找效率最高~！找到返回下标，找不到返回-1

    1.  
    2. //查找指定元素x
    3. int SLFind(SL* ps, SeqDataType x)
    4. {
    5. 	assert(ps);
    6.  
    7. 	for (int i = 0; i < ps->size; i++)
    8. 	{
    9. 		if (x == ps->data[i])
    10. 			return i;
    11. 	}
    12.  
    13. 	return -1;
    14. }

    静态顺序表中修改指定pos位置的元素

    这里要考虑好边界即可，你不能超过最大存储范围也不能超过顺序表的有效数据范围，以及pos本身的合法性~！

    1. //修改顺序表pos位置的元素
    2. void SLModif(SL* ps, int pos, SeqDataType x)
    3. {
    4. 	assert(ps);
    5.  
    6. 	if (pos >= 1 && pos <= MAX && pos <= ps->size)
    7. 	{
    8. 		ps->data[pos - 1] = x;
    9. 	}
    10. }

    OK，测试一下：

    全部源码：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #pragma once
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #define MAX 5
    9. typedef int SeqDataType;
    10.  
    11. typedef struct SeqList
    12. {
    13. 	SeqDataType data[MAX];
    14. 	int size;
    15. }SL;
    16.  
    17. //初始化
    18. void SLInit(SL* ps);
    19.  
    20. //销毁
    21. void SLDestory(SL* ps);
    22.  
    23. //打印
    24. void SLPrint(const SL* ps);
    25.  
    26. //尾插
    27. void SLPushBack(SL* ps, SeqDataType x);
    28.  
    29. //尾删
    30. void SLPopBack(SL* ps);
    31.  
    32. //头插
    33. void SLPushFront(SL* ps, SeqDataType x);
    34.  
    35. //头删
    36. void SLPopFront(SL* ps);
    37.  
    38. //排序
    39. void SLSort(SL* ps);
    40.  
    41. //在pos位置插入x
    42. void SLInsert(SL* ps, int pos, SeqDataType x);
    43.  
    44. //删除pos位置
    45. void SLErase(SL* ps, int pos);
    46.  
    47. //查找指定元素x
    48. int SLFind(SL* ps, SeqDataType x);
    49.  
    50. //修改顺序表pos位置的元素
    51. void SLModif(SL* ps,int pos, SeqDataType x);
    1. #include "SeqList.h"
    2.  
    3. //初始化
    4. void SLInit(SL* ps)
    5. {
    6. 	assert(ps);
    7.  
    8. 	memset(ps->data, 0, sizeof(int) * MAX);
    9. 	ps->size = 0;
    10. }
    11.  
    12. //销毁
    13. void SLDestory(SL* ps)
    14. {
    15. 	assert(ps);
    16. 	SLInit(ps);
    17. }
    18.  
    19. //打印
    20. void SLPrint(const SL* ps)
    21. {
    22. 	assert(ps);
    23.  
    24. 	for (int i = 0; i < ps->size; i++)
    25. 	{
    26. 		printf("%d ", ps->data[i]);
    27. 	}
    28.  
    29. 	printf("\n");
    30. }
    31.  
    32.  
    33. //尾插
    34. void SLPushBack(SL* ps, SeqDataType x)
    35. {
    36. 	assert(ps);
    37. 	
    38. 	if (ps->size == MAX)
    39. 	{
    40. 		printf("顺序表已满无法插入!\n");
    41. 		exit(-1);
    42. 	}
    43. 	//assert(MAX == ps->size);
    44.  
    45. 	ps->data[ps->size] = x;
    46. 	ps->size++;
    47. }
    48.  
    49.  
    50. //尾删
    51. void SLPopBack(SL* ps)
    52. {
    53. 	assert(ps);
    54.  
    55. 	if (ps->size  == 0)
    56. 	{
    57. 		printf("顺序表为空无法删除!\n");
    58. 		exit(-1);
    59. 	}
    60.  
    61. 	ps->size--;
    62. }
    63.  
    64.  
    65. //头插
    66. void SLPushFront(SL* ps, SeqDataType x)
    67. {
    68. 	assert(ps);
    69.  
    70. 	if (ps->size == MAX)
    71. 	{
    72. 		printf("顺序表已满无法插入!\n");
    73. 		exit(-1);
    74. 	}
    75.  
    76. 	int i = 0;
    77. 	for (i = ps->size; i > 0; i--)
    78. 	{
    79. 		ps->data[i] = ps->data[i - 1];
    80. 	}
    81.  
    82. 	ps->data[i] = x;
    83. 	ps->size++;
    84. }
    85.  
    86. //头删
    87. void SLPopFront(SL* ps)
    88. {
    89. 	assert(ps);
    90.  
    91. 	if (ps->size == 0)
    92. 	{
    93. 		printf("顺序表为空无法删除!\n");
    94. 		exit(-1);
    95. 	}
    96. 	//assert(ps->size);
    97.  
    98. 	for (int i = 0; i < ps->size; i++)
    99. 	{
    100. 		ps->data[i] = ps->data[i+1];
    101. 	}
    102.  
    103. 	ps->size--;
    104. }
    105.  
    106.  
    107. int cmp(const void* a, const void* b)
    108. {
    109. 	return *(int*)a - *(int*)b;
    110. }
    111.  
    112. //排序
    113. void SLSort(SL* ps)
    114. {
    115. 	assert(ps);
    116. 	assert(ps->size);
    117.  
    118. 	qsort(ps->data, ps->size, sizeof(int), cmp);
    119. }
    120.  
    121.  
    122. //在pos位置插入x
    123. void SLInsert(SL* ps, int pos, SeqDataType x)
    124. {
    125. 	assert(ps);
    126.  
    127. 	if (pos < 1 || pos >= MAX || ps->size >= MAX)
    128. 	{
    129. 		printf("pos非法或顺序表已满!\n");
    130. 		exit(-1);
    131. 	}
    132.  
    133. 	int i = 0;
    134. 	for (i = ps->size; i >= pos; i--)
    135. 	{
    136. 		ps->data[i] = ps->data[i-1];
    137. 	}
    138. 	ps->data[pos-1] = x;
    139. 	ps->size++;
    140. }
    141.  
    142. //删除pos位置
    143. void SLErase(SL* ps, int pos)
    144. {
    145. 	assert(ps);
    146.  
    147. 	
    148. 	if (ps->size == 0 || pos < 1 || pos >= MAX || pos >= ps->size)
    149. 	{
    150. 		printf("pos非法或顺序表为空无法删除!\n");
    151. 		exit(-1);
    152. 	}
    153.  
    154. 	for (int i = pos-1; i < ps->size; i++)
    155. 	{
    156. 		ps->data[i] = ps->data[i + 1];
    157. 	}
    158.  
    159. 	ps->size--;
    160. }
    161.  
    162.  
    163. //查找指定元素x
    164. int SLFind(SL* ps, SeqDataType x)
    165. {
    166. 	assert(ps);
    167.  
    168. 	for (int i = 0; i < ps->size; i++)
    169. 	{
    170. 		if (x == ps->data[i])
    171. 			return i;
    172. 	}
    173.  
    174. 	return -1;
    175. }
    176.  
    177.  
    178. //修改顺序表pos位置的元素
    179. void SLModif(SL* ps, int pos, SeqDataType x)
    180. {
    181. 	assert(ps);
    182.  
    183. 	if (pos >= 1 && pos <= MAX && pos <= ps->size)
    184. 	{
    185. 		ps->data[pos - 1] = x;
    186. 	}
    187. }
    1. #include "SeqList.h"
    2.  
    3. //测试尾插、尾删以及初始化、销毁、打印
    4. void test1()
    5. {
    6. 	SL s;
    7. 	SLInit(&s);
    8.  
    9. 	SLPushBack(&s, 1);
    10. 	SLPushBack(&s, 2);
    11. 	SLPushBack(&s, 3);
    12. 	SLPushBack(&s, 4);
    13. 	SLPrint(&s);
    14. 	SLPushBack(&s, 5);
    15. 	SLPrint(&s);
    16.  
    17. 	SLPopBack(&s);
    18. 	SLPrint(&s);
    19. 	SLPopBack(&s);
    20. 	SLPrint(&s);
    21. 	SLPopBack(&s);
    22. 	SLPrint(&s);
    23. 	SLPopBack(&s);
    24. 	SLPrint(&s);
    25. 	SLPopBack(&s);
    26. 	SLPrint(&s);
    27.  
    28. 	//检查是否满的时候插入是否有Bug
    29. 	SLPopBack(&s);
    30. 	SLPrint(&s);
    31.  
    32. 	SLDestory(&s);
    33. }
    34.  
    35. //测试头插、头删
    36. void test2()
    37. {
    38. 	SL s;
    39. 	SLInit(&s);
    40.  
    41. 	SLPushFront(&s, 1);
    42. 	SLPushFront(&s, 2);
    43. 	SLPushFront(&s, 3);
    44. 	SLPushFront(&s, 5);
    45. 	SLPushFront(&s, 6);
    46. 	SLPrint(&s);
    47.  
    48. 	//检查是在满的情况下是否有Bug
    49. 	//SLPushFront(&s, 7);
    50. 	//SLPrint(&s);
    51.  
    52. 	SLPopFront(&s);
    53. 	SLPrint(&s);
    54. 	SLPopFront(&s);
    55. 	SLPrint(&s);
    56. 	SLPopFront(&s);
    57. 	SLPrint(&s);
    58. 	SLPopFront(&s);
    59. 	SLPrint(&s);
    60. 	SLPopFront(&s);
    61. 	SLPrint(&s);
    62.  
    63. 	//检查是否空的时候删除是否有Bug
    64. 	SLPopFront(&s);
    65. 	SLPrint(&s);
    66.  
    67. 	SLDestory(&s);
    68. }
    69.  
    70. //测试排序、在pos位置插入、删除pos位置
    71. void test3()
    72. {
    73. 	SL s;
    74. 	SLInit(&s);
    75.  
    76. 	SLPushFront(&s, 1);
    77. 	SLPushFront(&s, 2);
    78. 	SLPushFront(&s, 3);
    79. 	SLPushFront(&s, 5);
    80. 	SLPrint(&s);
    81.  
    82. 	SLSort(&s);
    83. 	SLPrint(&s);
    84.  
    85. 	SLInsert(&s, 3, 4);
    86. 	SLPrint(&s);
    87.  
    88. 	SLErase(&s, 1);
    89. 	SLPrint(&s);
    90. 	SLErase(&s, 3);
    91. 	SLPrint(&s);
    92.  
    93. 	SLDestory(&s);
    94. }
    95.  
    96. //测试查找指定元素和修改pos位置的元素的值
    97. void test4()
    98. {
    99. 	SL s;
    100. 	SLInit(&s);
    101.  
    102. 	SLPushFront(&s, 1);
    103. 	SLPushFront(&s, 2);
    104. 	SLPushFront(&s, 3);
    105. 	SLPushFront(&s, 5);
    106. 	SLPrint(&s);
    107.  
    108. 	int ret = SLFind(&s, 4);
    109. 	if (ret != -1)
    110. 	{
    111. 		printf("找到了，下标为: %d ", ret);
    112. 	}
    113. 	else
    114. 	{
    115. 		printf("没找到\n");
    116. 	}
    117.  
    118. 	SLModif(&s, 2, 20);
    119. 	SLPrint(&s);
    120. 	SLModif(&s, 1, 10);
    121. 	SLPrint(&s);
    122.  
    123. 	SLModif(&s, 4, 40);
    124. 	SLPrint(&s);
    125.  
    126. 	SLDestory(&s);
    127. }
    128.  
    129.  
    130. int main()
    131. {
    132. 	test4();
    133. 	return 0;
    134. }

    静态顺序表的缺点就是它的存储个数是固定的，这个缺陷导致他的应用场景并不多，你一开始给他开多大的空间？这个是不是很为难呀？开太大了浪费了，开太小了又不够......所以它的应用场景不是很多！针对这种情况，我们进行优化：一开始给一点空间（或者不开）用的时候或不够了进行扩容（每次扩1.5倍或2倍），这样就有效的降低了浪费内存的情况~！OK，下面我们就来look一look顺序表的动态版本

    四、动态顺序表的实现

    动态顺序表的申明

    1. typedef int SLDataType;
    2. typedef struct SeqList
    3. {
    4. 	SLDataType* data;
    5. 	int size;//顺序表的元素个数
    6. 	int capacity;//顺序表的容量
    7. }SeqList;

    动态顺序表的初始化

    1. //初始化
    2. void SLInit(SL* ps)
    3. {
    4. 	assert(ps);
    5. 	ps->data = (SLDataType*)malloc(sizeof(SLDataType) * 4);
    6. 	if (!ps->data)
    7. 	{
    8. 		perror("malloc failed");
    9. 		exit(-1);//异常终止
    10. 	}
    11.  
    12. 	ps->size = 0;
    13. 	ps->capacity = 4;
    14. }

    这里一定要在malloc开辟后检查，否则一旦开辟失败就玩完了~！你都数组都没开出来你还在那里增删查改啥？？？所以，如果开辟失败直接异常退出~！

    动态顺序表的销毁

    1. //销毁
    2. void SLDestory(SL* ps)
    3. {
    4. 	assert(ps);
    5.  
    6. 	free(ps->data);
    7. 	ps->data = NULL;
    8. 	ps->size = ps->capacity = 0;
    9. }

    要记得在最后把ps-data置空，否则就是野指针~！

    动态顺序表的打印

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

    动态顺序表的尾插

    1. //尾插
    2. void SLPushBack(SL* ps, SLDataType x)
    3. {
    4. 	assert(ps);
    5.  
    6. 	//判断扩容
    7. 	if (ps->size == ps->capacity)
    8. 	{
    9. 		int newcapacity = ps->capacity * 2;
    10. 		SLDataType* tmp = (SLDataType*)realloc(ps->data, sizeof(SLDataType) * newcapacity);
    11. 		if (!tmp)
    12. 		{
    13. 			perror("realloc failed");
    14. 			exit(-1);
    15. 		}
    16. 		
    17. 		ps->data = tmp;
    18. 		ps->capacity = newcapacity;
    19. 	}
    20.  
    21. 	ps->data[ps->size] = x;
    22. 	ps->size++;
    23. }

    由于是动态开辟的我们无需考虑满了插入不下的问题，我们只需要考虑是否扩容的问题，如果顺序表的有效数据个数==容量那就得扩容了~！

    动态顺序表的尾删

    1. //尾删
    2. void SLPopBack(SL* ps)
    3. {
    4. 	assert(ps);
    5.  
    6. 	//判断是否为空
    7. 	if (ps->size == 0)
    8. 	{
    9. 		printf("顺序表为空无法删除！\n");
    10. 		exit(-1);
    11. 	}
    12.  
    13. 	ps->size--;
    14. }

    尾删得考虑当前顺序表已经是空的情况~！这里你也可以用断言一旦为空直接终止，我这里稍微人性化了一点，提示了一下，异常退出了~！哈哈~

    OK，老样子！写两个测两个：

    OK，尾插尾删是没有问题了~！Let' s go on ~!

    动态顺序表的头插

    这里判断是否扩容会出现多次，而且代码相对较长，所以我么可以考虑封装成一个函数~！

    1. //判断扩容
    2. void JudExpan(SL* ps)
    3. {
    4. 	assert(ps);
    5.  
    6. 	if (ps->size == ps->capacity)
    7. 	{
    8. 		int newcapacity = ps->capacity * 2;
    9. 		SLDataType* tmp = (SLDataType*)realloc(ps->data, sizeof(SLDataType) * newcapacity);
    10. 		if (!tmp)
    11. 		{
    12. 			perror("realloc failed");
    13. 			exit(-1);
    14. 		}
    15.  
    16. 		ps->data = tmp;
    17. 		ps->capacity = newcapacity;
    18. 	}
    19. }
    1. //头插
    2. void SLPushFront(SL* ps, SLDataType x)
    3. {
    4. 	assert(ps);
    5.  
    6. 	JudExpan(ps);
    7. 	for (int i = ps->size; i > 0; i--)
    8. 	{
    9. 		ps->data[i] = ps->data[i - 1];
    10. 	}
    11. 	ps->data[0] = x;
    12. 	ps->size++;
    13. }

    动态顺序表的头删

    头删判断为空时的判断，当然也可以封装成一个函数，但这里就两句所以我没有封装成函数~！

    1. //头删
    2. void SLPopFront(SL* ps)
    3. {
    4. 	assert(ps);
    5.  
    6. 	//判断是否为空
    7. 	if (ps->size == 0)
    8. 	{
    9. 		printf("顺序表为空无法删除！\n");
    10. 		exit(-1);
    11. 	}
    12.  
    13. 	for (int i = 0; i < ps->size; i++)
    14. 	{
    15. 		ps->data[i] = ps->data[i + 1];
    16. 	}
    17. 	ps->size--;
    18. }

    OK，测试一下：

    OK，没有问题~！我们继续！

    动态顺序表的排序

    我们还是采用C语言库里面提供的qsort进行排序

    1. //比较函数
    2. int cmp(const void* a, const void* b)
    3. {
    4. 	return *(int*)a - *(int*)b;
    5. }
    6.  
    7. //排序
    8. void SLSort(SL* ps)
    9. {
    10. 	assert(ps);
    11. 	qsort(ps->data, ps->size, sizeof(SLDataType), cmp);
    12. }

    这个我们就把感刚的头插修改一下测试一下即可：

    OK，没问题！

    动态顺序表在pos位置插入

    1. //在pos位置插入
    2. void SLInsert(SL* ps, int pos, SLDataType x)
    3. {
    4. 	assert(ps);
    5.  
    6. 	JudExpan(ps);
    7. 	//判断pos的合法性
    8. 	if (pos > ps->capacity || pos < 1)
    9. 	{
    10. 		printf("pos非法!");
    11. 		exit(-1);
    12. 	}
    13.  
    14. 	for (int i = ps->size; i >= pos; i--)
    15. 	{
    16. 		ps->data[i] = ps->data[i - 1];
    17. 	}
    18. 	ps->data[pos - 1] = x;
    19. 	ps->size++;
    20. }

    记得判断pos的合法性~！！！

    动态顺序表在pos位置删除

    1. //删除pos位置的元素
    2. void SLErase(SL* ps, int pos)
    3. {
    4. 	assert(ps);
    5.  
    6. 	//判断是否为空
    7. 	if (ps->size == 0)
    8. 	{
    9. 		printf("顺序表为空无法删除！\n");
    10. 		exit(-1);
    11. 	}
    12. 	//判断pos的合法性
    13. 	if (pos < 1 || pos > ps->size)
    14. 	{
    15. 		printf("pos非法！");
    16. 		exit(-1);
    17. 	}
    18.  
    19. 	for (int i = pos - 1; i < ps->size; i++)
    20. 	{
    21. 		ps->data[i] = ps->data[i + 1];
    22. 	}
    23. 	ps->size--;
    24. }

    这里还是注意pos的合法性！！！

    OK，测试一下：

    OK，没有问题~！

    动态顺序表中查找指定元素x

    这个还是和上面的一样找到了返回下标，否则返回-1（如果是已经有序的就可以采用二分查找）

    1. //查找指定元素x
    2. int SLFind(SL* ps, SLDataType x)
    3. {
    4. 	assert(ps);
    5.  
    6. 	for (int i = 0; i < ps->size; i++)
    7. 	{
    8. 		if (x == ps->data[i])
    9. 		{
    10. 			return i;
    11. 		}
    12. 	}
    13.  
    14. 	return -1;
    15. }

    动态顺序表中修改指定pos位置的元素

    1. //修改pos位置的值
    2. void SLModif(SL* ps, int pos, SLDataType x)
    3. {
    4. 	assert(ps);
    5.  
    6. 	if (pos >=1 && pos <= ps->size)
    7. 	{
    8. 		ps->data[pos - 1] = x;
    9. 	}
    10. 	else
    11. 	{
    12. 		printf("pos非法！\n");
    13. 		exit(-1);
    14. 	}
    15. }

    这里也是注意判断pos的合法性~！！！否则会出问题！！！

    OK，测试一下：

    OK，没有问题~！

    全部源码：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include 
    3. #include 
    4. #include 
    5.  
    6.  
    7. typedef int SLDataType;
    8. typedef struct SeqList
    9. {
    10. 	SLDataType* data;
    11. 	int size;//顺序表的元素个数
    12. 	int capacity;//顺序表的容量
    13. }SL;
    14.  
    15. //初始化
    16. void SLInit(SL* ps);
    17.  
    18. //销毁
    19. void SLDestory(SL* ps);
    20.  
    21. //打印
    22. void SLPrint(SL* ps);
    23.  
    24. //尾插
    25. void SLPushBack(SL* ps, SLDataType x);
    26.  
    27. //尾删
    28. void SLPopBack(SL* ps);
    29.  
    30. //头插
    31. void SLPushFront(SL* ps, SLDataType x);
    32.  
    33. //头删
    34. void SLPopFront(SL* ps);
    35.  
    36. //排序
    37. void SLSort(SL* ps);
    38.  
    39. //在pos位置插入
    40. void SLInsert(SL* ps, int pos, SLDataType x);
    41.  
    42. //删除pos位置的元素
    43. void SLErase(SL* ps, int pos);
    44.  
    45. //查找指定元素x
    46. int SLFind(SL* ps, SLDataType x);
    47.  
    48. //修改pos位置的值
    49. void SLModif(SL* ps, int pos, SLDataType x);
    1. #include "SeqList.h"
    2.  
    3. //初始化
    4. void SLInit(SL* ps)
    5. {
    6. 	assert(ps);
    7. 	ps->data = (SLDataType*)malloc(sizeof(SLDataType) * 4);
    8. 	if (!ps->data)
    9. 	{
    10. 		perror("malloc failed");
    11. 		exit(-1);//异常终止
    12. 	}
    13.  
    14. 	ps->size = 0;
    15. 	ps->capacity = 4;
    16. }
    17.  
    18. //销毁
    19. void SLDestory(SL* ps)
    20. {
    21. 	assert(ps);
    22.  
    23. 	free(ps->data);
    24. 	ps->data = NULL;
    25. 	ps->size = ps->capacity = 0;
    26. }
    27.  
    28. //打印
    29. void SLPrint(SL* ps)
    30. {
    31. 	assert(ps);
    32.  
    33. 	for (int i = 0; i < ps->size; i++)
    34. 	{
    35. 		printf("%d ", ps->data[i]);
    36. 	}
    37. 	printf("\n");
    38. }
    39.  
    40. //判断扩容
    41. void JudExpan(SL* ps)
    42. {
    43. 	assert(ps);
    44.  
    45. 	if (ps->size == ps->capacity)
    46. 	{
    47. 		int newcapacity = ps->capacity * 2;
    48. 		SLDataType* tmp = (SLDataType*)realloc(ps->data, sizeof(SLDataType) * newcapacity);
    49. 		if (!tmp)
    50. 		{
    51. 			perror("realloc failed");
    52. 			exit(-1);
    53. 		}
    54.  
    55. 		ps->data = tmp;
    56. 		ps->capacity = newcapacity;
    57. 	}
    58. }
    59.  
    60. //尾插
    61. void SLPushBack(SL* ps, SLDataType x)
    62. {
    63. 	assert(ps);
    64.  
    65. 	JudExpan(ps);
    66. 	ps->data[ps->size] = x;
    67. 	ps->size++;
    68. }
    69.  
    70. //尾删
    71. void SLPopBack(SL* ps)
    72. {
    73. 	assert(ps);
    74.  
    75. 	//判断是否为空
    76. 	if (ps->size == 0)
    77. 	{
    78. 		printf("顺序表为空无法删除！\n");
    79. 		exit(-1);
    80. 	}
    81.  
    82. 	ps->size--;
    83. }
    84.  
    85. //头插
    86. void SLPushFront(SL* ps, SLDataType x)
    87. {
    88. 	assert(ps);
    89.  
    90. 	JudExpan(ps);
    91. 	for (int i = ps->size; i > 0; i--)
    92. 	{
    93. 		ps->data[i] = ps->data[i - 1];
    94. 	}
    95. 	ps->data[0] = x;
    96. 	ps->size++;
    97. }
    98.  
    99. //头删
    100. void SLPopFront(SL* ps)
    101. {
    102. 	assert(ps);
    103.  
    104. 	//判断是否为空
    105. 	if (ps->size == 0)
    106. 	{
    107. 		printf("顺序表为空无法删除！\n");
    108. 		exit(-1);
    109. 	}
    110.  
    111. 	for (int i = 0; i < ps->size; i++)
    112. 	{
    113. 		ps->data[i] = ps->data[i + 1];
    114. 	}
    115. 	ps->size--;
    116. }
    117.  
    118. //比较函数
    119. int cmp(const void* a, const void* b)
    120. {
    121. 	return *(int*)a - *(int*)b;
    122. }
    123.  
    124. //排序
    125. void SLSort(SL* ps)
    126. {
    127. 	assert(ps);
    128. 	qsort(ps->data, ps->size, sizeof(SLDataType), cmp);
    129. }
    130.  
    131. //在pos位置插入
    132. void SLInsert(SL* ps, int pos, SLDataType x)
    133. {
    134. 	assert(ps);
    135.  
    136. 	JudExpan(ps);
    137. 	//判断pos的合法性
    138. 	if (pos > ps->capacity || pos < 1)
    139. 	{
    140. 		printf("pos非法!");
    141. 		exit(-1);
    142. 	}
    143.  
    144. 	for (int i = ps->size; i >= pos; i--)
    145. 	{
    146. 		ps->data[i] = ps->data[i - 1];
    147. 	}
    148. 	ps->data[pos - 1] = x;
    149. 	ps->size++;
    150. }
    151.  
    152. //删除pos位置的元素
    153. void SLErase(SL* ps, int pos)
    154. {
    155. 	assert(ps);
    156.  
    157. 	//判断是否为空
    158. 	if (ps->size == 0)
    159. 	{
    160. 		printf("顺序表为空无法删除！\n");
    161. 		exit(-1);
    162. 	}
    163. 	//判断pos的合法性
    164. 	if (pos < 1 || pos > ps->size)
    165. 	{
    166. 		printf("pos非法！");
    167. 		exit(-1);
    168. 	}
    169.  
    170. 	for (int i = pos - 1; i < ps->size; i++)
    171. 	{
    172. 		ps->data[i] = ps->data[i + 1];
    173. 	}
    174. 	ps->size--;
    175. }
    176.  
    177.  
    178. //查找指定元素x
    179. int SLFind(SL* ps, SLDataType x)
    180. {
    181. 	assert(ps);
    182.  
    183. 	for (int i = 0; i < ps->size; i++)
    184. 	{
    185. 		if (x == ps->data[i])
    186. 		{
    187. 			return i;
    188. 		}
    189. 	}
    190.  
    191. 	return -1;
    192. }
    193.  
    194. //修改pos位置的值
    195. void SLModif(SL* ps, int pos, SLDataType x)
    196. {
    197. 	assert(ps);
    198.  
    199. 	if (pos >=1 && pos <= ps->size)
    200. 	{
    201. 		ps->data[pos - 1] = x;
    202. 	}
    203. 	else
    204. 	{
    205. 		printf("pos非法！\n");
    206. 		exit(-1);
    207. 	}
    208. }
    1. #include "SeqList.h"
    2.  
    3. //测试尾插、尾删
    4. void test()
    5. {
    6. 	SL s;
    7. 	SLInit(&s);
    8. 	SLPushBack(&s, 1);
    9. 	SLPushBack(&s, 2);
    10. 	SLPushBack(&s, 3);
    11. 	SLPushBack(&s, 4);
    12. 	SLPrint(&s);
    13. 	//检查扩容
    14. 	SLPushBack(&s, 5);
    15. 	SLPrint(&s);
    16.  
    17. 	SLPopBack(&s);
    18. 	SLPrint(&s);
    19. 	SLPopBack(&s);
    20. 	SLPrint(&s);
    21. 	SLPopBack(&s);
    22. 	SLPrint(&s);
    23. 	SLPopBack(&s);
    24. 	SLPrint(&s);
    25. 	SLPopBack(&s);
    26. 	SLPrint(&s);
    27.  
    28. 	//检查是否已经为空是的删除是否有Bug
    29. 	SLPopBack(&s);
    30. 	SLPrint(&s);
    31.  
    32. 	SLDestory(&s);
    33. }
    34.  
    35. //测试头插、头删
    36. void test2()
    37. {
    38. 	SL s;
    39. 	SLInit(&s);
    40.  
    41. 	SLPushFront(&s, -1);
    42. 	SLPushFront(&s, 3);
    43. 	SLPushFront(&s, 0);
    44. 	SLPushFront(&s, 1);
    45. 	SLPrint(&s);
    46. 	//判断扩容
    47. 	SLPushFront(&s, 10);
    48. 	SLPrint(&s);
    49.  
    50. 	SLSort(&s);
    51. 	SLPrint(&s);
    52.  
    53. 	SLPopFront(&s);
    54. 	SLPrint(&s);
    55. 	SLPopFront(&s);
    56. 	SLPrint(&s);
    57. 	SLPopFront(&s);
    58. 	SLPrint(&s);
    59. 	SLPopFront(&s);
    60. 	SLPrint(&s);
    61. 	SLPopFront(&s);
    62. 	SLPrint(&s);
    63. 	//检查为空时删除是否有Bug
    64. 	SLPopFront(&s);
    65. 	SLPrint(&s);
    66.  
    67. 	SLDestory(&s);
    68. }
    69.  
    70. //测试在pos位置插入、删除
    71. void test3()
    72. {
    73. 	SL s;
    74. 	SLInit(&s);
    75. 	SLPushBack(&s, 1);
    76. 	SLPushBack(&s, 2);
    77. 	SLPushBack(&s, 3);
    78. 	SLPushBack(&s, 4);
    79. 	SLPrint(&s);
    80.  
    81. 	SLInsert(&s, 4, 10);
    82. 	SLPrint(&s);
    83. 	SLInsert(&s, 4, -1);
    84. 	SLPrint(&s);
    85. 	//SLInsert(&s, 20, 7);
    86. 	//SLPrint(&s);
    87.  
    88. 	SLErase(&s, 1);
    89. 	SLPrint(&s);
    90. 	SLErase(&s, 5);
    91. 	SLPrint(&s);
    92. 	//SLErase(&s, -0);
    93. 	//SLPrint(&s);
    94.  
    95. 	SLDestory(&s);
    96. }
    97.  
    98. //测试查找指定元素和修改pos位置的值
    99. void test4()
    100. {
    101. 	SL s;
    102. 	SLInit(&s);
    103. 	SLPushBack(&s, 1);
    104. 	SLPushBack(&s, 2);
    105. 	SLPushBack(&s, 3);
    106. 	SLPushBack(&s, 4);
    107. 	SLPrint(&s);
    108.  
    109. 	int ret = SLFind(&s, -1);
    110. 	if (ret != -1)
    111. 	{
    112. 		printf("找到了，下标是: %d  顺序表位置是: %d ", ret, ret + 1);
    113. 	}
    114. 	else
    115. 	{
    116. 		printf("没找到！\n");
    117. 	}
    118.  
    119. 	SLModif(&s, 1, -10);
    120. 	SLPrint(&s);
    121. 	SLModif(&s, -1, -10);
    122. 	SLPrint(&s);
    123. }
    124.  
    125. int main()
    126. {
    127. 	test4();
    128. 	return 0;
    129. }

    OK~！两个版本的顺序表就完成了~！

    五、顺序表的问题

    1、在顺序表中间或头部进行插入或删除时的时间复杂度为O(N)

    2、扩容时如果到数据多的时候会异地扩容，会增加空间复杂度~！

    3、无论静态还是动态顺序表其实都会都空间浪费的现象，这是避免不了的~！

    关于这些问题如何解决，请期待下一期：链表~！！！

    OK，本期内容就分享到这里~！好兄弟，我们下期再见！！！

  • 相关阅读:
    LeetCode Hot-100
    第三篇【传奇开心果系列】Python的自动化办公库技术点案例示例：深度解读Pandas股票市场数据分析
    邮编区号查询易语言代码
    使用UICollectionView制作轮播图（一）
    你真的会使用 《断点》 吗
    Spring Cloud入门看这一篇就够了
    【微服务】SpringCloud的OpenFeign与Ribbon配置
    MybatisPlus【SpringBoot】 2 入门案例
    路由知识——路由分类+RIP相关知识+链路状态协议和距离矢量协议的区别
    网课搜题公众号搭建 查题接口教程
  • 原文地址：https://blog.csdn.net/m0_75256358/article/details/132912696