比特航哥系列：数据结构大揭秘：从零开始，掌握常见数据结构的原理与应用《顺序表》

1线性表

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

2顺序表

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

2.1静态顺序表：

使用定长数组存储元素。

2.2动态顺序表：

使用动态开辟的数组存储。

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

typedef int SLDataType;
// 顺序表的动态存储
typedef struct SeqList
{
	SLDataType* array; // 指向动态开辟的数组
	size_t size ; // 有效数据个数
	size_t capicity ; // 容量空间的大小
}SeqList;
// 基本增删查改接口
// 顺序表初始化
void SeqListInit(SeqList* psl){
	s->array = new SLDatatype(4);
	if (s->array == nullptr) {
		cout << "开辟空间失败！" << endl;
		exit(-1);
	}
	s->size = 0;
	s->capicity = 4;
}
// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* psl){
//增容
	if (s->size <= s->capicity) {
		s->capicity *= 2;
		s->array = (SLDatatype*)realloc(s->array, sizeof(SLDatatype) * s->capicity);
		if (s->array == nullptr) {
			cout << "增容失败！" << endl;
			exit(-1);
		}
	}
}
// 顺序表尾插
void SeqListPushBack(SeqList* psl, SLDataType x){
	assert(s);
	SeqListCheckcapacity(s);
	s->array[s->size] = x;
	s->size++;
}
// 顺序表尾删
void SeqListPopBack(SeqList* psl){
	assert(s);
	s->size--;
}
// 顺序表头插
void SeqListPushFront(SeqList* psl, SLDataType x){
	int end = s->size - 1;
	while (end>=0) {
		s->array[end+1] = s->array[end];
		--end;
	}
	
	s->array[0] = x;
	s->size++;
}
// 顺序表头删
void SeqListPopFront(SeqList* psl){
	for (int i = 0; i < s->size - 1; i++) {
		s->array[i] = s->array[i + 1];
	}
	s->size--;
}
// 顺序表查找
int SeqListFind(SeqList* psl, SLDataType x){
	int i = 0;
	while (i < s->size) {
		if (s->array[i] == x) {
			cout << i << endl;
			return i;
		}
		i++;
	}
	return -1;
}
// 顺序表在pos位置插入x
void SeqListInsert(Seqlist* s, int pos, int x) {
	assert(s);
	assert(pos >= 0 && pos <= s->size-1);
	SeqListCheckcapacity(s);
	int end = s->size - 1;
	while (end>=pos)
	{
		s->array[end + 1] = s->array[end];
		end--;
	}
	s->array[pos] = x;
	s->size++;
}
// 顺序表删除pos位置的值
void SeqListErase(Seqlist* s, int pos) {
	assert(s);
	assert(pos >= 0 && pos <= s->size - 1);
	int start = pos;
	while (start<s->size)
	{
		s->array[start] = s->array[start + 1];
		start++;
	}
	s->size--;

}
// 顺序表销毁
void SeqListDestory(Seqlist* s) {
	delete(s);
	s->array = nullptr;
	s->size = s->capicity = 0;
}
// 顺序表打印
void SeqListPrint(Seqlist* s) {
	assert(s);
	for (size_t i = 0; i < s->size; i++) {
		cout << s->array[i] << ' ';
	}
	cout << endl;
}

2.3顺序表的问题及思考

问题：
1. 中间/头部的插入删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到
200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
思考：如何解决以上问题呢？