数据结构——顺序表

一. 线性表

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

二. 顺序表

2.1概念及结构

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

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

---

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

2.2 接口实现

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

typedef int SLDataType;
#define Init_Capacity 4
typedef struct SeqList
{
	SLDataType* a;	// 指向动态开辟的数组
	int size;  	// 有效数据个数
	int capacity;// 容量空间的大小
}SL;

• 对 int 类型进行重命名 SLDataType，方便存储不同类型的数据
• 宏定义Init_Capacity，方便修改顺序表的初始大小容量
• 对 struct SeqList类型进行重命名 SL

(1)顺序表初始化

 给顺序表开辟一个数据类型为SL，大小为Init_Capacity的数组

void SLInit(SL* ps)
{
	ps->a = (SL*)malloc(sizeof(SL) * Init_Capacity);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	ps->size = 0;
	ps->capacity = Init_Capacity;
}

(2)顺序表销毁

 释放动态内存开辟的空间，避免造成内存泄漏，并将 ps->a 置空

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

(3)顺序表扩容

 首先，判断当前数组是否已充满，若需要扩容，则先创建一个临时变量用来存放新申请的空间的地址（防止realloc异地扩容）异地扩容的知识点，扩容的大小由自己定义。

void CheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		SL* tmp = (SL*)realloc(ps->a, sizeof(SL) * 2 * ps->capacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(1);
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
}

(4)尾插数据

 插入数据前，先检查是否需要扩容，然后在顺序表的末尾插入新的数据

void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	assert(ps->a);
	CheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}

(5)头插数据

 插入数据前，先检查是否需要扩容，因为是在顺序表的开头插入数据，所以要将整个顺序表的数据往后移一个位置（注意：从末尾的数据开始往后移动，循环向前，不然会造成数据覆盖），腾出空间，留给新插入的元素。

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	assert(ps->a);
	CheckCapacity(ps);
	for (int i = ps->size - 1; i >= 0; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[0] = x;
	ps->size++;
}

(6)在下标为pos的数据前插入x

 插入数据前，先检查是否需要扩容，原理跟头插数据相同，只不过插入数据的位置不同。(要确保下标 pos>= 0 && pos <= ps->size)

void SLInsert(SL* ps, int pos,SLDataType x)//在下标为pos的数据前插入x 
{
	assert(ps);
	assert(ps->a);
	assert(pos >= 0 && pos <= ps->size);
	CheckCapacity(ps);
	int end =Ins ps->size-1;
	for (int i = end ;i >= pos; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[pos] = x;
	ps->size++;
}

 优化头插和尾插函数

  编写 SLInsert函数后，可以运用 SLInsert函数来实现SLPushFront函数和SLPushBack函数

 头插：在下标为 0 的数据前插入 x。尾插：在下标为 ps -> size 的数据前插入 x

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	assert(ps->a);
	//CheckCapacity(ps);
	/*for (int i = ps->size - 1; i >= 0; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[0] = x;
	ps->size++;*/
	SLInsert(ps, 0, x);
}

void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	assert(ps->a);
	/*CheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;*/
	SLInsert(ps, ps->size, x);
}

(7)尾删数据

 先确定有效数据个数 ps->size 是否 > 0，然后将有效数据个数 ps->size - 1，此时，被尾删的数据已经不能通过顺序表直接访问，等到下一次插入覆盖旧数据

void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->a);
	assert(ps->size > 0);
	ps->size--;
}

(8)头删数据

 先确定有效数据个数 ps->size 是否 > 0，要删除顺序表开头的数据，所以要将整个顺序表的数据往前移一个位置（注意：从第二个数据开始往前移动一个位置，循环向后，不然会造成数据覆盖）

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

(9)删除下标为pos的数据

 先确定有效数据个数 ps->size 是否 > 0，原理与头删数据相同，只不过删除数据的位置不同。(要确保下标 pos>= 0 && pos < ps->size)

void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(ps->a);
	assert(ps->size > 0);
	assert(pos >= 0 && pos < ps->size);
	int begin = pos;
	for (int i = begin; i < ps->size - 1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}

 优化头删和尾删函数

  编写 SLErase函数后，可以运用 SLErase函数来实现SLPopFront函数和SLPopBack函数

 头删：删除下标为 0 的数据。尾删：删除下标为 ps->size-1 的数据

void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->a);
	/*for (int i = 1; i < ps->size - 1; i++)
	{
		ps->a[i - 1] = ps->a[i];
	}
	ps->size--;*/
	SLErase(ps, 0);
}

void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->a);
	/*ps->size--;*/
	SLErase(ps, ps->size - 1);
}

(10)查找数据

 在顺序表中寻找值为 x 的数据，若找到，则返回下标，若找不到，则返回 -1

int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	assert(ps->a);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

(11)修改数据

 将下标为 pos 的数据修改为 x

void Modify(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(ps->a);
	assert(pos >= 0 && pos < ps->size);
	ps->a[pos] = x;
}

(12)打印顺序表

 将顺序表中的所有数据依次打印

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

2.3 顺序表的优缺点

 优点：

1. 尾插尾删，效率高
2. 下标随机访问，适合 排序 二分查找
3. CPU高速缓存命中率较高

 缺点：

1. 中间或者头部插入删除数据要移动数据，效率低
2. 空间不够，只能扩容，扩容有消耗
3. 按倍数扩容，用不完，造成空间浪费