数据结构基础入门之【顺序表】详解，2024年最新深度解析，2024年最新值得收藏

机器学习之心AI
26 阅读9分钟

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

  1. 定义一个结构体，该结构体包含一个可以存放数据的数组和记录数组中有效数字的变量。

  2. 初始化结构体。

  3. 打印结构体。

  4. 头插。

  5. 尾插。

  6. 头删。

  7. 尾删。

  8. 任意位置插入。

  9. 任意位置删除。

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

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

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

  代码如下：

#define MAX_SIZE 10
typedef int SQDataType;
typedef struct SeqList
{
	SQDataType a[MAX_SIZE];
	int size;
}SL;
//typedef struct SeqList SL;

typedef struct SeqList SL;
//初始化结构体
void SeqListInit(SL* ps);
//打印
void SeqListPrint(SL s);
//尾插
void SeqListPushBack(SL* ps, SQDataType x);
//尾删
void SeqListPopBack(SL* ps);
//头插
void SeqListPushFrint(SL* ps, SQDataType x);
//头删
void SeqListPopFrint(SL* ps);
//查找位置
int SeqListFind(SL s, SQDataType x);
//任意插入
void SeqListInsert(SL* ps, int pos, SQDataType x);
//任意删
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进行结构体类型简化，方便我们以后编辑代码。我们来看一下代码的实现：

typedef int SQDataType;
struct SeqList
{
	SQDataType* a;
	int size;
	int capacity;
};
typedef struct SeqList SL;

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

2、3 初始化结构体

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

void SeqListInit(SL* ps)
{
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

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

2、4 结构体打印

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

void SeqListPrint(SL s)
{
	int i = 0;
	for (i = 0; i < s.size; i++)
	{
		printf("%d ", s.a[i]);
	}
	printf("\n");
}

2、5 检查数组容量

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

void SQLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SQDataType* tmp =(SQDataType*)realloc(ps->a, sizeof(SQDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc failed\n");
			exit(-1);
		}
		ps->capacity = newcapacity;
		ps->a = tmp;
	}
	
}

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

2、6 头插

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

void SeqListPushFrint(SL* ps, SQDataType x)
{
	SQLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end+1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

2、7 尾插

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

void SeqListPushBack(SL* ps, SQDataType x)
{
	SQLCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}

2、8 头删

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

void SeqListPopFrint(SL* ps)
{
	assert(ps->size > 0);
	int i = 0;
	for (i = 0; i < ps->size - 1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}

2、9 尾删

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

void SeqListPopBack(SL* ps)
{
	assert(ps->size > 0);
	ps->size--;
}

2、10 任意删除

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

//查找位置
int SeqListFind(SL s, SQDataType x)
{
	int i = 0;
	for (i = 0; i < s.size; i++)
	{
		if (s.a[i] == x)
		{
			return i;
		}
	}
	return -1;
}
void SeqListErase(SL* ps, int pos)
{
	assert(pos >= 0 && pos < ps->size);
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}

2、11 任意插入

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

void SeqListInsert(SL* ps, int pos, SQDataType x)
{
	assert(pos >= 0 && pos <= ps->size);
	SQLCheckCapacity(ps);
	int end = ps->size-1;
	while (end >= pos)
	{
		ps->a[end+1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

2、12 空间释放

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

void SeqListDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

 三、顺序表代码整合

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

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

SeqList.h

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SQDataType;
struct SeqList
{
	SQDataType* a;
	int size;
	int capacity;
};

typedef struct SeqList SL;
//初始化结构体
void SeqListInit(SL* ps);
//打印
void SeqListPrint(SL s);
//尾插
void SeqListPushBack(SL* ps, SQDataType x);
//尾删
void SeqListPopBack(SL* ps);
//头插
void SeqListPushFrint(SL* ps, SQDataType x);
//头删
void SeqListPopFrint(SL* ps);
//查找位置
int SeqListFind(SL s, SQDataType x);
//任意插入
void SeqListInsert(SL* ps, int pos, SQDataType x);
//任意删
void SeqListErase(SL* ps, int pos);
//销毁空间
void SeqListDestory(SL* ps);

SeqList.c

#include"SeqList.h"

//初始化结构体
void SeqListInit(SL* ps)
{
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}
//打印
void SeqListPrint(SL s)
{
	int i = 0;
	for (i = 0; i < s.size; i++)
	{
		printf("%d ", s.a[i]);
	}
	printf("\n");
}
//查容增容
void SQLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SQDataType* tmp =(SQDataType*)realloc(ps->a, sizeof(SQDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc failed\n");
			exit(-1);
		}
		ps->capacity = newcapacity;
		ps->a = tmp;
	}
	
}
//尾插
void SeqListPushBack(SL* ps, SQDataType x)
{
	SQLCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}
//尾删
void SeqListPopBack(SL* ps)
{
	assert(ps->size > 0);
	ps->size--;
}
//头插
void SeqListPushFrint(SL* ps, SQDataType x)
{
	SQLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end+1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}
//头删
void SeqListPopFrint(SL* ps)
{
	assert(ps->size > 0);
	int i = 0;
	for (i = 0; i < ps->size - 1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}
//查找位置
int SeqListFind(SL s, SQDataType x)
{
	int i = 0;
	for (i = 0; i < s.size; i++)
	{
		if (s.a[i] == x)
		{
			return i;
		}
	}
	return -1;


![img](https://p6-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/cbbfd09b3fb845b1900c903881b835e8~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAg5py65Zmo5a2m5Lmg5LmL5b-DQUk=:q75.awebp?rk3s=f64ab15b&x-expires=1772462236&x-signature=BEMtEZrspXSXALncSHQ57wrb2JA%3D)
![img](https://p6-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/29adad013d834598be5394cdac5f00c2~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAg5py65Zmo5a2m5Lmg5LmL5b-DQUk=:q75.awebp?rk3s=f64ab15b&x-expires=1772462236&x-signature=ilB7Mas%2FAMzNkosOEZEDADVsrZ0%3D)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://gitee.com/vip204888)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
avatar
文章
阅读
粉丝