数据结构之线性表(一)——顺序表

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

顺序表的概念

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

顺序表一般分为两种：
一种是静态的顺序表，是使用定长的数组进行存储的，也就是在最开始就分配好了顺序表的空间大小；

#define N 100
typedef int SLDataType;//对顺序表的元素进行定义
struct SeqList 
{
	SLDataType arr[N];//定义空间大小为N的数组
	int size;//记录存储的元素个数
}

从上面的定义可以很明显的看出，静态顺序表的存储空间大小在一开始就给定了，在进行数据存储的过程中，会面临开大了空间浪费，开少了不够用的情况。

另一种是动态顺序表，使用动态开辟的数组来进行存储，能够在需要的时候对空间进行扩充。

typedef int SLDataType;//对顺序表的元素进行定义
struct SeqList 
{
	SLDataType* arr;//定义空间大小为N的数组
	int size;//记录存储的元素个数
	int capacity;//记录数组的容量
}

而在动态的顺序表中，最开始数组的定义是通过指针来进行定义的，在初始化的时候，通过动态内存开辟来获得空间，如果空间不够用了就可以进行动态扩容，很好的解决了静态顺序表的缺点，可能也会存在空间的浪费，但是相比于静态顺序表会完善很多。

顺序表的功能实现

通过上面的描述，顺序表通过动态开辟来实现的。

1. 顺序表的初始化

顺序表的初始化最重要的就是给数组中开辟空间，这个空间的大小取决于你最开始的需求，可小可大；其次顺序表开始的时候元素个数为0，容量是你所开辟的空间大小，可以通过传参来解决。

//顺序表的初始化
void SeqInit(SeqList* psl, int n)
{
	assert(psl);
	//对顺序表的空间进行初始化
	psl->a = (SLDataType*)malloc(sizeof(SLDataType) * n);
	if (psl->a == NULL)
	{
		printf("顺序表创建失败\n");
		exit(-1);
	}
	psl->size = 0;
	psl->capacity = n;
}

2. 线性表的置空

我们所用的线性表中的数据可能并不是一成不变的，如果我们想重置顺序表中的元素数值或者类型，就需要将顺序表置空。但是顺序表置空并不是真的把元素清除掉，只是让记录元素个数的size重新置0，然后传入新数据进行覆盖。

//如果线性表已存在，将其置为空
void ClearList(SeqList* psl)
{
	assert(psl);
	//将线性表置为空意味着里面没有任何的元素，但并不是要将其释放，初始容量也不应该改变
	psl->size = 0;
}

3. 顺序表的打印

每次插入元素之后，都会将size加一，因此在打印的时候刚好可以用size作为循环终止的条件。

//顺序表的打印
void SeqPrint(SeqList* psl)
{
	assert(psl);
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

4. 顺序表的增容

在进行插入数据的时候，无论是怎样插入，都会面临着增容的问题。增容的条件很容易想到，就是顺序表中的元素个数达到了容量的大小就需要增容。很多人会问，增容的话我们需要增加多少比较合适？因为在增容的时候计算机的内部一定是有消耗的，我们不能使增容过于频繁，所以每次增容的空间应该要适中，在增加容量的选择上，我们可以选择1.5倍或者2倍进行增容。顺序表的增容我们用realloc函数来完成。

//检查空间是否已满，如果满了就进行增容
void CheckCapacity(SeqList* psl)
{
	assert(psl);
	if (psl->size == psl->capacity)
	{
		psl->capacity *= 2;
		SLDataType* ptr = (SLDataType*)realloc(psl->a, sizeof(SLDataType) * psl->capacity);
		if (ptr == NULL)
		{
			printf("内存开辟失败\n");
			exit(-1);
		}
		else
		{
			printf("增容成功\n");
			psl->a = ptr;
		}
	}
}

5. 顺序表的尾插

顺序表的尾插最重要的是要找到尾部，我们可以看到，每次插入元素之后，size都要加一，size所对应的位置就是下一个元素要插入的位置，因此尾插的时候可以直接在size位置插入。注意：插入的时候我们需要加入检查容量的函数，以免插入的位置发生越界访问。

//顺序表的尾插
void SeqListPushBack(SeqList* psl, SLDataType x)
{
	assert(psl);
	CheckCapacity(psl);
	psl->a[psl->size] = x;
	psl->size++;
}

6. 顺序表的尾删

尾删的位置同样是在size对应的地方，但是要强调的是，尾删并不是把数据真正的删除，而是将插入的位置size减一，使下一次插入的数据覆盖掉原来的数据即可。因为顺序表是整体开辟的，不能通过free局部释放；并且顺序表本质上是连续的数组，因此并不需要进行释放，用新的元素直接替换原来的元素即可。
注意：在尾删的时候要注意当size = 0的时候说明顺序表中已经为空，如果再继续删除的话，就会越界访问。所以我在开头进行了断言，防止这类错误的发生。

// 顺序表尾删
void SeqListPopBack(SeqList* psl)
{
	assert(psl);
	assert(psl->size > 0);
	psl->size--;
}

7.顺序表的头插

顺序表头插和尾插最大的不同点在于尾插的时候，尾部的空间是没有元素的，可以直接插入。但是头插的时候，不能在原来的顺序表前面直接插入元素，如果想要插入元素的话，就必须将所有的元素全部向后移动一位，在最开头空出来一个位置来进行头插，这就导致了头插的效率比较低。同样，头插的时候要对容量进行检查。

// 顺序表头插
void SeqListPushFront(SeqList* psl, SLDataType x)
{
	assert(psl);
	CheckCapacity(psl);
	//对于头插，要对顺序表先进行移位，在进行插入
	int i = 0;
	for (i = psl->size; i > 0; i--)
	{
		psl->a[i] = psl->a[i - 1];
	}
	psl->a[0] = x;
	psl->size++;
}

8. 顺序表的头删

头删本质上也就是通过移位将第一个元素进行覆盖，然后将元素个数size减一。这里同样要注意size = 0的情况。

// 顺序表头删
void SeqListPopFront(SeqList* psl)
{
	assert(psl);
	assert(psl->size > 0);
	//顺序表的头删，先将头部的元素删除，也就是将元素移位进行覆盖
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		psl->a[i] = psl->a[i + 1];
	}
	psl->size--;
}

接下来是在任意地方插入和删除，但是在顺序表中想要在任意地方插入，就要找到对应的元素下标。

9. 顺序表的查找

顺序表的查找就是通过遍历数组，查找到想要插入的元素位置的下标进行返回，如果没有找到，就返回-1。这里返回-1是因为数组的下标不可能为-1，作为标志。

// 顺序表查找
int SeqListFind(SeqList* psl, SLDataType x)
{
	assert(psl);
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
			return i;
	}
	printf("未找到\n");
	return -1;
}

10. 顺序表的pos位置插入

想要在pos位置进行插入，前提就是在查找函数中已经找到pos，如果没有对应元素，是不能进行插入的。要在任意位置插入，必须要预留出一个位置出来，所以最关键的还是元素的移动，通过移动pos之后的元素，然后将新的数据插入禁区。pos位置的插入可以在pos之前，也可以在pos之后，唯一的差别就是多移动一个元素。

// 顺序表在pos位置插入x
void SeqListInsert(SeqList* psl, int pos, SLDataType x)
{
	assert(psl);
	CheckCapacity(psl);
	//在pos位置的后面插入
	int i = 0;
	for (i = psl->size; i > pos ; i--)
	{
		psl->a[i] = psl->a[i - 1];
	}
	psl->a[pos] = x;
	psl->size++;
	//在pos位置的前面插入
	//int i = 0;
	//for (i = psl->size; i >= pos + 1; i--)
	//{
	//	psl->a[i] = psl->a[i - 1];
	//}
	//psl->a[pos + 1] = x;
	//psl->size++;
}

11. 顺序表的pos位置删除

删除pos位置对应的值，原理和前面的大同小异，并不是真正的删除，而是把pos之前的数向前移动，覆盖掉pos位置的值。

// 顺序表删除pos位置的值
void SeqListErase(SeqList* psl, int pos)
{
	assert(psl);
	int i = 0;
	for (i = pos; i < psl->size; i++)
	{
		psl->a[i] = psl->a[i + 1];
	}
	psl->size--;
}

讲到这里，有没有发现一个问题，顺序表的尾插尾删和头插头删，都可以用pos位置的插入和删除来完成，这样就可以实现一种函数来完成插入和删除。

//顺序表的尾插
void SeqListPushBack(SeqList* psl, SLDataType x)
{
	assert(psl);
	CheckCapacity(psl);
	SeqListInsert(psl, psl->size, x);
}

// 顺序表尾删
void SeqListPopBack(SeqList* psl)
{
	assert(psl);
	assert(psl->size > 0);
	SeqListErase(psl, psl->size);
}

//但是可以看出，顺序表的尾插尾删和头插头删是可以用SeqInsert和SeqEearse函数来完成的

// 顺序表头插
void SeqListPushFront(SeqList* psl, SLDataType x)
{
	assert(psl);
	CheckCapacity(psl);
	SeqListInsert(psl, 0, x);
}

// 顺序表头删
void SeqListPopFront(SeqList* psl)
{
	assert(psl);
	assert(psl->size > 0);
	SeqListErase(psl, 0);
}

这就是顺序表的基本功能实现，但是我在写的时候还加了其他的一些功能，这里就不在赘述了，有兴趣的可以去我的码云上看，链接贴在下方，欢迎大家批评指正。

顺序表的代码实现