数据结构顺序表各接口实现

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

顺序表一般可以分为：

1. 静态顺序表：使用定长数组存储。
2. 动态顺序表：使用动态开辟的数组存储。

// 顺序表的静态存储
#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;

接口具体代码实现：

//Seqlist.h
#ifndef __SEQLIST_H__
#define __SEQLIST_H__
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

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

void SeqListInit(SeqList* ps);//初始化
void SeqListDestory(SeqList* ps);//销毁
void SeqListPrint(SeqList* ps);//打印

void SeqListCheckCapacity(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);//查找
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x);//插入
void SeqListErase(SeqList* ps, size_t pos);//删除
void SeqListRemove(SeqList* ps, SLDataType x);

void SeqListBubbleSort(SeqList* ps);
int SeqListBinaryFind(SeqList* ps, SLDataType x);

#endif //__SEQLIST_H__

//Seqlist.c
#define _CRT_SECURE_NO_WARNINGS 1


#include"Seqlist.h"


void SeqListInit(SeqList* ps)//初始化
{
	ps->_a = NULL;
	ps->_size = 0;
	ps->_capacity = 0;

}
void SeqListDestory(SeqList* ps)//销毁
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_size = ps->_capacity = 0;
}
void SeqListPrint(SeqList* ps)//输出
{
	assert(ps);
	for (size_t i = 0; i < ps->_size; ++i)
	{
		printf("%d ", ps->_a[i]);
	}
	printf("\n");
}
void SeqListCheckCapacity(SeqList* ps)//检查空间大小
{
	assert(ps);
	if (ps->_size >= ps->_capacity)
	{
		size_t newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		ps->_a=realloc(ps->_a, ps->_capacity * sizeof(SLDataType));
		ps->_capacity = newcapacity;
	}
}
void SeqListPushBack(SeqList* ps, SLDataType x) //尾插
{
	assert(ps);
	SeqListCheckCapacity(ps);
	ps->_a[ps->_size++] = x;
}
void SeqListPopBack(SeqList* ps)//尾删
{
	assert(ps&&ps->_size>0);
	ps->_size--;
}
void SeqListPushFront(SeqList* ps, SLDataType x)//头插
{
	assert(ps);
	SeqListCheckCapacity(ps);
	int end = ps->_size;
	for (; end >= 0; --end)
	{
		ps->_a[end + 1] = ps->_a[end];
	}
	ps->_a[0] = x;
	ps->_size++;
}
void SeqListPopFront(SeqList* ps)//头删
{
	assert(ps && ps->_size>0);
	for (size_t i = 1; i < ps->_size; ++i)
	{
		ps->_a[i - 1] = ps->_a[i];
	}
	ps->_size--;

}
int SeqListFind(SeqList* ps, SLDataType x)//查找
{
	assert(ps);
	for (int i = 0; i < ps->_size; ++i)
	{
		if (ps->_a[i] == x)
		{
			return i;
		}
		
	}
	return -1;

}
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x)//插入
{
	assert(ps&&pos<ps->_size);
	SeqListCheckCapacity(ps);
	size_t end = ps->_size+1;
	while (end > pos)
	{
		ps->_a[end] = ps->_a[end - 1];
		--end;
	}
	ps->_a[pos] = x;
	ps->_size++;
}
void SeqListErase(SeqList* ps, size_t pos)//删除
{
	assert(ps && pos < ps->_size);
	size_t i = pos + 1;
	while (i < ps->_size)
	{
		ps->_a[i - 1] = ps->_a[i];
		++i;
	}
	ps->_size--;

}
void SeqListRemove(SeqList* ps, SLDataType x)
{
	int pos = SeqListFind(ps, x);
	if (pos >= 0)
	{
		SeqListErase(ps, pos);
	}
}

void SeqListBubbleSort(SeqList* ps)
{
	for (size_t end = ps->_size; end > 0; --end)
	{
		for (size_t i = 0; i < ps->_size; ++i)
		{
			if (ps->_a[i]>ps->_a[i + 1])
			{
				SLDataType tmp = ps->_a[i];
				ps->_a[i] = ps->_a[i + 1];
				ps->_a[i + 1] = tmp;
			}
		}
	}
	
}

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