数据结构—顺序表

线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

顺序表

概念及结构

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

注：顺序表要求是一段连续的物理空间（其实是数组），但要求存储的数据是依次连续存储的

顺序表一般可以分为：

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

注：静态顺序表的缺点是固定大小的顺序表给小了不够用，给大了可能浪费空间

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

注：动态顺序表可以动态的适应程序员需求的大小

顺序表相关接口实现

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

顺序表的定义

typedef int SQDataType;//便于存储其他类型

typedef struct SeqList 
{
	SQDataType* a;   //指向存储数据空间的指针（指向动态开辟的数组）
	int size;        //顺序表中有效数据的个数
	int capacity;    //顺序表容量空间大小
}SLT;  //便于使用顺序表类型

注意以下代码不要这样写，这样会使代码理解变高，可读性变差

typedef int SQDataType;//便于存储其他类型

typedef struct SeqList
{
	SQDataType* a;   //指向存储数据空间的指针（指向动态开辟的数组）
	int size;        //顺序表中有效数据的个数（作为数组下标是最后一个数据的下一个位置）
	int capacity;    //顺序表容量空间大小
}SLT, * PSLT;  //便于使用顺序表类型

可以这样写 typedef struct SeqList* PSLT

顺序表的初始化

顺序表初始化时需要传址初始化，传值初始化不会改变实参。当函数参数为指针时需要注意为了避免指针使用时发生错误（传递过来的地址为NULL），需要对指针进行断言（可以快速地定位问题）

void SeqListInit(SLT* psl)
{
	assert(psl);

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

顺序表的销毁

void SeqListDestory(SLT* psl)
{
	assert(psl);

	if (psl->a)
	{
		free(psl->a);//对动态开辟的数组进行释放
		psl->a = NULL; //释放完空间需要对指针进行置空，避免野指针问题
	}

	psl->size = psl->capacity = 0;  //有效数据个数和容量空间的大小置空

}

顺序表的尾插

如果顺序表的空间足够可以直接将要插入的数据放到数组下标为size的位置上去，同时size++，capacity不需要修改这样就完成尾插了。在此之前需要检查容量是否满了，满了这时需要增容（增容的时候数据是不变的）。注意当第一次插入时size和capacity都是0，按照上述的增容方式增容的话是无效的，那么就需要在增容中进行判断如果容量是0，那么对容量赋初值；否则进行二倍增容。

注：

• 增容一般是需要付出代价的就算是往后扩容，系统里面也需要往后检查，其次如果空间不够会重新开一块新空间拷贝数据到新空间释放旧空间（代价很大）
• 一般情况为了避免频繁插入数据增容，当空间满了以后一般一次增容二倍（折中选择）像官方的库里面一般也是增二倍。
• realloc当所需要增容的空间的指针为NULL、需要空间的大小为0时realloc函数也会开辟出一块空间（当指向原空间的指针为NULL，realloc函数的行为和malloc函数一样），上述的这种行为最好不要用。
• free报错一般是内存越界了（如果动态申请的内存发生越界访问行为时，检查不出来，free的时候才会去检查或者realloc释放旧空间时有越界也会检查）。这时需要细致观察用内存的地方和申请内存的地方（越界有两种可能性一种是越界了，另一种是内存开小了）

void SeqListCheckCapcity(SLT* psl)
{
	assert(psl);

	// 是否满了，满了就要增容
	if (psl->size == psl->capacity)
	{
		size_t newcapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;
		psl->a = (SQDataType*)realloc(psl->a, newcapacity*sizeof(SQDataType));
		psl->capacity = newcapacity;
	}
}


// 尾插
//版本一：
//void SeqListPushBack(SLT* psl, SQDataType x)
//{
//	assert(psl);
//
//	SeqListCheckCapcity(psl);
//
//	psl->a[psl->size] = x;
//	psl->size++;
//
//}

//版本二：
void SeqListPushBack(SLT* psl, SQDataType x)
{
	SeqListInsert(psl, psl->size, x);
}

注：顺序表尾插的时间复杂度为O(1)

顺序表的打印

void SeqListPrint(SLT* psl)
{
	assert(psl);
	for (int i = 0; i < psl->size; ++i)
	{
		printf("%d ", psl->a[i]);  //打印数组的值
	}
	printf("\n");
}

顺序表的头插

顺序表的头插数据时需要从后往前挪动数据（如果是从前往后挪动数据会导致所有的数据都会改成第一个元素的值），再将要插入的数据放到数组中的第一个位置上去并将size++。需要注意进行头插时顺序表的空间是否已满，如果满了需要进行增容。

//版本一：

//void SeqListPushFront(SLT* psl, SQDataType x)
//{
	//assert(psl);

	//SeqListCheckCapcity(psl);

	 挪动数据
	//int end = psl->size - 1;
	//while (end >= 0)
	//{
	//	psl->a[end + 1] = psl->a[end];
	//	--end;
	//}

	//psl->a[0] = x;
	//psl->size++;

//}

//版本二：
void SeqListPushFront(SLT* psl, SQDataType x)
{
	SeqListInsert(psl, 0, x);
}

注：顺序表头插的时间复杂度为O(N)

顺序表的尾删

顺序表的尾删不存在空间不够的问题，直接进行size–（size是标识有效数据的）即可。注意在删除之前需要判断是否有数据，如果有数据进行尾删，否则尾删就会出问题（size就会变为-1），这里需要进行断言。这里使用断言进行判断可以很好

//版本一：

//void SeqListPopBack(SLT* psl)
//{
//	assert(psl);
//	assert(psl->size > 0);  //要尾删之前要先确认有没有数据如果没有数据尾删就会报错（断言会终止程序）。但是没报错时尾删一定是成功的。在STL中也会采用类似这样的一种方式处理，C++官方库里面也是这样做的。
	
	//psl->a[psl->size - 1] = 0;
	//写这句代码是不好的这要是因为顺序表所存储的数据不一定是整型有可能是其他类型（结构体类型）因此这样赋值就有问题了，还有就是赋的值可能跟插入的值一样这时就没有任何意义
	
	//psl->size--;
//}

//版本二：

//void SeqListPopBack(SLT* psl)
//{
//	assert(psl);
	
	//if (psl->size > 0)   //如果没有数据进行尾删也不会出现问题，但是缺点是不知道有没有数据、到底删除成功还是失败
	//{
	//	psl->size--;  
	//}
//}

//版本三：

void SeqListPopBack(SLT* psl)
{
	assert(psl);
	assert(psl->size > 0);
	SeqListErase(psl, psl->size - 1);//调用SeqListErase之前需要对size进行判断，否则会出现问题（位置可能就对不上）
}

注：顺序表尾删的时间复杂度为O(1)

顺序表的头删

顺序表的头删需要从前往后挪动数据（从后往前挪动数据会导致数据被覆盖），再将size–即可。注意在删除之前需要判断是否有数据，如果有数据进行头删，否则头删就会出问题（size就会变为-1），这里需要进行断言。

//版本一：

//void SeqListPopFront(SLT* psl)
//{
//	assert(psl);
//	assert(psl->size > 0);
//
//	int begin = 1;
//	while (begin < psl->size)
//	{
//		psl->a[begin - 1] = psl->a[begin];
//		++begin;
//	}
//
//	psl->size--;
//}

//版本二：

//void SeqListPopFront(SLT* psl)
//{
//	assert(psl);
//
//	int begin = 1;
//	while (begin < psl->size)
//	{
//		psl->a[begin - 1] = psl->a[begin];
//		++begin;
//	}
//
//	if (psl->size > 0)
//	{
//		psl->size--;
//	}
//
//	
//}

//版本三：

void SeqListPopFront(SLT* psl)
{
	assert(psl);
	assert(psl->size > 0);

	SeqListErase(psl, 0);
}

注：顺序表头删的时间复杂度为O(N)

顺序表的查找

顺序表查找某个值是否存在，如果找到了返回该位置的下标，否则返回-1

int SeqListFind(SLT* psl, SQDataType x)
{
	assert(psl);
	for (int i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			return i;
		}
	}

	return -1;
}

注：前置要比后置更高效，在早期CPU（运算单元、存储器）都还不够快，存储器不够大，此时这个理论是可以接受的。但现在CPU（处理器）变得很快（摩尔定律），用前置和后置的效率都差不多。

顺序表的插入

顺序表的插入要求插入完数据之后要求存储的数据是连续的。在插入数据之前需要检查容量是否满了，如果满了增容。插入数据的过程是将pos位置上的数据到最后的数据依次从后往前挪动，最后再将要插入的数据放到pos位置上，size++即可。

注：

• 先挪数据再增容会导致size是不变的只会把一部分数据拷贝下来到新空间，而其中部分数据是没有拷贝下来的。

//版本一：

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

//版本二：

//void SeqListInsert(SLT* psl, size_t pos, SQDataType x)
//{
//	assert(psl);
//	assert(pos <= psl->size && pos >= 0);
//	SeqListCheckCapcity(psl);
//
//	int end = psl->size - 1;
//	while (end >= (int)pos)  //防止发生算术转换
//	{
//		psl->a[end + 1] = psl->a[end];  //越界不一定会报错，可能到后才会报错
//		--end;
//	}
//
//	psl->a[pos] = x;
//	psl->size++;
//}

//版本三
void SeqListInsert(SLT* psl, size_t pos, SQDataType x)
{
	assert(psl);
	assert(pos <= psl->size && pos >= 0);
	SeqListCheckCapcity(psl);

	size_t end = psl->size;
	while (end > pos) //当end是整型时，只有当pos=0或者size=0时才会出现问题,会导致end最后会走到-1，提升就出现问题了
	//解决方案：第一种是这进行强转。第二种是避免出现pos=0或者size=0的情况（避免end=-1）
	{
		psl->a[end] = psl->a[end-1];
		--end;
	}

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

注：

• 提升并不会改变一个值，它是提升出一个临时变量不会改变原来的值。强转也是一样的。强转和提升不会改变变量本身
• 顺序表的插入要避免负数给到无符号，或者避免有符号数变成负数以后，被提升或者强转成有符号。

顺序表的删除

顺序表的删除需要从要删除数据的下一个位置开始从前往后依次挪动覆盖数据，最后将size–即可

//版本一：

void SeqListErase(SLT* psl, size_t pos)
{
	assert(psl);
	assert(pos < psl->size);

	size_t begin = pos + 1;
	while (begin < psl->size)
	{
		psl->a[begin - 1] = psl->a[begin];
		++begin;
	}

	psl->size--;
}

//版本二：

//void SeqListErase(SLT* psl, size_t pos)
//{
//	assert(psl);
//	assert(pos < psl->size);
//
//	size_t begin = pos;
//	while (begin < psl->size-1)
//	{
//	psl->a[begin] = psl->a[begin+1];
//	++begin;
//	}
//
//	psl->size--;
//}

查看顺序表数据个数

size_t SeqListSize(SLT* psl)
{
	assert(psl);
	return psl->size;
}

顺序表的修改

void SeqListAt(SLT* psl, size_t pos, SQDataType x)
{
	assert(psl);
	assert(pos < psl->size);

	psl->a[pos] = x;
}

注：

• 访问数据结构不要直接去访问，而要调用函数接口去访问，这样做时更规范的（访问修改数据结构的建议一定用函数去，这样是最安全靠谱的）
• 越界不一定报错，系统对越界的检查是一种抽查。一般情况对数组的检查，读一般检查不出来只针对写进行检查，它会在数组结束的位置设置几个标志位，其他地方不检查所以越界到后面一般都检查不出来，程序结束时它会看这几个标志位有没有被修改，如果有被修改说明越界了就会报错。读的话检查不出来标志位没有被修改。如果是越界写通常能被检查出来因为越界一般情况都是越界数组后面的位置，如果不越这些位置直接跳到后面的位置它是不一定能检查出来的，这是具体由编译器决定的（不同的编译器都是不同的）。越界读时编译的时候也是检查不出来的因为它是通过看标志位有没有改。