长春 万网 网站建设关键词林俊杰无损下载

Hello~,欢迎大家来到我的博客进行学习！

1.线性表

首先我们需要知道的是，顺序表和链表都属于线性表。线性表是具有相同特性的一类数据结构的集合。

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是⼀种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…

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

这里的相同特性我从逻辑结构和物理结构两个方面进行分析。

• 逻辑结构（一定是线性的）：人为想象出来的。
• 物理结构(不一定是线性的）：比如数组在存储空间是连续的，和物理结构上的线性是一样的。

2.顺序表

2.1 概念与结构

概念：顺序表是用⼀段物理地址连续的存储单元（物理结构是线性的）依次存储数据元素的线性结构，⼀般情况下采用数组存储。顺序表的底层结构是数组。

顺序表和数组的区别？
顺序表的底层结构是数组，对数组的封装，实现了常用的增删改查等接口。

2.2 分类

2.2.1 静态顺序表

如果顺序表底层是固定的空间大小，我们把它叫做静态顺序表。
实现静态顺序表，需要三个文件：头文件(.h)、源文件(.c)、测试文件(test.c)。

• 头文件(.h)：用来声明一些结构和我们的方法
• 源文件(.c)：方法的具体实现
• 测试文件(test.c)：用于测试

取名为SeqList（Sequence List），意为连续的。
我们可以定义一下静态顺序表的大小N，还需要一个size来定义一下有效数据的个数。同时这里的数据类型可能是各种各样的，使用typedef来解决。当要使用这个结构体的时候，我每次都要加上关键词，感觉麻烦，使用typedef来解决。

SeqList.h

#define N 1000
typedef char SLDataType;
//静态顺序表
typedef struct SeqList {SLDataType arr[N];int size;//有效数据的个数
}SL;

2.2.2 动态顺序表

如果空间是不固定的，我想要多少，可以去增加，就是动态顺序表。

#define N 1000
typedef char SLDataType;
//动态顺序表
typedef struct SeqList {SLDataType* arr;int size;//有效数据的个数int capacity;//容量大小
}SL;

2.3 动态顺序表的实现

初始化

现在我先进行初始化，参数传一个s,初始化的具体方法在SeqList.c文件中实现。
SeqList.c

#include"SeqList.h"
//初始化
void SLInit(SL s)
{s.arr = NULL;s.size = s.capacity = 0;
}

在test.c中进行检验。

#include"SeqList.h"
void SLTest()
{SL sl;SLInit(sl);
}int main()
{SLTest();return 0;
}

此时会报错：

在test.c的sl是实参，在SeqList里面的s为形参。

我们需要将sl的地址传过去，而不是传值。传值时，改变形参并不能改变实参。在SeqList.c这里我就应该用指针来接收。
改完以后：
SeqList.c

#include"SeqList.h"
//初始化
void SLInit(SL* ps)
{ps->arr = NULL;ps->size = ps->capacity = 0;
}

test.c

#include"SeqList.h"
void SLTest()
{SL sl;SLInit(&sl);
}int main()
{SLTest();return 0;
}

SeqList.h

#include<stdio.h>
#include<stdlib.h>
#define N 1000
typedef int SLDataType;
静态顺序表
//typedef struct SeqList {
//	SLDataType arr[N];
//	int size;//有效数据的个数
//}SL;//动态顺序表
typedef struct SeqList {SLDataType* arr;int size;//有效数据的个数int capacity;//容量大小
}SL;//初始化
void SLInit(SL* ps);

调试看看：

跳出以后，sl里面的部分也初始化了：

尾插

现在来添加插入数据的功能，顺序表的底层是数组，我可能需要需要在原来数据的末尾、中间、开头插入数据。
首先实现尾插（在顺序表最后一个可插的位置，插入数据）的功能。

如上图，我有5块空间，里面有3个有效数据。尾插就是在3的后面插入数据。

用SLPushBack这个函数来实现，里面的参数为ps和我们要插入的数据。现在我们需要在顺序表里插入数据，这里有三个成员：arr、size、capacity。size指向的位置刚好就是最后一个有效数据的下一个位置。

假设空间足够，现在往里面插入一个数据X = 99，直接往3后面放，这里并不需要遍历数据组，往size这个位置放就行，插入完成之后，size++。

//尾插
void SLPushBack(SL* ps, SLDataType x)
{ps->arr[ps->size] = x;++ps->size;
}

假设空间不够（此时size和capacity在一个位置），按以上方式插入数据，会越界。就需要对原数组申请空间，，然后再在size位置插入数据，插入后size++。
因而我们需要分情况来写。

在增容时，我们使用realloc（可以在原数组的基础上进行增加容量）来进行这一操作。如果插一个数据，增加一个容量，没有空间的浪费，但是增容频繁，程序效率低下。如果一次多申请一些，可能会造成空间的浪费。通常，增容是按倍数增加，如2倍、3倍…这里我选择两倍。

按照以上思路，其实是有漏洞的。

//尾插
void SLPushBack(SL* ps, SLDataType x)
{//空间不够，申请空间if (ps->size == ps->capacity){//空间不够，2倍增容SLDataType* tmp = (SLDataType*)realloc(ps->arr, ps->capacity * 2);}ps->arr[ps->size++] = x;
}

在realloc这里，第二个参数是size_t size单位是字节，ps->capacity * 2 这里改为 ps->capacity * 2 *sizeof（SLDataType）。并看看增容成功没有。但是之前我们初始化那里把capacity初始化为0，现在需要扩容的话，需要先给一个初始值。我这里先给一个SLDestroy函数，在程序结束时释放动态分配的内存，不然程序结束时会出现内存泄漏。
SeqList.c

#include"SeqList.h"
//初始化
void SLInit(SL* ps)
{ps->arr = NULL;ps->size = ps->capacity = 0;
}//尾插
void SLPushBack(SL* ps, SLDataType x)
{if (ps == NULL){return;}//空间不够，申请空间if (ps->size == ps->capacity){int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//空间不够，2倍增容SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));if (tmp == NULL){perror("realloc fail!");exit(1);}ps->arr = tmp;ps->capacity = newCapacity;}ps->arr[ps->size++] = x;
}// 释放顺序表
void SLDestroy(SL* ps) 
{if (ps->arr != NULL) {free(ps->arr);  // Free the allocated memoryps->arr = NULL;}
}

头插

现在来实现头插。这里也要看空间大小够不够，则可以分装一个方法来判断空间大小够不够。前面的步骤和尾插差不多，只是实现头插时有部分区别。需要把数据整体往后移动，然后再进行插入。在移动的时候，先把后面的数据往后移动，最后把插入的数据放在下标为0的位置。同样在增加完数据之后，size++。
SeqList.c

#include"SeqList.h"
//初始化
void SLInit(SL* ps)
{ps->arr = NULL;ps->size = ps->capacity = 0;
}void SLcheckCapacity(SL* ps)
{//空间不够，申请空间if (ps->size == ps->capacity){int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//空间不够，2倍增容SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));if (tmp == NULL){perror("realloc fail!");exit(1);}ps->arr = tmp;ps->capacity = newCapacity;}
}//尾插
void SLPushBack(SL* ps, SLDataType x)
{if (ps == NULL){return;}SLcheckCapacity(ps);ps->arr[ps->size++] = x;
}//头插
void SLPushFront(SL* ps, SLDataType x)
{if (ps == NULL){return;}SLcheckCapacity(ps);//直接头插//数据整体向后移动一位for (int i = ps->size; i > 0; i--){ps->arr[i] = ps->arr[i - 1];}ps->arr[0] = x;++ps->size;
}

尾删

ps不能传空，删除数据之后，size要 - -。顺序表为空，也不行。这里把最后一个数据弄掉，不是把最后一个数据弄为0，而是可以修改。

//尾删
void SLPopBack(SL* ps)
{assert(ps&&ps->size>0);--ps->size;}

头删

这里的前提和尾删一样。ps不能传空，删除数据之后，size要 - -。顺序表为空，也不行。我们需要移动数据，下标为零以后的数据，整体向前移动一位。

//头删
void SLPopFront(SL* ps)
{assert(ps && ps->size > 0);--ps->size;for (int i = 0; i<ps->size-1; i++){ps->arr[i] = ps->arr[i + 1];}
}

查找

这里比较简单，遍历顺序表，如果查找到返回下标；如果找不到返回无效下标。

//查找
int SLFind(SL* ps, SLDataType x)
{for(int i = 0; i < ps->size; i++){if (x == ps->arr[i]){//找到了，返回下标return i;}}//找不到return -1;
}

指定位置之前插入数据

这里新增一个参数pos（指定位置）。pos需要有效，pos >= 0 && pos <= ps->size。与之前一样需要判断空间是否足够，插入好之后size++。
假设需要将99这个数据插入3这个位置之前，需要将pos以及之后的数据向后移动一位。

//指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x)
{assert(ps);//前=：头插//后=：尾插assert(pos >= 0 && pos <= ps->size);SLcheckCapacity(ps);for (int i = ps->size - 1; i > pos; i--){ps->arr[i] = ps->arr[i - 1];}ps->arr[pos] = x;++ps->size;
}

删除指定位置的数据

同样的size需要减减，指定位置pos必须pos >= 0 && pos <= ps->size。要删除pos位置的数据就需要把pos之后的数据整体向前移。

//删除指定位置的数据
void SLErase(SL* ps, int pos)
{assert(ps);assert(pos >= 0 && pos < ps->size);for (int i = pos;i<ps->size-1; i++){ps->arr[i] = ps->arr[i + 1];}--ps->size;
}

销毁

动态申请的空间在不用的时候需要销毁。

//销毁
void SLDestroy(SL* ps)
{if (ps->arr)free(ps->arr);ps->arr = NULL;ps->size = ps->capacity = 0;
}

此时，我们对顺序表已经比较理解了。

好了，我们的顺序表的知识就讲到这里。如果文章内容有误，请大佬在评论区斧正！谢谢大家！