• 数据结构与算法之顺序表详解

    标题：顺序表的思路及代码实现

    作者：@Ggggggtm

    寄语：与其忙着诉苦，不如低头赶路，奋路前行，终将遇到一番好风景

    文章目录：

    一、顺序表的概念与结构

    1、线性表的解释

    2、顺序表概念解释

    二、顺序表的思路及代码实现详解

    1、静态顺序表的实现

    2、动态顺序表思路及代码实现

    2、1 动态顺序表的整体思路

    2、2 定义结构体的实现

    2、3 初始化结构体

    2、4 结构体打印 

    2、5 检查数组容量

    2、6 头插

    2、7 尾插

    2、8 头删

    2、9 尾删

    2、10 任意删除

    2、11 任意插入

    2、12 空间释放

     三、顺序表代码整合

    SeqList.h

    SeqList.c

    test.c

    一、顺序表的概念与结构

    1、线性表的解释

      首先我们在这里引入线性表的概念。线性表是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构。

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

      线性表在逻辑上是线性结构，也就是说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数据和链式结构的形式存储。 

      顺序表就是线性表的一种，我们在这里详细解释一下顺序表的实现，后续我们会更新链表等内容。

    2、顺序表概念解释

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

       而顺序表一般可分为：

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

    二、顺序表的思路及代码实现详解

    1、静态顺序表的实现

      我们先想出来一个静态表整体的模板思路： 

    1. 定义一个结构体，该结构体包含一个可以存放数据的数组和记录数组中有效数字的变量。
    2. 初始化结构体。
    3. 打印结构体。
    4. 头插。
    5. 尾插。
    6. 头删。
    7. 尾删。
    8. 任意位置插入。
    9. 任意位置删除。

       这里需要有一点注意的是，我们在定义结构体中的数组时，我们可以用typedef进行变量名简化，这也方便我们后期更改存储类型的时候直接更改typedef处就行。同时我们会想到数组的大小需要define定义一个宏，这样大大提高了代码后期的可维护性。

      但是我们仔细想一下，假如我们存储的数据满了，我们想要继续存储的话还要找到源码进行更改大小 。每次存储满了，都要更改。那是不是太麻烦了，且效率很低。这时候我们就联想到了动态的顺序表，可以自动开辟空间，从而大大提高效率。

      这里我就给出大家静态顺序表定义及接口的代码，不再详细解释接口的实现了。我们这里详细解释一下动态顺序表的解释。静态顺序表接口的实现与动态顺序表接口实现大同小异，可参考动态顺序表接口的详解。

      代码如下：

    1. #define MAX_SIZE 10
    2. typedef int SQDataType;
    3. typedef struct SeqList
    4. {
    5. 	SQDataType a[MAX_SIZE];
    6. 	int size;
    7. }SL;
    8. //typedef struct SeqList SL;
    9.  
    10. typedef struct SeqList SL;
    11. //初始化结构体
    12. void SeqListInit(SL* ps);
    13. //打印
    14. void SeqListPrint(SL s);
    15. //尾插
    16. void SeqListPushBack(SL* ps, SQDataType x);
    17. //尾删
    18. void SeqListPopBack(SL* ps);
    19. //头插
    20. void SeqListPushFrint(SL* ps, SQDataType x);
    21. //头删
    22. void SeqListPopFrint(SL* ps);
    23. //查找位置
    24. int SeqListFind(SL s, SQDataType x);
    25. //任意插入
    26. void SeqListInsert(SL* ps, int pos, SQDataType x);
    27. //任意删
    28. void SeqListErase(SL* ps, int pos);

    2、动态顺序表思路及代码实现

    2、1 动态顺序表的整体思路

      动态顺序表的思路与静态大致相同，但也有所不同，我来给大家详细解释一下。我们先看动态顺序表的整体思路模板：

    1. 定义一个结构体，该结构体包含一个可以存放数据的动态数组和记录数组中有效数据的变量，两外还需要一个变量记录当前数组的大小。
    2. 初始化结构体。
    3. 打印结构体。
    4. 检查数组容量
    5. 头插。
    6. 尾插。
    7. 头删。
    8. 尾删。
    9. 任意位置插入。
    10. 任意位置删除。
    11. 释放动态数组空间

      我们上面提到了动态的数组，需要用malloc或realloc动态开辟空间。由于是动态开辟的，我们这里多了一项释放动态开辟的空间。注意，记录数组的有效数据和数组大小并不相同。有效数据是已经存储的数据个数 ，而数组大小是指最能够存储数组的个数。我们为什么要记录数组的大小呢？这里是用来判断是否存储满了，满了话要开辟空间。

      我们来详细看一下每个接口的实现。

    2、2 定义结构体的实现

      在定义结构体时，我们可以用typedef进行数组类型简化，同时方便我们后期更改存储类型的时候直接更改typedef处即可。同时我们也用typedef进行结构体类型简化，方便我们以后编辑代码。我们来看一下代码的实现：

    1. typedef int SQDataType;
    2. struct SeqList
    3. {
    4. 	SQDataType* a;
    5. 	int size;
    6. 	int capacity;
    7. };
    8. typedef struct SeqList SL;

       通过上面的代码我们可以发现，当我们不想存储int型数据时，我们只需把‘typedef int SQDataType’改为‘typedef double SQDataType’即可。极大的提高了代码的维护性。

    2、3 初始化结构体

      我们初始化结构体时，可以先将数组置空，我们后期插入数据时可再开辟空间。同时当然有效数据和数组大小都要初始化成零。我们看代码的实现。 

    1. void SeqListInit(SL* ps)
    2. {
    3. 	ps->a = NULL;
    4. 	ps->size = 0;
    5. 	ps->capacity = 0;
    6. }

      我们这里是改变了结构体的内容，所以需要传地址，用指针变量来接收。 

    2、4 结构体打印 

      结构体打印方便我们观察对动态数组的操作。打印的时数组的有效数据的内容。我们来看代码的实现。

    1. void SeqListPrint(SL s)
    2. {
    3. 	int i = 0;
    4. 	for (i = 0; i < s.size; i++)
    5. 	{
    6. 		printf("%d ", s.a[i]);
    7. 	}
    8. 	printf("\n");
    9. }

    2、5 检查数组容量

      我们仔细想一想，是不是在插入每个数据之前都要检查数组是否已经满了。如果满了，则需要增容。如果没有满，就插入数据即可。在这里我们需要实现头插、尾插、任意插入三个接口，所以我们就把检查数组容量单独分装一个函数，这样提高代码的简洁性。我们看一下代码的实现。

    1. void SQLCheckCapacity(SL* ps)
    2. {
    3. 	if (ps->size == ps->capacity)
    4. 	{
    5. 		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    6. 		SQDataType* tmp =(SQDataType*)realloc(ps->a, sizeof(SQDataType) * newcapacity);
    7. 		if (tmp == NULL)
    8. 		{
    9. 			printf("realloc failed\n");
    10. 			exit(-1);
    11. 		}
    12. 		ps->capacity = newcapacity;
    13. 		ps->a = tmp;
    14. 	}
    15. 	
    16. }

      当我们检查增容时，我们还要判断一下之前的数组大小是否为零，如果是零的话，我们要给其赋一个值。因为我们刚开始初始化数组的时候把数组指针置空了。 在动态顺序表中我们增容一般会扩大到原来的2倍。

    2、6 头插

      在插入之前要判断数组是否已经满了。头插的思想就是把数组的内容整体后移一位，我们把要插入的数据放在第一位。我们结合着代码一起理解。 

    1. void SeqListPushFrint(SL* ps, SQDataType x)
    2. {
    3. 	SQLCheckCapacity(ps);
    4. 	int end = ps->size - 1;
    5. 	while (end >= 0)
    6. 	{
    7. 		ps->a[end+1] = ps->a[end];
    8. 		end--;
    9. 	}
    10. 	ps->a[0] = x;
    11. 	ps->size++;
    12. }

    2、7 尾插

      同样， 在插入之前要判断数组是否已经满了。尾插的思想很简单。就是直接在数组尾部插入一个数据即可。我们看一下代码的实现。

    1. void SeqListPushBack(SL* ps, SQDataType x)
    2. {
    3. 	SQLCheckCapacity(ps);
    4. 	ps->a[ps->size] = x;
    5. 	ps->size++;
    6. }

    2、8 头删

       删除时我们也有要注意的一点，就是检查数组中是否有元素给我们删除。头删的思想就是除去数组的第一个元素，我们将后面的元素整体向前移动一位，将第一位给覆盖了。我们来看代码。  

    1. void SeqListPopFrint(SL* ps)
    2. {
    3. 	assert(ps->size > 0);
    4. 	int i = 0;
    5. 	for (i = 0; i < ps->size - 1; i++)
    6. 	{
    7. 		ps->a[i] = ps->a[i + 1];
    8. 	}
    9. 	ps->size--;
    10. }

    2、9 尾删

      同样，在尾删之前， 我们要检查数组中是否有元素给我们删除。尾删的思想十分简单，就是把数组的有效数据减一即可。我们看一下代码的实现。

    1. void SeqListPopBack(SL* ps)
    2. {
    3. 	assert(ps->size > 0);
    4. 	ps->size--;
    5. }

    2、10 任意删除

        在任意删除时，我们首先要判断删除的位置是否合理，不能违背顺序表的规则。同样，在尾删之前， 我们要检查数组中是否有元素给我们删除。任意删除就是我们指出删除位置的下标进行删除。当然，我们想要删除数组中指定元素时，我们可以先查出元素下标在进行删除。这个相对来说较复杂一点，我们结合着代码理解一下。

    1. //查找位置
    2. int SeqListFind(SL s, SQDataType x)
    3. {
    4. 	int i = 0;
    5. 	for (i = 0; i < s.size; i++)
    6. 	{
    7. 		if (s.a[i] == x)
    8. 		{
    9. 			return i;
    10. 		}
    11. 	}
    12. 	return -1;
    13. }
    14. void SeqListErase(SL* ps, int pos)
    15. {
    16. 	assert(pos >= 0 && pos < ps->size);
    17. 	int begin = pos + 1;
    18. 	while (begin < ps->size)
    19. 	{
    20. 		ps->a[begin - 1] = ps->a[begin];
    21. 		begin++;
    22. 	}
    23. 	ps->size--;
    24. }

    2、11 任意插入

      在任意插入时时，我们也要判断插入的位置是否合理，不能违背顺序表的规则。插入时，我们不能忘记检查数组是否满了。任意插入的思想与任意删除的思想基本相同。任意插入的思想就是在我们指出删除位置的下标进行插入。我们看一下代码实现。

    1. void SeqListInsert(SL* ps, int pos, SQDataType x)
    2. {
    3. 	assert(pos >= 0 && pos <= ps->size);
    4. 	SQLCheckCapacity(ps);
    5. 	int end = ps->size-1;
    6. 	while (end >= pos)
    7. 	{
    8. 		ps->a[end+1] = ps->a[end];
    9. 		end--;
    10. 	}
    11. 	ps->a[pos] = x;
    12. 	ps->size++;
    13. }

    2、12 空间释放

      由于我们的数组是动态开辟的，所以当我们不用时，我们要及时释放掉动态开辟的空间，避免内存泄漏。同时我们要把数组指针再次置空，避免产生野指针。我们看代码实现。 

    1. void SeqListDestory(SL* ps)
    2. {
    3. 	free(ps->a);
    4. 	ps->a = NULL;
    5. 	ps->capacity = ps->size = 0;
    6. }

     三、顺序表代码整合

      由于代码量相对来说有一点多，所以我们就将函数的声明的定义分开，这样有利于提高代码的可读性，同时会保持一个良好的思路，且方便编写代码。

      我们将函数的声明放在单独的一个SeqList.h的头文件，函数的实现放在一个单独的SeqList.c源文件，函数的主方法及调用放在另一个单独的test.c源文件。

    SeqList.h

    1. #include
    2. #include
    3. #include
    4.  
    5. typedef int SQDataType;
    6. struct SeqList
    7. {
    8. 	SQDataType* a;
    9. 	int size;
    10. 	int capacity;
    11. };
    12.  
    13. typedef struct SeqList SL;
    14. //初始化结构体
    15. void SeqListInit(SL* ps);
    16. //打印
    17. void SeqListPrint(SL s);
    18. //尾插
    19. void SeqListPushBack(SL* ps, SQDataType x);
    20. //尾删
    21. void SeqListPopBack(SL* ps);
    22. //头插
    23. void SeqListPushFrint(SL* ps, SQDataType x);
    24. //头删
    25. void SeqListPopFrint(SL* ps);
    26. //查找位置
    27. int SeqListFind(SL s, SQDataType x);
    28. //任意插入
    29. void SeqListInsert(SL* ps, int pos, SQDataType x);
    30. //任意删
    31. void SeqListErase(SL* ps, int pos);
    32. //销毁空间
    33. void SeqListDestory(SL* ps);

    SeqList.c

    1. #include"SeqList.h"
    2.  
    3. //初始化结构体
    4. void SeqListInit(SL* ps)
    5. {
    6. 	ps->a = NULL;
    7. 	ps->size = 0;
    8. 	ps->capacity = 0;
    9. }
    10. //打印
    11. void SeqListPrint(SL s)
    12. {
    13. 	int i = 0;
    14. 	for (i = 0; i < s.size; i++)
    15. 	{
    16. 		printf("%d ", s.a[i]);
    17. 	}
    18. 	printf("\n");
    19. }
    20. //查容增容
    21. void SQLCheckCapacity(SL* ps)
    22. {
    23. 	if (ps->size == ps->capacity)
    24. 	{
    25. 		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    26. 		SQDataType* tmp =(SQDataType*)realloc(ps->a, sizeof(SQDataType) * newcapacity);
    27. 		if (tmp == NULL)
    28. 		{
    29. 			printf("realloc failed\n");
    30. 			exit(-1);
    31. 		}
    32. 		ps->capacity = newcapacity;
    33. 		ps->a = tmp;
    34. 	}
    35. 	
    36. }
    37. //尾插
    38. void SeqListPushBack(SL* ps, SQDataType x)
    39. {
    40. 	SQLCheckCapacity(ps);
    41. 	ps->a[ps->size] = x;
    42. 	ps->size++;
    43. }
    44. //尾删
    45. void SeqListPopBack(SL* ps)
    46. {
    47. 	assert(ps->size > 0);
    48. 	ps->size--;
    49. }
    50. //头插
    51. void SeqListPushFrint(SL* ps, SQDataType x)
    52. {
    53. 	SQLCheckCapacity(ps);
    54. 	int end = ps->size - 1;
    55. 	while (end >= 0)
    56. 	{
    57. 		ps->a[end+1] = ps->a[end];
    58. 		end--;
    59. 	}
    60. 	ps->a[0] = x;
    61. 	ps->size++;
    62. }
    63. //头删
    64. void SeqListPopFrint(SL* ps)
    65. {
    66. 	assert(ps->size > 0);
    67. 	int i = 0;
    68. 	for (i = 0; i < ps->size - 1; i++)
    69. 	{
    70. 		ps->a[i] = ps->a[i + 1];
    71. 	}
    72. 	ps->size--;
    73. }
    74. //查找位置
    75. int SeqListFind(SL s, SQDataType x)
    76. {
    77. 	int i = 0;
    78. 	for (i = 0; i < s.size; i++)
    79. 	{
    80. 		if (s.a[i] == x)
    81. 		{
    82. 			return i;
    83. 		}
    84. 	}
    85. 	return -1;
    86. }
    87. //任意插——在下标为pos的位置插入数据
    88. void SeqListInsert(SL* ps, int pos, SQDataType x)
    89. {
    90. 	assert(pos >= 0 && pos <= ps->size);
    91. 	SQLCheckCapacity(ps);
    92. 	int end = ps->size-1;
    93. 	while (end >= pos)
    94. 	{
    95. 		ps->a[end+1] = ps->a[end];
    96. 		end--;
    97. 	}
    98. 	ps->a[pos] = x;
    99. 	ps->size++;
    100. }
    101. //任意删——删除下标为pos的数据
    102. void SeqListErase(SL* ps, int pos)
    103. {
    104. 	assert(pos >= 0 && pos < ps->size);
    105. 	int begin = pos + 1;
    106. 	while (begin < ps->size)
    107. 	{
    108. 		ps->a[begin - 1] = ps->a[begin];
    109. 		begin++;
    110. 	}
    111. 	ps->size--;
    112. }
    113. //销毁空间
    114. void SeqListDestory(SL* ps)
    115. {
    116. 	free(ps->a);
    117. 	ps->a = NULL;
    118. 	ps->capacity = ps->size = 0;
    119. }

    test.c

    1. #include"SeqList.h"
    2.  
    3. void test()
    4. {
    5. 	SL s1;
    6. 	SeqListInit(&s1);
    7. 	SeqListPushBack(&s1, 1);
    8. 	SeqListPushFrint(&s1, 1);
    9. 	SeqListPushFrint(&s1, 2);
    10. 	SeqListPushFrint(&s1, 3);
    11. 	SeqListPushFrint(&s1, 4);
    12. 	SeqListPushBack(&s1, 5);
    13. 	SeqListPrint(s1);
    14. 	SeqListPopFrint(&s1);
    15. 	SeqListPrint(s1);
    16. 	int pos = SeqListFind(s1, 1);
    17. 	SeqListInsert(&s1, pos, 10);
    18. 	SeqListInsert(&s1, 0, 20);
    19. 	SeqListPrint(s1);
    20. 	SeqListErase(&s1, 0);
    21. 	SeqListPrint(s1);
    22. 	SeqListDestory(&s1);
    23. }
    24. int main()
    25. {
    26. 	test();
    27. 	return 0;
    28. }

      以上就是顺序表的所有内容啦，希望本篇文章会对你有所帮助，感谢阅读。

      后期会持续更新链表哦ovo~。 

  • 相关阅读:
    基于WTMM算法的图像多重分形谱计算matlab仿真
    大数据开发之Hive案例篇10-大表笛卡尔积优化
    ACM MM & ECCV 2022 | 美团视觉8篇论文揭秘内容领域的智能科技
    借降本增效之名，探索开闭原则架构设计
    01--MySQL数据库概述
    程序员必须要懂的首字母大写规范
    TCP/IP 测试题（五）
    vscode推荐插件20220901
    spring---第七篇
    7.springboot中整合Jpa多数据源
  • 原文地址：https://blog.csdn.net/weixin_67596609/article/details/127967719