数据结构【顺序表】

1. 什么是线性结构？ 线性结构中都包含什么内容？

数据结构课程中数据的逻辑结构分为线性结构和非线性结构。
线性结构是一个有序数据元素的集合。常用的线性结构有：线性表，栈，队列，双队列，数组，串。
常见的非线性结构有：二维数组，多维数组，广义表，树(二叉树等)，图

2. 什么是顺序表？顺序表的分类？

顺序表就是用一段连续的物理地址存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上来完成增删查改。
顺序表一般分为两类：
1.静态顺序表：使用定长数组存储，空间大小是给定的，不能扩容
2.动态顺序表：使用动态开辟的数组存储，空间大小可以根据存储的元素数量来扩容

//静态顺序表的存储结构
typedef struct SeqList
{
	DataType array[N];     // 定长数组
	int _size;             // 顺序表中有效元素的个数 
}SeqList;

//动态顺序表的存储结构
typedef struct SeqList
{
	DataType* _array;     // 指向动态开辟的数组
	int _capacity;        // 顺序表的总大小 
	int _size;            // 顺序表中有效元素的个数 
}SeqList;

3. 动态顺序表的相关操作

（1）动态顺序表的初始化

// 顺序表的初始化 
//申请空间
//给定参数
void SeqListInit(PSeq ps, int capacity) {
	ps->_array = (DataType*)malloc(sizeof(DataType)*capacity);
	if (NULL == ps->_array) {
		assert(0);
		return;
	}
	ps->_capacity = capacity;
	ps->_size = 0;
}

（2）动态顺序表的尾插

// 在顺序表的尾部插入值为data的元素 
void SeqListPushBack(PSeq ps, DataType data) {
	assert(ps);
	//检验数组中还有没有空间可以插入元素
	CheckCapacity(ps);   
	ps->_array[ps->_size] = data;
	ps->_size++;
}

（3）动态顺序表的尾删

// 删除顺序表最后一个元素 
void SeqListPopBack(PSeq ps) {
	assert(ps);
	//检验数组中有没有元素
	if(SeqListEmpty(ps)) {
		return;
	}
	ps->_size--;
}

（4）动态顺序表的头插

// 在顺序表的头部插入值为data的元素 
void SeqListPushFront(PSeq ps, DataType data) {
	assert(ps);
	//检验数组中还有没有空间可以插入元素
	CheckCapacity(ps);
	//将顺序表中所有的元素向后搬移一个位置
	for (int i = ps->_size - 1; i >= 0; i--) {
		ps->_array[i + 1] = ps->_array[i];
	}
	//插入元素
	ps->_array[0] = data;
	ps->_size++;
}

（5）动态顺序表的头删

// 删除顺序表头部的元素 
void SeqListPopFront(PSeq ps) {
    //检验数组中有没有元素
	if (SeqListEmpty(ps)) {
		return;
	}
	//将顺序表中所有的元素向前搬移一个位置
	for (int i = 1; i <ps->_size; i++) {
		ps->_array[i-1] = ps->_array[i];
	}
	ps->_size--;
}

（6）动态顺序表的任意位置插入元素

// 在顺序表pos位置插入值为data的元素 
void SeqListInsert(PSeq ps, int pos, DataType data) {
	assert(ps);
	//检验pos是否为有效值
	if (pos < 0 || pos > ps->_size) {
		return;
	}
	CheckCapacity(ps);
	for (int i = ps->_size - 1; i >= pos; i--) {
		ps->_array[i + 1] = ps->_array[i];
	}
	ps->_array[pos] = data;
	ps->_size++;
}

（7）动态顺序表的任意位置删除元素

// 删除顺序表中pos位置上的元素 
void SeqListErase(PSeq ps, int pos) {
	if (pos < 0 || pos >= ps->_size) {
		return;
	}
	for (int i = pos + 1; i < ps->_size; i++) {
		ps->_array[i - 1] = ps->_array[i];
	}
	ps->_size--;
}

（8）检验顺序表是否为空

// 检测顺序表是否为空，如果为空返回非0值，非空返回0 
int SeqListEmpty(PSeq ps) {
	assert(ps);
	return 0 == ps->_size;
}

（9）返回动态顺序表有效元素个数

// 返回顺序表中有效元素的个数 
int SeqListSize(PSeq ps) {
	assert(ps);
	return ps->_size;
}

（10）返回动态动态顺序表的容量

// 返回顺序表的容量大小 
int SeqListCapacity(PSeq ps) {
	assert(ps);
	return ps->_capacity;
}

（11）将动态顺序表的元素清空

// 将顺序表中的元素清空 
void SeqListClear(PSeq ps) {
	assert(ps);
	ps->_size = 0;
}

（12）删除动态顺序表中第一个值为data的元素

// 删除顺序表中第一个值为data的元素 
void SeqListRemove(PSeq ps, DataType data) {
	SeqListErase(ps, SeqListFind(ps, data));
}

（13）动态顺序表的销毁

// 销毁顺序表 
void SeqListDestroy(PSeq ps) {
	if (ps->_array) {
		free(ps->_array);     //释放空间
		ps->_array = NULL;
		ps->_capacity = 0;
		ps->_size = 0;
	}
}

（14）动态顺序表的扩容

// 顺序表的扩容 
void CheckCapacity(PSeq ps) {
	assert(ps);
	if (ps->_size == ps->_capacity) {
		int newCapacity = ps->_capacity*2;
		//申请新空间
		int* pTmp = (DataType*)malloc(newCapacity*sizeof(DataType));
		if (NULL == pTmp) {
			assert(0);
			return;
		}
		//拷贝元素
		for (int i = 0; i < ps->_size; i++) {
			pTmp[i] = ps->_array[i];
		}
		//释放旧空间
		free(ps->_array);
		//更新
		ps->_array = pTmp;
		ps->_capacity = newCapacity;
	}
}

（15）查找动态顺序表的元素

// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的下标，否则返回-1 
int SeqListFind(PSeq ps, DataType data) {
	assert(ps);
	for (int i = 0; i < ps->_size; i++) {
		if (ps->_array[i] == data) {
			return i;
		}
	}
	return -1;
}