一、线性表之顺序表

首先，我们先来看看什么是线性表。

线性表

线性表是n个具有相同特性的数据元素的有限序列。
常见的线性表：

• 顺序表
• 链表
• 栈
• 队列
• 字符串

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

• 数组形式：
  

• 链式结构：
  

顺序表

顺序表是一段物理地址连续的存储单元，依次存储数据元素的线性结构，一般情况下采用数组存储。
本质：是数组。
缺点：动态增容有性能消耗，扩容时容易造成空间浪费，头插需要挪动数据。
分类：

• 静态顺序表：使用定长数据存储。
• 动态顺序表：使用动态开辟的数据存储。

顺序表实现（静态+动态）

• 静态顺序表结构定义

// 顺序表的静态存储
#define N 100
typedef int SLDataType;
typedef struct SeqList
{
    SLDataType array[N]; // 定长数组
     size_t size; // 有效数据的个数
}SeqList;

• 动态顺序表结构定义

// 顺序表的动态存储
typedef struct SeqList
{
    SLDataType* array; // 指向动态开辟的数组
    size_t size ; // 有效数据个数
    size_t capicity ; // 容量空间的大小
}SeqList;

以上是静态顺序表和动态顺序表的定义，下面给出功能实现代码：
完整顺序表实现代码

顺序实现-初始化

//初始化顺序表
void SeqListInit(SeqList* pq)
{
	//assert(pq != NULL);//等价于下面
	assert(pq);
	pq->a = NULL;
	pq->size = pq->capacity = 0;
}

顺序实现-尾插

// 尾插  需要检查容量
void SeqListPushBack(SeqList* pq, SeqDataType x)
{
	assert(pq);
	SeqCheckCapacity(pq);//检查是否需要扩容
	pq->a[pq->size] = x; //向后移动一位
	pq->size++;
}

顺序实现-头插

需要注意： 头插时，移动数据的顺序是从后往前的。

// 头插 检查容量
void SeqListPushFront(SeqList* pq, SeqDataType x)
{
	assert(pq);
	SeqCheckCapacity(pq);
	//从后往前依次移动
	int end = pq->size - 1;
	while (end >= 0)
	{
		pq->a[end + 1] = pq->a[end];
		--end;
	}

	pq->a[0] = x;//头部插入x
	pq->size++;
}

顺序实现-头删和尾删

//尾删 
void SeqListPopBack(SeqList* pq)
{
	assert(pq);
	assert(pq->size > 0);
	--pq->size;
}
//头删
void SeqListPopFront(SeqList* pq)
{
	assert(pq);
	int start = 0;
	while (start < pq->size - 1)
	{
		pq->a[start] = pq->a[start + 1];
		++start;
	}
	pq->size--;//删除，size减小
}

顺序实现-打印顺序表

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

顺序实现-销毁

//顺序表销毁
void SeqListDestory(SeqList* pq)
{
	assert(pq);
	free(pq->a);//指向元素销毁
	pq->a = NULL;//避免野指针
	pq->capacity = pq->size = 0;//容量，大小置为零
}

顺序实现-检查容量和扩容

//检查容量  扩容
void SeqCheckCapacity(SeqList* pq)
{
	// 满了，需要增容
	if (pq->size == pq->capacity)
	{
		int newcapacity = pq->capacity == 0 ? 4 : pq->capacity * 2;//判断容量是否为0，为0时扩容*2，还是0，所以要判断。
		SeqDataType* newA = realloc(pq->a, sizeof(SeqDataType)*newcapacity);
		if (newA == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		pq->a = newA;
		pq->capacity = newcapacity;
	}
}

顺序实现-查找

int SeqListFind(SeqList* pq, SeqDataType x)
{
	assert(pq);
	for (int i = 0; i < pq->size; i++)
	{
		if (pq->a[i] == x){
			return i;
		}
	}
	return -1;
}

顺序实现-任意位置插入

void SeqListInsert(SeqList* pq, int pos, SeqDataType x)
{
	assert(pq);
	assert(pos >= 0 && pos <= pq->size);

	SeqCheckCapacity(pq);

	int end = pq->size - 1;
	while (end >= pos)
	{
		pq->a[end + 1] = pq->a[end];
		--end;
	}

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

顺序表实现-删除指定位置

void SeqListErase(SeqList* pq, int pos)
{
	assert(pq);
	assert(pos >= 0 && pos < pq->size);

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

顺序表实现-修改

void SeqListModify(SeqList* pq, int pos, SeqDataType x)
{
	assert(pq);
	assert(pos >= 0 && pos < pq->size);

	pq->a[pos] = x;
}

由于顺序表的扩容不方便、头插不方便等缺点，于是有了链表。 链表在下一节，介绍。