图解顺序表:全面解析顺序表工作原理及C语言实现

---

思维导图

---

顺序表的概念

顺序表是一种线性表的数据存储结构，要求数据依次存储在一块连续的物理空间中。

顺序表的物理空间结构如下：

顺序表的分类

根据存储空间的申请方式，可以分静态顺序表和动态顺序表两类。

静态顺序表

静态顺序表是一次性地申请一块固定大小的栈内存空间。这种方式可能会出现两种情况：

• 情况1：内存空间申请过小，不能存放所有的数据。
• 情况2：内存空间申请过大，导致部分空间闲置。

下面是静态顺序表的实现过程：

//静态顺序表结构体类型声明
#define N 7
typedef int SLDataType;

typedef struct SeqList
{
	SLDataType array[N]; //存储空间
	int size; //实际数据量
}SeqList;


#include <stdio.h>

int main()
{
	SeqList SList;
	SList.size = 0;
    
    //静态顺序表存入数据
	for (int i = 0; i < N; i++)
	{
		SList.array[i] = i;
		printf("%d ", SList.array[i]);
		SList.size += 1;
	}

	printf("\n%d\n", SList.size);

	return 0;
}

• 在上述代码中，由于在向静态顺序表存放数据时，还需要记录静态顺序表中实际存放的数据个数。
• 所以声明一个包含整形数组和整形变量的结构体类型，用于定义结构体变量，同时保存静态顺序表和实际数据量的信息。这样就只需要用一个结构体变量来维护静态顺序表。
• 静态顺序表事先申请了定长数组用于保存数据，每存入一个数据，实际数据量的变量size就加1。

动态顺序表

为了避免内存空间浪费和不足的问题，我们可以根据实际数据量动态从堆空间上申请空间。

动态顺序表在堆空间上申请空间的好处是，即使插入函数调用结束后，动态顺序表依然存在。

动态顺序表的基本操作

动态顺序表的操作包括初始化、输出、增删查改和销毁操作。

初始化

在对顺序表进行初始化之前，需要进行以下的操作：

声明一个结构体类型，包含如下成员：

• 一个指向顺序表的指针。用于记录顺序表的起始位置。
• 记录顺序表中存放的实际数据量。便于使用顺序表，因为顺序表本质上是一个数组，清楚数据个数就知道数据对应的下标，可以通过下标访问到对应的数据。
• 记录顺序表的容量。用于实时比对容量和实际数据量的大小，判断是否需要重新申请新的空间存放超出容量的数据。

具体的实现代码如下：

//创建一个结构体类型
#define N 4 //代表初次申请的数据个数
typedef int SLDataType;
typedef struct Seqlist
{
	SLDataType* a; //存储空间
	int size; //实际数据量
	int capacity; //容量
}SL;

其中a是指向未初始化的动态数组的指针，应当理解为整个动态数组。

下面是顺序表的初始化：

• 申请一定大小的存储空间。
• 给实际数据量size和容量capacity赋值。

//创建一个结构体变量
SL s;

//顺序表初始化
void SLInit(SL* s)
{
	assert(s); //因为s为结构体变量，地址不可能为空

	s->a = (SLDataType*)malloc(sizeof(SLDataType) * N); //动态申请内存空间，构造一个空顺序表
    if(!s->a)
    {
        perror("malloc failed");
	}
    
	s->capacity = N; //初始容量为N
	s->size = 0; //初始数量为空
}

• 将顺序表初始化的过程封装为一个函数SLInit，便于代码复用。
• 通过传入结构体变量s的地址，函数SLInit能够修改外部的s。
• 同时对空间申请进行判断，如果申请失败，输出错误信息。

输出元素

由于顺序表是一个数组结构，因此可以很方便地使用循环遍历输出顺序表的元素。

具体的实现代码如下：

//顺序表输出
void SLPrint(SL* s)
{
	assert(s);

	for (int i = 0; i < s->size; i++)
	{
		printf("%d ", s->a[i]);
	}

	printf("\n");
}

插入元素

向构造的顺序表中插入数据元素，根据插入的位置可分为三种情况：

• 头部插入：在顺序表的首元素前插入

• 中间插入：在顺序表的中间位置插入

• 尾部插入：在属性表的尾元素后插入

三种插入都使用同一种插入方法：

• 找到插入的元素位置，
• 将插入位置的元素以及后续的元素，从尾元素开始，整体往后移动一个位置。

插入过程如下：

头插和中间插入的时间复杂度最坏是O(N)，N是顺序表的数据元素个数；尾插是O(1)。

扩容操作：

• 插入数据之前都需要对顺序表的容量进行检查，当实际数据量size等于容量capacity时（因为一次插入一个数据，不会跳过capacity），需要扩容。
• 容量扩为原来的2倍。
• 更新容量capacity为原来的2倍。

扩容操作的具体实现如下：

//顺序表容量检查
void SLCheckCapacity(SL* s)
{
	assert(s);

	//增容
	if (s->capacity == s->size)
	{
		s->a = (SLDataType*)realloc(s->a, sizeof(SLDataType) * s->capacity * 2);
		s->capacity = s->capacity * 2;
	}
}

使用realloc函数重新申请空间。

头插：

• 头插需要提供顺序表和要插入的数据。
• 插入数据之前，检查容量。
• 移动数据，避免覆盖。
  • 创建一个下标变量，用于迭代元素，避免改变size。
  • 从尾元素开始，将前一个元素赋给后一个元素。
• 在下标0的位置插入元素，数据量size加1。

具体的实现代码如下：

void SLPushFront(SL* s, SLDataType num)
{
	assert(s);

	//检查容量
	SLCheckCapacity(s);

	//向后移动数据,本质是把前一个数据赋给后一个数据
    for(int i = s->size-1; i >= 0; i--) //从尾元素开始，到首元素结束
    {
        s->a[i+1] = s->a[i];
	}

	s->a[0] = num;
	s->size++;
}

中间插入

• 中间插入需要提供顺序表、插入的位置和要插入的数据。
• 插入数据之前，检查容量。
• 移动数据，避免覆盖。
  • 创建一个下标变量，用于迭代元素，避免改变size。
  • 从尾元素开始，将前一个元素赋给后一个元素，直到下标pos位置的元素完成拷贝。
• 在下标pos位置插入元素，数据量加1。

具体的实现代码如下：

//顺序表任意位置pos插入
void SLPosInsert(SL* s, int pos, SLDataType num) 
{
	assert(s);

	//检查容量
	SLCheckCapacity(s);

	//循环后移
    for(int i = s->size-1; i >= pos; i--) //从尾元素开始，到pos元素结束
    {
        s->a[i+1] = s->a[i];
	}

	s->a[pos] = num;
	s->size++;
}

尾插：

• 尾插需要提供顺序表和要插入的数据。
• 插入数据之前，检查容量。
• 直接在下标size位置插入元素，数据量加1，不需要移动元素。

具体的实现代码如下：

//顺序表尾插
void SLPushBack(SL* s, SLDataType num)
{
	//检查容量
	SLCheckCapacity(s); //如果满容了，就会扩容

	s->a[s->size] = num;
	s->size++;
}

删除元素

向构造的顺序表中删除数据元素，根据删除的位置可分为三种情况：

• 头部删除：删除顺序表的首元素

• 中间删除：删除顺序表的中间位置元素

• 尾部删除：删除顺序表的尾元素

三种删除都使用同一种删除方法：

• 找到删除的元素位置
• 从删除位置的下一个元素开始，整体往前移动一个位置

头删和中间删除的时间复杂度最坏是O(N)，N是顺序表的数据元素个数；尾删是O(1)。

删除过程如下图所示：

头部删除：

• 头删需要提供顺序表
• 从下标为1的位置开始，将后面的数据往前移动一个位置
• 不处理下标为size-1位置的数据，只需将size减1
• 注意：在删除数据之前，需要检查size是否大于0。若size为0，表示顺序表为空，不能再删除数据

具体的实现代码如下：

//顺序表头删
void SLPopFront(SL* s)
{
	assert(s);
	assert(s->size > 0);

	for (int i = 1; i < s->size; i++)
	{
		s->a[i-1] = s->a[i];
	}

	s->size--;
}

中间删除：

• 中间删除需要提供顺序表和要删除的元素位置pos。
• 从下标为pos+1位置开始，将后面的数据往前移动一个位置
• 不处理下标为size-1位置的数据，只需将size减1
• 注意：在删除数据之前，需要检查size是否大于0。若size为0，表示顺序表为空，不能再删除数据

具体的实现代码如下：

//顺序表任意位置pos删除
void SLPosErase(SL* s, int pos)
{
	assert(s);
	assert(s->size > 0);

	for (int i = pos + 1; i < s->size; i++)
	{
		s->a[i - 1] = s->a[i];
	}

	s->size--;
}

尾部删除：

• 尾删需要提供顺序表。
• 不处理下标为size-1位置的数据，只需将size减1
• 注意：在删除数据之前，需要检查size是否大于0。若size为0，表示顺序表为空，不能再删除数据

具体的实现代码如下：

//顺序表尾删
void SLPopBack(SL* s)
{
	assert(s);
	assert(s->size > 0); //最后一个数据，删完才等于0

	s->size--;
}

查找元素

顺序表不一定有序，因此，使用顺序查找元素法寻找目标数据元素的下标位置。

• 查找元素需要提供顺序表和要查找的数据。
• 使用循环遍历顺序表，如果找到了目标数据元素返回对应的下标位置，找不到则返回-1。

具体的实现代码如下：

//顺序表查找
int SLFind(SL* s, SLDataType num)
{
	assert(s);

	for (int i = 0; i < s->size; i++)
	{
		if (num == s->a[i])
		{
			return i;
		}
	}

	return -1;
}

更改元素

要修改顺序表中的某个元素，首先需要找到这个元素的下标，然后修改下标处的数据。

具体的实现代码如下：

//顺序表更改
int SLFind(SL* s, SLDataType num)
{
	assert(s);

	for (int i = 0; i < s->size; i++)
	{
		if (num == s->a[i])
		{
            s->a[i] = 30; //更改元素
			return i;
		}
	}

	return -1;
}

顺序表销毁

由于顺序表是在堆空间上申请的内存空间，所以在不使用顺序表时需要手动释放内存，以防止内存泄漏。

• 提供顺序表
• 释放掉数组a的内存空间、并将size、capicity置为0

具体的实现代码如下：

void SLDestroy(SL* s)
{
	free(s->a);
	s->a = NULL;

	s->size = 0;
	s->capacity = 0;
}