【数据结构】顺序表

---

前言

今天开始我们正式进入对数据结构的学习，让我们先从最简单的数据结构——顺序表开始吧。

---

一、引入

说及顺序表我们先引入一下线性表：

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

所以顺序表是一种线性的数据存储方式。

---

二、顺序表

1.概念和结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

根据数组的开辟方式，我们可以将顺序表分为两类：

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

2)动态顺序表：使用动态开辟的数组存储。

2.顺序表接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

例如现在有一组数据，让我们对数据进行管理，管理数据的基本的操作即：增、删、查、改。所以我们要构建以下函数接口：

typedef int SLDataType;
// 顺序表的动态存储
typedef struct SeqList
{
	SLDataType* array; // 指向动态开辟的数组
	size_t size ; // 有效数据个数
	size_t capicity ; // 容量空间的大小
}SeqList;
// 基本增删查改接口
// 顺序表初始化
void SeqListInit(SeqList* SL);
// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* SL);
// 顺序表尾插
void SeqListPushBack(SeqList* SL, SLDataType x);
// 顺序表尾删
void SeqListPopBack(SeqList* SL);
// 顺序表头插
void SeqListPushFront(SeqList* SL, SLDataType x);
// 顺序表头删
void SeqListPopFront(SeqList* SL);
// 顺序表查找
int SeqListFind(SeqList* SL, SLDataType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* SL, size_t pos, SLDataType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* SL, size_t pos);
// 顺序表销毁
void SeqListDestory(SeqList* SL);
// 顺序表打印
void SeqListPrint(SeqList* SL);

下面我带大家一一实现以上接口：

顺序表初始化：SeqListInit();

我们首先初始化了动态内存的大小，给他了四个数据大小的内存，以便于我们刚开始对数据的插入。

void SeqListInit(SeqList* SL)
{
	SL->a = (SLDateType*)malloc(sizeof(SLDateType) * 4);
	if (SL->a == NULL)
	{
		perror("malloc error");
		exit(-1);
	}
	SL->size = 0;
	SL->capacity = 4;
}

顺序表的销毁：SeqListDestory();

销毁的实现很简单，只需将我们malloc申请的空间释放掉就实现了顺序表的销毁。

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

顺序表尾插：SeqListPushBack();

在插入中我们都要对内存空间大小是否充足进行检查，如果内存不足则扩容。扩容后即在SL->size指向的数组末尾插入一个数据即可。

void SeqListPushBack(SeqList* SL, SLDateType x)
{
	//检查内存，不足将扩容
	if (SL->capacity == SL->size)
	{
		//扩容
		SLDateType* tmp = realloc(SL->a, sizeof(SLDateType) * 2 * SL->capacity);
		if (tmp == NULL)
		{
			perror("realloc error");
			exit(-1);
		}
		SL->a = tmp;
		SL->capacity *= 2;
	}
	
	//尾插
	SL->a[SL->size] = x;
	SL->size++;
}

顺序表尾删：SeqListPopBack();

尾删时我们不需对数据进行处理，不用将其值0或其它，只需将有效数据个数减一即可，之后插入时会将原先数据覆盖。在这里要注意的是SL->size不能小于0。

void SeqListPopBack(SeqList* SL)
{
	if (SL->size == 0)
		return;

	SL->size--;
}

顺序表头插：SeqListPushFront();

首先也是检查内容是否够，然后对数组内元素整体右移一个数据大小，最后在首元素插入新的数据。

void SeqListPushFront(SeqList* SL, SLDateType x)
{
	if (SL->capacity == SL->size)
	{
		SLDateType* tmp = realloc(SL->a, sizeof(SLDateType) * 2 * SL->capacity);
		if (tmp == NULL)
		{
			perror("realloc error");
			exit(-1);
		}
		SL->a = tmp;
		SL->capacity *= 2;
	}

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

	SL->size++;
}

顺序表头删：SeqListPopFront();

将数组元素整体左移一个数据大小，实现对首元素的覆盖。

void SeqListPopFront(SeqList* SL)
{
	if (SL->size == 0)
		return;

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

	SL->size--;

}

顺序表查找：SeqListFind();

采用了遍历数组的方式查找，返回下标。

int SeqListFind(SeqList* SL, SLDateType x)
{
	for (int i = 0; i < SL->size; i++)
	{
		if (SL->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

顺序表在pos位置插入x

void SeqListInsert(SeqList* SL, int pos, SLDateType x)
{
	assert(pos <= SL->size && pos >= 0);
	if (SL->capacity == SL->size)
	{
		SLDateType* tmp = realloc(SL->a, sizeof(SLDateType) * 2 * SL->capacity);
		if (tmp == NULL)
		{
			perror("realloc error");
			exit(-1);
		}
		SL->a = tmp;
		SL->capacity *= 2;
	}

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


	SL->size++;
}

顺序表在pos位置删除

void SeqListErase(SeqList* SL, int pos)
{
	assert(pos <= SL->size && pos >= 0);
	if (SL->size == 0)
		return;

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

	SL->size--;
}

总结

代码资料已经放置github，有需要的朋友可以点击前往：https://github.com/wuming12138/C_CODE