顺序表的基本操作

线性表

线性表时具有相同特性的数据元素的一个有限序列。该序列所含元素的个数叫做线性表的长度，用n表示，n>=0。是一种在实际中广泛应用的数据结构:顺序表，链表，栈，队列........

在逻辑上是 线性结构，每个数据元素由逻辑序号唯一确定，(但是在物理结构上斌不一定是连续的)线性表在物理上的存储时，通常以数组或者链式结构的形式存储。

  顺序表

顺序表的存储

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

# define N 6
typedef int SLDataType;
typedef struct
{    SLDataType array[N];//定长数组
     size_t size;//有效数据个数
}SeqList;

 静态是指空间在代码执行之前就已经开辟好了，已经规定了的长度

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

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

//若空间不够则扩容

 接口实现

静态顺序表只适用于确定的存储数据的场景，可能存在不足或浪费的情况。实际情况下，更多是使用动态顺序表，按照需要的分配空间大小。基本操作如下：

typedef int SLDataType;
// 顺序表的动态存储
typedef struct SeqList
{
  SLDataType* array;  // 指向动态开辟的数组
  size_t size ;       // 有效数据个数
  size_t capicity ;   // 容量空间的大小
}SeqList;
// 基本增删查改接口
// 顺序表初始化
void SeqListInit(SeqList* ps);
// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* ps);
// 顺序表尾插
void SeqListPushBack(SeqList* ps, SLDataType x);
// 顺序表尾删
void SeqListPopBack(SeqList* ps);
// 顺序表头插
void SeqListPushFront(SeqList* ps, SLDataType x);
// 顺序表头删
void SeqListPopFront(SeqList* ps);
// 顺序表查找
int SeqListFind(SeqList* ps, SLDataType x); 
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, size_t pos);
// 顺序表销毁
void SeqListDestory(SeqList* ps);
// 顺序表打印
void SeqListPrint(SeqList* ps);

 初始化与销毁

初始化线性表：

void SLInit(SL* ps)
{
      ps->a = (SLDataType*)malloc(sizeof(SLDataType)*4);
      if(ps->a == NULL)
      {  
         perror("malloc failed");//判断是否开辟空间成功 
         exit(-1);//程序异常终止
} 
      ps->size = 0;
      ps->capacity = 0;
} 

请注意：这里初始化的函数在主函数调用时会对参数做出改变，因为函数中是形参，形参是实参的拷贝，形参的改变不影响实参，所以需要把实参的地址传入函数中，通过地址解引用，找到实参，从而通过改变形参指向的对象，去改变实参。

销毁线性表：

void SLDestroy(SL* ps)
{  
      free(ps->a);//释放顺序表空间
      ps->a = NULL;
      ps->capacity = ps->size = 0;
}

 注意：free函数的作用是清空这整段空间释放，后面的一段空间删除不可用此函数。

  头插头删与尾插尾删

尾插的实现也很简单，函数如其名字，在存储空间的存放数据的尾部继续添加数据，要注意的是：在初始化时分配的空间是否用完了，需不需要再开辟空间

void SLPushBack(SL* ps,SLDataType)
{   //满了要扩容
     if(ps->size == ps->capacity) 
    {
        SLDataType* tmp =(SLDataType*)realloc(ps->a,ps->capacity*2*(sizeof(SLDatatype)));
        if(tmp == NULL)//判断是否开辟空间成功
    {
        perror("realloc failed");
        exit(-1);
    }
        ps->a = tmp;
        ps->capacity *=2;      
       }
         } 

在扩容时，也会出现两种情况：

原地扩容 ：在原来堆区开辟的空间后面接着分配空间。

异地扩容：当原来的空间不足以满足再次开辟空间的需要，将会在其他地方再次开辟空间，并将原空间的数据迁移到新开辟的空间。

以下的代码的运行实例：

尾部删除需实际是是将存放数据的下标向前移动一位，使其存放的数据无效，不在存放的序列中，完成数据删除的操作

void SLPopBack(SL* ps)
{
	//检查
	if (ps->size == 0)
		return;

	//检查2,直接程序结束
	assert(ps->size > 0);

	ps->a[ps->size - 1] = 0;
	ps->size--;
}

在此代码中，加入了两种检查的代码，目的是为了防止发生越界，越界问题在C语言中不会对这种行为进行检查，只有在运行期间才会发现问题 (一般释放空间与程序运行结束，会对存放空间进行检查，查看是否存在修改情况。)

头插代码示例：

void SLPushFront(SL* ps, SLDataType x)
{
	SLCheckCapacity(ps);//扩容

	// 挪动数据，数据是从后往前挪动
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[0] = x;
	ps->size++;
}

在开辟空间的最前端插入数据，需要开辟新的空间，将原有的数据移动一位，空出下标为0的执行的数据空间，并填入数据。 

 头部删除：在要删除的后一个数据的下标标记后，整体数据向前覆盖，完成头部删除，在这里同样需要注意越界问题。

void SLPopFront(SL* ps)
{
	assert(ps);//检查

	assert(ps->size > 0);//检查

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

	ps->size--;
	SLErase(ps, 0);
}

定点插入删除

在pos处插入x：可以首先检查一下POS位置是否合法，再执行操作，再定义一个变量，，将插入位置后的数据向后移动(若空间不够先扩容)

// 在pos位置插入x
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);

	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);//扩容自定义函数
//挪动数据的主要代码
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
//挪动数据的主要代码
	ps->a[pos] = x;
	ps->size++;
}

定点删除：若是按值查找删除，可以先定义一个函数，执行查找的功能，如下：

//遍历一遍，暴力查找
int SLFind(SL* ps, SLDataType x)
{
	assert(ps);

	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}

	return -1;
}

 接下来，就可以找到POS的位置，进行删除操作：

void SLErase(SL* ps, int pos)
{
	assert(ps);//检查

	assert(pos >= 0 && pos < ps->size);

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

	ps->size--;
}