顺序表的实现

顺序表是线性表的一种，在物理和逻辑上都是连续的，因为用顺序表存储的数据在内存中是连续的，简单点讲就是一个数组

通常顺序表有两种结构，一种是静态的：

typedef int SDataType;

#define SIZE 10

//静态的顺序表
typedef struct SeqList
{
	SDataType a[SIZE];//定长数组
	int size;//存储有效数据的个数
}SeqList;

静态的顺序表当空间满时，需要我们手动改变数组的大小，并且我们在使用时也不清楚未来要存多少个数据，因此会存在一定的空间浪费

将静态的进行优化，可以自动检测空间，当空间满时，达到自动增容的效果，也就是第二种顺序表结构，动态的：

typedef int SDataType;

typedef struct SeqList
{
	SDataType* a;//指向一个数组
	int capacity;//容量
	int size;//有效数据的个数
}SeqList;

今天我们以动态的顺序表为例，实现一下该数据结构

要实现顺序表，首先得知道顺序表需要哪些接口

对于大部分数据结构，都离不开增删查改这四个功能，因此这四个接口是我们必须实现的

//初始化
void SeqListInit(SeqList* ps);

//销毁
void SeqListDestroy(SeqList* ps);

//打印
void SeqListPrint(SeqList* ps);

//头插
void SeqListPushFront(SeqList* ps, SDataType x);

//尾插
void SeqListPushBack(SeqList* ps, SDataType x);

//头删
void SeqListPopFront(SeqList* ps);

//尾删
void SeqListPopBack(SeqList* ps);

//查找
int SeqListFind(SeqList* ps, SDataType x);

//在pos位置插入
void SeqListInsert(SeqList* ps, int pos, SDataType x);

//在pos位置删除
void SeqListErase(SeqList* ps, int pos);

上面的就是我们要大致实现的接口

首先是初始化：

给顺序表结构中的元素赋个初始值

//初始化
void SeqListInit(SeqList* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

尾插：

每次插入数据之前，需要判断空间是否满了， 如果满了，需要进行增容

由于后面的头插也需要判断是否需要增容，我们不妨将判断增容单独写成一个函数，下次直接调用该函数即可

• 在增容函数中，如果元素个数等于容量大小，就需要增容，否则不需要。插入第一个数据时，可以先给容量赋一个初始值，之后满了再进行两倍扩容。为什么选择两倍扩容？其实几倍扩容问题都不是很大，选择相对减少空间浪费的即可
• 在尾插函数中，调用增容函数，在数组中size下标位置插入数据，最后别忘了++size

//检查是否需要增容
void CheckCapacity(SeqList* ps)
{
	assert(ps);

	if (ps->capacity == ps->size)
	{
		int newCapacity = ps->capacity * 2;
		ps->capacity = (ps->capacity == 0 ? 4 : newCapacity);
		SDataType* tmp = (SDataType*)malloc(sizeof(SDataType) * ps->capacity);
		if (tmp == NULL)
		{
			perror("CheckCapacity:malloc fail");
			exit(-1);
		}
		ps->a = tmp;
	}
}

//尾插
void SeqListPushBack(SeqList* ps, SDataType x)
{
	assert(ps);

	CheckCapacity(ps);

	ps->a[ps->size] = x;
	ps->size++;
}

写代码时，我们最好是写完一个模块就测试一个模块，保证当前写的代码基本无误

如果是把所有代码一次性写完，出了错误，是很不方便去调试的

因此我们先测试一下尾插的函数

打印函数：遍历数组

//打印
void SeqListPrint(SeqList* ps)
{
	assert(ps);

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

测试代码：

void TestSeqList()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s);
}

int main()
{
	TestSeqList();

	return 0;
}

插入4个数据时，结果没有问题，但我们还需要测试增容后的结果，再插入一个数据

void TestSeqList()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPrint(&s);
}

int main()
{
	TestSeqList();

	return 0;
}

我们发现，此时代码出现了bug

经过调试，我们发现，是malloc函数的问题

可以查看ps->a的地址来进一步验证

 

使用realloc函数就可以修复这个bug

void* realloc (void* ptr, size_t size);

改变ptr指向空间的大小为size个字节

如果ptr是空指针，则realloc函数就是一个malloc函数，会开辟一块size字节的空间，返回该空间的地址

如果ptr指向的空间加上ptr后面的的空间不够容纳size个字节，则会另外开辟一块size字节的空间，并将原数据拷贝到新的空间，自动释放掉原空间

因此，正确的增容函数就是：

//检查是否需要增容
void CheckCapacity(SeqList* ps)
{
	assert(ps);

	if (ps->capacity == ps->size)
	{
		int newCapacity = ps->capacity * 2;
		ps->capacity = (ps->capacity == 0 ? 4 : newCapacity);
		SDataType* tmp = (SDataType*)realloc(ps->a, sizeof(SDataType) * ps->capacity);
		if (tmp == NULL)
		{
			perror("CheckCapacity:malloc fail");
			exit(-1);
		}
		ps->a = tmp;
	}
}

 

 头插：

插入数据前调用增容函数，头插时，需要我们将数据往后挪

注意：一定要从后往前挪，如果从前往后挪，前面的数据会覆盖后面的数据

代码实现：

//头插
void SeqListPushFront(SeqList* ps, SDataType x)
{
	assert(ps);

	CheckCapacity(ps);

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

	ps->a[0] = x;
	ps->size++;
}

测试代码：

void TestSeqList()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPrint(&s);

	SeqListPushFront(&s, 10);
	SeqListPushFront(&s, 20);
	SeqListPrint(&s);
}

头删：

同样需要挪动数据，这次需要从前往后挪

当没有数据时，就不能进行删除操作了，因此要加上一个断言，当没有数据时，再进行删除操作就会报错

代码实现：

//头删
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);

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

	ps->size--;
}

尾删：

尾删就比较简单了，只需要size--即可

//尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);

	ps->size--;
}

查找：

遍历数组，如果找到了，就返回下标，如果找不到，就返回-1

这里我们不考虑如果有两个数据相等，该返回哪一个数据的下标这种情况，假设所有的数据都不相等

//查找
int SeqListFind(SeqList* ps, SDataType x)
{
	assert(ps);

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

	return -1;
}

pos位置插入：

同头插，尾插原理相似，唯一需要注意的是，pos要在0~size之间，加上断言即可

//在pos位置插入
void SeqListInsert(SeqList* ps, int pos, SDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);

	CheckCapacity(ps);

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

	ps->a[pos] = x;
	ps->size++;
}

另外，需要知道当pos为0时，相当于头插，pos为size时相当于尾插，因此前面的头插尾插可以用pos位置插入函数替代

//头插
void SeqListPushFront(SeqList* ps, SDataType x)
{
	SeqListInsert(ps, 0, x);
}

//尾插
void SeqListPushBack(SeqList* ps, SDataType x)
{
	SeqListInsert(ps, ps->size, x);
}

pos位置删除：

删除时，pos要大于0且小于size-1，即最后一个元素的下标

//在pos位置删除
void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(ps->size > 0);
	assert(pos >= 0 && pos <= ps->size - 1);

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

	ps->size--;
}

此时，pos为0相当于头删，pos为size-1，相当于尾删

前面的头删尾删函数也可以被替换

//头删
void SeqListPopFront(SeqList* ps)
{
	SeqListErase(ps, 0);
}

//尾删
void SeqListPopBack(SeqList* ps)
{
	SeqListErase(ps, ps->size - 1);
}

最后别忘了动态开辟的内存要销毁

//销毁
void SeqListDestroy(SeqList* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

最后的最后，我们来分析一下顺序表的好坏

• 我们发现，尾插，尾删数据都蛮方便的，但在其他位置插入，删除数据相对而言就比较麻烦了，需要挪动数据
• 其次，我们每次都是两倍增容，而实际上我们并不知道要存储多少数据，在一定程度上会造成空间浪费

有没有这样一种数据结构，在任意位置插入删除数据都比较方便，且能够按需开辟空间，这就是我们下次要讲的链表

如果大家需要顺序表的完整代码，可以进入我的Gitee自行获取，顺便点个赞！

SeqList/SeqList · baiyahua/LeetCode - 码云 - 开源中国 (gitee.com)