【数据结构】- 顺序表详解(动图演示！！！！）_顺序表存储边的算法流程图

顺序表简介

顺序表(SeqList)是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

顺序表其实就是一个数组，利用一个数组存储数据，要求数据必须连续存储，方便管理

顺序表一般可以分为：

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

静态类型的顺序表开辟固定长度的空间所以只能存储有限个数据，不太实用，当我们遇到不同的情况时就会可能有浪费或者是不够用的情况，它只适用于已经确定知道需要存多少数据的场景

动态顺序表：使用动态开辟的数组存储数据
我们已经知道了静态顺序表的功能和缺点，接下来还有一种类型是动态顺序表

根据我们的需要可以对空间进行增容，随用随增这样不用担心空间不够的问题。

实现顺序表

接下来我们正式进入顺序表
顺序表里面处理数据的功能大概可以分为：增删查改，头插头删，尾插尾删几个大类。我们分块实现他们

我们将函数声明放到我们的头文件，函数定义放到.c文件，test.c源文件我们用来测试我们的顺序表

简单地理解，顺序表就是按顺序存储数据，然后我们可以对数据进行一系列基本的操作，比如说增删查改等等。。。

当我们处理一系列数据时，这些数据可能会有不同的类型，当我们只用一种类型来声明一个变量时，以后遇到不同的情况会需要通篇代码大幅度地更改，所以我们可以使用typedef来重命名一种类型，这里我们以int型为例。（我们利用typedef的好处是当我们以后使用不同类型的数据时，可以直接在代码开头的typedef进行更改，这样提高了我们的效率）

typedef int SLDataType;//将int型重命名为 SLDataType
1

然后我们根据我们的需要定义一个结构体，里面的成员先设置为一个数组指针，数据的个数和我们所设置的空间的大小：

typedef struct SeqList
{
	SLDataType* a;
	int size;//空间上存储的有效数据的个数
	int capacity;//空间的大小
}SL;
1
2
3
4
5
6

顺序表就是管理数据，也就是做到一些增删查改的功能
定义一个结构体变量跟我们定义一个普通变量一样，在我们操作之前最好先对它初始化一下，我们将初始化部分封装到一个函数里.

既然我们选择了动态顺序表，那我就应该先为我们将来数据的存储以及一系列操作先动态开辟一些空间（利用malloc函数），空间的大小在我们操作一系列数据之前可以先随机开辟一点点。

SLInit(SL* ps)初始化

//初始化
void SLInit(SL* ps)
{
	assert(ps); 
	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc failed");
		exit(-1);//让程序异常退出
	}
	ps->size = 0;//开始时候我们数据存储为0，就把size初始化为0
	ps->capacity = 4;//我们先为4个数据开辟了空间，所以空间大小初始化为4
}
1
2
3
4
5
6
7
8
9
10
11
12
13

SLDestory(SL* ps)销毁数据

实现了各种功能之后我们需要及时的销毁数据，这里并不是让这些数据和他们所站用的空间彻底地毁灭，而是释放我们动态内存开辟的空间，并通过此来清空数据。

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

SLPrint(SL* ps)打印数据

我们对数据进行增删查改等操作时，将数据打印在屏幕上就可以知道我们的操作有没有成功

//将数据打印在屏幕上
void SLPrint(SL* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
1
2
3
4
5
6
7
8
9
10

SLCheckCapacity(SL* ps)扩容空间

我们在顺序表初始化时只对它开辟了一小部分空间，随着为我们使用，当需要存储的数据越来越多时，我们就需要用realloc来函数进行扩容。

在定义一个结构体变量时，我们定义了空间大小和数据个数，在判断是否需要扩容时，只需要看数据的个数与空间的大小相不相等，如果相等就证明数据已经满了，如果需要再存储，那就要扩容空间

void SLCheckCapacity(SL* ps)
{
	assert(ps);
	//满了要扩容
	if (ps->size == ps->capacity)//判断需不需要扩容
	{
		SLDataType* tmp = (SLDataType*)realloc(ps->a, ps->capacity * 2 * (sizeof(SLDataType)));
		if (tmp == NULL)
		{
			perror("realloc failed");
			exit(-1);
		}
		ps->a = tmp;//这里将指针再次指向数组的开头，也是realloc函数的功能
		ps->capacity *= 2;//根据我们扩容的空间，改变capacity的大小
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在扩容过程中，我们可能会纠结扩容扩多少的问题，这个的大小其实是可以随意指定，两个也好四个也好，只要能够包括下我们存储一次数据的大小，如果有需要还可以再次进行扩容。

以上几个函数对应了“初始化，删除，检查扩容，打印数据”几个简单的功能，接下来我们开始实现在顺序表的不同位置实现增加数据，删除数据的函数

在实现这几个函数之前，我们先来梳理一下头插头删，尾插尾删的思路，在插入某个数据时，以尾插为例，我们首先需要检查空间大小是否合适，如果空间不够就需要扩容（如途中那样）然后再把我们想插入的数据插入进去。

相比来说，头插也一样，只不过在首部位置插入数据时，我们需要先将所有的数据向后挪动，为我们即将要插入的数据腾出空间

二者的思路都是在某一个位置插入一个数据，只不过根据位置的不同需要有不同的变动，那我们可以将这一过程封装成一个插入函数，在我们头插头删时根据需要运用进去

在插入函数中，我们设置三个参数，分别是结构体指针变量，还有要传过去的位置，以及要插入的函数

在数组中，我们描述位置的最好方法就是利用下标来寻找某一个数据（pos），然后无论是头插还是尾插我们都需要检查空间大小是否合适，如果大小不够，我们还需要进行扩容操作来为我们即将插入的数据留出空间

//插入函数
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);//在使用函数进行插入数据操作时，我们首先要检查即将要插入（也就是下标）的位置是否合法
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

尾插情况：

头插情况：

当我们头插运用到插入函数时，进入循环，里面的数据就会向后挪动，为头插腾出位置。

这样，我们的头插尾插函数就可以用到我们的插入函数了

SLPushBack(SL* ps, SLDataType x)尾插

void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	SLInsert(ps, ps->size, x);
}
1
2
3
4
5

SLPushFront(SL* ps, SLDataType x)头插

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLInsert(ps, 0, x);
}
1
2
3
4
5

头插尾插函数我们定义完了，接下来是头删尾删

当我们想要删除一个数据，也就是让后面的数据往前挪动，覆盖在已经删除的数据之后

我们想要在一个位置删除一个数据，可以直接找到它的位置然后删除它，我们以头删为例，如果我们删除了首部的一个数据，这个位置空出来我们就需要让其后的数据往前挪动来覆盖它，为此我们也可以封装成一个删除数据的函数，在头删尾删中运用它

//删除数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		++begin;
	}
	ps->size--;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

尾删时，如下图：

到了头删，我们不仅要删除指定位置的数据，还要挪动后面的数据来覆盖这个位置，让顺序表接着连续起来，这样符合条件进入循环，就可以实现：

这样我们就基本实现了函数框架，可以进行传参然后运用到头删尾删里面

SLPopBack(SL* ps)尾删

//尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	SLErase(ps, ps->size - 1);
}
1
2
3
4
5
6

SLPopFront(SL* ps)头删

//头删
void SLPopFront(SL* ps)
{
	assert(ps);
	SLErase(ps, 0);
}
1
2
3
4
5
6

在我们删除一个数据时，有个问题就是需不需要利用free来释放被删除数据的那段空间

答案是：不要！删除了一个数据不能对它free，要free就整体free，释放空间不能分期，不能局部释放

顺序表的核心部分我们已经完成了，接下来就是在顺序表中查找一个数据。

我们通过一个数组的下标，可以直接锁定我们想找的数据，但是如果在繁多的顺序表中的数据我们不知道下标，但是想找到一个数呢，我们同样通过封装函数来完成，函数参数通过设置结构体指针和想要查找的数据，传参来实现查找

SLFind(SL* ps, SLDataType x) 查找

int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)//遍历顺序表，当符合我们所要查找的数据时，返回它的下标，如果找不到则返回-1
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}
1
2
3
4
5
6
7
8
9
10
11
12

这样一个完整的顺序表就完成了，我们通过一系列函数实现了它的功能。

看到这里本章就结束了伟大的程序员辛苦了