顺序表的实现

顺序表的一般接口 

顺序表本质上来说是一个数组，有动态顺序表和静态顺序表之分，一般来说，静态顺序表占大多数【方便修改容量】

下图是一个静态的顺序表，初识容量就会被固定，不方便修改；

下图是一个动态的顺序表，在容量不足时可以使用扩容接口函数进行扩容。

顺序表的一些基本接口函数：

// 基本增删改查接口

// 初始化
void SeqListInit(SeqList* psl, size_t capacity);

// 扩容检查
void CheckCapacity(SeqList* psl);

// 尾插
void SeqListPushBack(SeqList* psl, SLDataType x);

// 尾删
void SeqListPopBack(SeqList* psl);

// 头插
void SeqListPushFront(SeqList* psl, SLDataType x);

// 头删
void SeqListPopFront(SeqList* psl);

// 查找
int SeqListFind(SeqList* psl, SLDataType x); 

// pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);

// 删除pos位置的值
void SeqListErase(SeqList* psl, size_t pos);

// 销毁
void SeqListDestory(SeqList* psl);

// 打印
void SeqListPrint(SeqList* psl);

具体实现·如下： 

#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"

//顺序表初始化
void SeqListInit(SeqList* psl) {
	assert(psl);
	psl->arr = NULL;
	psl->capacity = psl->size = 0;
}

//检查空间：
void CheckCapacity(SeqList* psl) {
	assert(psl);
	//如果size == capacity，说明空间满了，需要扩容
	//如果capacity == 0，说明顺序表没有空间，需要开辟
	if (psl->capacity == psl->size) {
		int newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;
		SLDataType* newArr = realloc(psl->arr, sizeof(SLDataType) * newCapacity);
		if (newArr == NULL) {
			printf("realloc fail\n");
			exit(-1);
		}
		else {
			psl->arr = newArr;
			psl->capacity = newCapacity;
		}
	}
}

//尾插
void SeqListPushBack(SeqList* psl, SLDataType x) {
	assert(psl);
	CheckCapacity(psl);
	psl->arr[psl->size] = x;
	psl->size++;
}

//尾删
void SeqListPopBack(SeqList*psl) {
	assert(psl);
	CheckCapacity(psl);
	if (psl->size > 0) {
		psl->size--;
	}
}

//头插
void SeqListPushFront(SeqList* psl, SLDataType x) {
	assert(psl);
	CheckCapacity(psl);
	//头插需要把数据向后挪动一个
	for (int tmp = psl->size; tmp > 0; tmp--){
		psl->arr[tmp] = psl->arr[tmp -1];
	}
	psl->arr[0] = x;
	psl->size++;
}

//头删
void SeqListPopFront(SeqList* psl) {
	assert(psl);
	if (psl->size > 0) {
		//将所有数据往前移动一个
		for (int i = 0; i<psl->size; i++)	{
			psl->arr[i] = psl->arr[i + 1];
		}
		psl->size--;
	}
}

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

//pos位置插入
void SeqListInsert(SeqList* psl, int pos, SLDataType x) {
	assert(psl);
	CheckCapacity(psl);
	if (pos<0 || pos>psl->size) {
		printf("pos不合法\n");
		exit(-1);
	}
	int tmp = psl->size - pos;
	for (int i = psl->size; tmp >0; i--) {
		psl->arr[i] = psl->arr[i - 1];
		tmp--;
	}
	psl->arr[pos] = x;
	psl->size++;
}

//删除pos位置的值
void SeqListErase(SeqList* psl, int pos) {
	assert(psl);
	if (pos<0 || pos>psl->size) {
		printf("pos不合法\n");
		exit(-1);
	}

	//pos位置之后的数据往前移动一个
	while ((psl->size - pos) > 1) {
		psl->arr[pos] = psl->arr[pos + 1];
		pos++;
	}
	psl->size--;
}

//销毁
void SeqListDestory(SeqList* psl) {
	assert(psl);
	free(psl->arr);
	psl->arr = NULL;
	psl->capacity = psl->size = 0;
}

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

int main() {
	SeqList list;
	SeqListInit(&list);

    return 0;
}

其中，尾插 尾删 头插 头删 简洁写法·如下：

对尾插尾删头插头删使用SeqListErase与SeqListInsert方法可以简化代码：

 总体来说，顺序表在一定程度上有空间的浪费（一次性两倍的扩容），在进行中间或头部的插入、删除时（需要挪动数据），时间复杂度是O(N)，且扩容时旧数据的拷贝，原空间的释放都会有损耗。