顺序表(线性表的顺序存储结构)及C语言实现

逻辑结构上呈线性分布的数据元素在实际的物理存储结构中也同样相互之间紧挨着，这种存储结构称为 线性表的顺序存储结构 。

也就是说，逻辑上具有线性关系的数据按照前后的次序全部存储在一整块连续的内存空间中，之间不存在空隙，这样的存储结构称为顺序存储结构。

使用顺序存储结构存储的数据，第一个元素所在的地址就是这块存储空间的首地址。通过首地址，可以轻松访问到存储的所有的数据，只要首地址不丢，数据永远都能找着（一根绳上的蚂蚱，要有就都有）。

使用线性表的顺序存储结构生成的表，称为 顺序表 。

图1 顺序表结构示意图

顺序表的实现方法

顺序表中存放数据的特点和数组这种数据类型完全吻合，所以顺序表的实现使用的是数组。

数组实现顺序表的存储结构时，一定要注意预先申请足够大的内存空间，避免因存储空间不足，造成数据溢出，导致不必要的程序错误甚至崩溃。

顺序表的存储结构

在建立顺序表时，除了预先申请内存空间，还需要实时记录顺序表的长度和顺序表本身申请的内存大小，便于后期对顺序表中的数据元素进行调取。
 
所以，要自定义顺序表的结构：

1. typedef struct Table{
2. int * head;//声明了一个名为head的长度不确定的数组，也叫“动态数组”
3. int length;//记录当前顺序表的长度
4. int size;//记录顺序表分配的存储容量
5. }table;

顺序表的创建

顺序表的建立，也就是顺序表进行初始化，在预先申请内存空间的同时，给变量size和length赋初值：

1. table initTable(){
2. table t;
3. t.head=(int*)malloc(Size*sizeof(int));//构造一个空的顺序表，动态申请存储空间
4. if (!t.head) //如果申请失败，作出提示并直接退出程序
5. {
6. printf("初始化失败");
7. exit(0);
8. }
9. t.length=0;//空表的长度初始化为0
10. t.size=Size;//空表的初始存储空间为Size
11. return t;
12. }

顺序表查找元素

在数组中查找某个数据元素时，可以采取多种查找算法，例如二分查找、插值查找、斐波那契查找算法等。

具体的查找算法以及各自的时间复杂度后续章节会介绍。

根据顺序表中存储的数据的特点，选择合适的算法。这里，采用顺序查找算法（普通的遍历算法）。

实现代码：

1. //查找函数，其中，elem表示要查找的数据元素的值
2. int selectTable(table t,int elem){
3. for (int i=0; i<t.length; i++) {
4. if (t.head[i]==elem) {
5. return i+1;
6. }
7. }
8. return -1;//如果查找失败，返回-1
9. }

顺序表中更改元素

顺序表中更改数据元素，最简单直接的方式就是：调用查找算法找到该数据元素的位置，直接在该位置上更改。

实现代码：

1. //更改函数，其中，elem为要更改的元素，newElem为新的数据元素
2. table amendTable(table t,int elem,int newElem){
3. int add=selectTable(t, elem);
4. t.head[add-1]=newElem;//由于返回的是元素在顺序表中的位置，所以-1就是该元素在数组中的下标
5. return t;
6. }

顺序表插入元素

插入数据元素，无非三种情况：

1. 在表头插入
2. 在表的中间某个位置插入
3. 直接尾随顺序表，作为表的最后一个元素

无论在顺序表的什么位置插入数据元素，解决办法都是：找到要插入的位置，将后续数据元素整体向后移动一个位置，最后直接在腾出来的位置上插入数据元素。

实现代码：

1. //插入函数，其中，elem为插入的元素，add为插入到顺序表的位置
2. table addTable(table t,int elem,int add)
3. {
4. //判断插入本身是否存在问题（如果插入元素位置比整张表的长度+1还大（如果相等，是尾随的情况），
5. //或者插入的位置本身不存在，程序作为提示并自动退出）
6. if (add>t.length+1||add<1) {
7. printf("插入位置有问题");
8. return t;
9. }
10. //做插入操作时，首先需要看顺序表是否有多余的存储空间提供给插入的元素，如果没有，需要申请
11. if (t.length==t.size) {
12. t.head=(int *)realloc(t.head, (t.size+1)*sizeof(int));
13. if (!t.head) {
14. printf("存储分配失败");
15. return t;
16. }
17. t.size+=1;
18. }
19. //插入操作，需要将从插入位置开始的后续元素，逐个后移
20. for (int i=t.length-1; i>=add-1; i--) {
21. t.head[i+1]=t.head[i];
22. }
23. //后移完成后，直接将所需插入元素，添加到顺序表的相应位置
24. t.head[add-1]=elem;
25. //由于添加了元素，所以长度+1
26. t.length++;
27. return t;
28. }

注意：在此程序中，当数组存储空间不足时，使用realloc函数每次额外多申请 1 个int型的存储空间，这么做还不是最优。最好的办法就是每次发现空间不够时，多申请几个内存空间，这么做的好处是：在后续做插入操作过程中不需要每次都运行realloc函数，提高了程序的运行效率。

顺序表删除元素

在数组中删除元素时，只需将该元素所在位置后的所有数据元素整体前移 1 个位置即可。

前移的过程中被删除元素被后一个元素覆盖掉，间接实现了删除操作。

实现代码：

1. table delTable(table t,int add){
2. if (add>t.length || add<1) {
3. printf("被删除元素的位置有误");
4. exit(0);
5. }
6. //删除操作
7. for (int i=add; i<t.length; i++) {
8. t.head[i-1]=t.head[i];
9. }
10. t.length--;
11. return t;
12. }

完整的程序

1. #include
2. #include
3. #define Size 4
4. typedef struct Table{
5. int * head;
6. int length;
7. int size;
8. }table;
10. table initTable(){
11. table t;
12. t.head=(int*)malloc(Size*sizeof(int));
13. if (!t.head)
14. {
15. printf("初始化失败");
16. exit(0);
17. }
18. t.length=0;
19. t.size=Size;
20. return t;
21. }
23. table addTable(table t,int elem,int add)
24. {
25. if (add>t.length+1||add<1) {
26. printf("插入位置有问题");
27. return t;
28. }
29. if (t.length>=t.size) {
30. t.head=(int *)realloc(t.head, (t.size+1)*sizeof(int));
31. if (!t.head) {
32. printf("存储分配失败");
33. }
34. t.size+=1;
35. }
36. for (int i=t.length-1; i>=add-1; i--) {
37. t.head[i+1]=t.head[i];
38. }
39. t.head[add-1]=elem;
40. t.length++;
41. return t;
42. }
43. table delTable(table t,int add){
44. if (add>t.length || add<1) {
45. printf("被删除元素的位置有误");
46. exit(0);
47. }
48. for (int i=add; i<t.length; i++) {
49. t.head[i-1]=t.head[i];
50. }
51. t.length--;
52. return t;
53. }
54. int selectTable(table t,int elem){
55. for (int i=0; i<t.length; i++) {
56. if (t.head[i]==elem) {
57. return i+1;
58. }
59. }
60. return -1;
61. }
62. table amendTable(table t,int elem,int newElem){
63. int add=selectTable(t, elem);
64. t.head[add-1]=newElem;
65. return t;
66. }
67. void displayTable(table t){
68. for (int i=0;i<t.length;i++) {
69. printf("%d",t.head[i]);
70. }
71. printf("\n");
72. }
73. int main(){
74. table t1=initTable();
75. for (int i=1; i<=Size; i++) {
76. t1.head[i-1]=i;
77. t1.length++;
78. }
79. printf("原顺序表：\n");
80. displayTable(t1);
82. printf("删除元素1:\n");
83. t1=delTable(t1, 1);
84. displayTable(t1);
86. printf("在第2的位置插入元素5:\n");
87. t1=addTable(t1, 5, 2);
88. displayTable(t1);
90. printf("查找元素3的位置:\n");
91. int add=selectTable(t1, 3);
92. printf("%d\n",add);
94. printf("将元素3改为6:\n");
95. t1=amendTable(t1, 3, 6);
96. displayTable(t1);
97. return 0;
98. }

输出结果：


原顺序表：
1234
删除元素1:
234
在第2的位置插入元素5:
2534
查找元素3的位置:
3
将元素3改为6:
2564

顺序表的优缺点

顺序表实现的基础，完全借用了数组这一数据类型，优点是在对数据进行遍历时，数据在连续的物理空间中存放，查找的速度比较快。

但是由于数组本身的限制，在向顺序表中新增或者删除数据元素时，如果被操作位置后续有很多数据元素，后续所有的数据元素都需要前移，最后虽然实现了功能，但是程序总体效率不高。