【线性表——顺序表】

一、线性表

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

二、顺表表

1.顺序表的介绍

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

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

2. 动态顺序表; 使用动态开辟的数组内存存储。
   

2.动态顺序表的代码模块实现

1.顺序表的定义

typedef int SLDatatype;
typedef struct SeqList
{
	SLDatatype* a;
	int size;//当前有多个元素
	int capacity;//当前的容量
}SL;

这里我们定义了一个指针a、size表示当前的元素个数，capacity表示顺序表里的当前容量。在当前容量capacity等于元素个数size时，我们对指针a进行动态数组内存开辟，来实现了动态顺序表。

2.顺序表的初始化

void InitSL(SL* s)
{
	assert(s);//防止传进来的是空指针
	s->a = NULL;
	s->size = 0;
	s->capacity = 0;
}

在初始化时我们将s->a所指向的空间置为空（在后面我们会单独封装一个函数来实现动态数组内存开辟），将s->size和s->capacity都赋值为零。
3.顺序表的销毁

//销毁
void DestroySL(SL* s)
{
	assert(s);
	//判断是否有元素
	if (s->a != NULL)
	{
		free(s->a);
		s->a = NULL;
		s->size = 0;
		s->capacity=0;
	}
}

这里我们需要先判断顺序表里面是否还有元素（防止将有用的元素一并销毁）。因为是动态开辟的内存，所以我们也需要释放空间，并将指针a置为NULL。
4.顺序表的打印

//打印
void PrintSL(SL* s)
{
	assert(s);
	for (int i = 0; i < s->size; i++)
	{
		printf("%d ", s->a[i]);
	}
	printf("\n");
}

这里我们仿照遍历数组对顺序表进行遍历。主要因为顺序表是连续存储的。
5.顺序表的检查

//数据的检查
void CheckSL(SL* s)
{
	if (s->size == s->capacity)
	{
		int newCapacity = s->capacity == 0 ? 4 : 2 * s->capacity;
		int* temp = (int*)realloc(s->a, sizeof(SLDatatype)*newCapacity);
		if (temp == NULL)
		{
			perror("realloc fail");
			return;
		}
		s->a = temp;
		s->capacity = newCapacity;
	}
}

为什么我们需要对顺序表检查呢？
因为我们写的代码为动态顺序表，在对其进行插入元素时必须检查空间是否够用。当capacity和size均为0（初始时）或size和capacity一样大但不为0时（空间满了），我们需要对其开辟空间。但因为我们在初始化时没有对顺序表开辟空间，所以这里引入三目操作运算符来判断，如果当前空间大小为0，那我们开辟四个空间；如果空间满了，那我们使用realloc函数进行增补开辟空间。这里需要注意realloc的使用，设置一个临时指针变量来开辟新空间，在判断新空间不为空后将新空间拷贝至s->a来实现扩容。
6.顺序表的头插尾插

//头插元素
void PushFrontSL(SL* s,SLDatatype x)
{
	assert(s);
	
	//检查数据
	CheckSL(s);
	//移动元素
	for(int end= s->size-1; end>=0; end--)
	{
		s->a[end+1] = s->a[end];
	}
	//插入元素
	s->a[0] = x;
	s->size++;
	
}

因为顺序表是连续存储的，所以我们在头插元素前需要将所有元素向后移动（这个其实就是我们所说的数组元素覆盖），在移动时需要注意的是必须从最后一个元素进行移动。我们让end指向最后一个元素，然后不断将end移向后一个元素。

问题1;为什么必须从后往前移动，而不是从前往后移动？
答;因为从前往后移动时会把数组全部覆盖为数组的一个元素。

问题2;为什么在移动覆盖语句不写成s->a[end]=s->end[end-1]
答;因为这样会使的数组的最后一个被覆盖，并且在移动数组的第一个元素时end-1会造成数组越界。
注意（以上问题只针对本代码条件下！！！）

//尾插元素
void PushBackSL(SL* s,SLDatatype x)
{
	assert(s);
	CheckSL(s);
	s->a[s->size] = x;
	s->size++;
}

这里在判断完之后直接将我们需要的元素插入最后即可。

7.顺序表的头删尾删

//头删元素
void PopFrontSL(SL* s)
{
	assert(s);
	//判断是否有元素
	if (s->size <= 0)
	{
		printf("没有元素可以删除\n");
		return;
	}
	//删除移数
	for (int begin = 0; begin < s->size - 1; begin++)
	{
		s->a[begin] = s->a[begin + 1];
	}
	s->size--;
}

因为顺序表是连续存储的，所以我们在删除的时候需要可参考数组的覆盖来达到删除元素的目的。每删除一个元素将s->size减一。再删除前我们需要判断顺序表里是否有元素，然后进行删除。在这里需要注意的是，覆盖元素必须从前往后覆盖。我们让begin指向第一个元素，不断将begin往后移动，达到覆盖元素的目的。

问题1： 为什么必须从前往后开始覆盖？
答：因为从后往前覆盖是将最后一个元素覆盖给整个数组。

问题2：为什么移动覆盖语句不能写成s->a[begin]=s->a[begin-1]?
答：因为这样会使数组在第一次覆盖的时候造成越界，并且最后一个元素也无法移动覆盖至前一个元素里。
注意（以上问题只针对本代码条件下！！！）

//尾删元素
void PopBackSL(SL* s)
{
	assert(s);
	//不让size出现负值
	if (s->size > 0)
	{
		s->size--;
	}
}

这里我们在判断完后直接将s->size–即可。因为顺序表是连续存储的，尾删时将不用像头删一样需要移动元素，仅仅将我们s->size–，但是我们需要注意的是s->size不能小于0.（元素的个数可没有负的），也是为了防止我们在删除过头之后再次插入元素的时候造成数组越界。

8.顺序表的在任意下标位置进行插入、删除

//任意位置进行插入
void SLInsert(SL* s, int pos,SLDatatype x)
{
	assert(s);
	CheckSL(s);

	//判断位置是否合法
	assert(pos >= 0 && pos <= s->size - 1);
	//移数插入
	for (int end = s->size-1; end >= pos ; end--)
	{
		s->a[end+1] = s->a[end];
	}
	s->a[pos] = x;
	s->size++;
}

这里的任意位置插入我们在判断时需要加入对于插入位置的判断。由于顺序表是连续存储的，我们在插入元素时需要注意插入位置于原来位置的连续性。在移动覆盖数据时我们将end的指向了最后，然后从后往前不断地覆盖元素（这个和头插在移动覆盖元素的原理一样）。最后将元素插入，s->size++即可。

//任意下标位置删除元素
void SLErase(SL* s, int pos)
{
	assert(s);
	CheckSL(s);
	//判断位置是否合法
	assert(pos >= 0 && pos <= s->size - 1);
	//移数删除
	for (int begin = pos; begin < s->size; begin++)
	{
		s->a[begin] = s->a[begin + 1];
	}
	s->size--;

}

这里我们在判断完之后将begin指向了我们需要插入的位置，然后从前往后不断移动覆盖元素（这个和头删的移动覆盖元素原理一样）。最后将s->size–即可。

9.顺序表查找元素

//查找数据
//找到了返回该元素下标
//没有找到返回-1
int SLFind(SL* s, SLDatatype x)
{
	int i = 0;
	while (i < s->size - 1)
	{
		if (s->a[i++] == x)
		{
			return i;
		}	
	}
}

这里我们将是按值查找元素，对顺序表中的元素进行比较，要是相等则返回该元素下标，找不到时返回-1。但这个代码存在一个问题，当我们在查找元素时若顺序表含有相同元素，那么在返回值只能返回第一个数，其他的无法返回。

3.存在问题

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

为了解决这一问题，我们需要引入链表。敬请期待下一期的《线性表——链表 》。

---