什么是线性结构?

线性结构的定义是一个有序数据元素的集合。简单地说，线性结构是n个数据元素的有序（次序）集合。

那么线性结构中都包含什么内容？

常见的线性结构有：顺序表，链表，栈，队列，字符串。

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

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

顺序表通过数据的存储形式分为静态顺序表和动态顺序表，采用定长数组存储数据的为静态顺序表，使用动态开辟的数组存储数据的为动态顺序表。一般我们使用动态顺序表。

动态顺序表实例

//动态顺序表结构
typedef int DataType;
typedef struct SeqList {
	DataType* array;
	int capacity;//顺序表总大小
	int size;//顺序表中有效元素个数
}SeqList,* PSeqList;

// 顺序表的初始化 
void SeqListInit(PSeqList ps, int capacity) {
	ps->array = (DataType*)malloc(sizeof(DataType)*capacity);
	if (ps->array == NULL) {
		assert(0);
		return;
	}
	ps->capacity = capacity;
	ps->size = 0;
}

// 在顺序表的尾部插入值为data的元素
void SeqListPushBack(PSeqList ps, DataType data) {
#if 0
	assert(ps);
	//顺序表满情况
	CheckCapacity(ps);
	ps->array[ps->size] = data;
	ps->size++;
#endif
	//优化方法
	SeqListInsert(ps, ps->size, data);
}

// 删除顺序表最后一个元素 
void SeqListPopBack(PSeqList ps) {
#if 0
	assert(ps);
	if (SeqListEmpty(ps)) {
		return;
	}
	ps->size--;
#endif
	//优化方法
	SeqListErase(ps, ps->size - 1);
}

// 在顺序表的头部插入值为data的元素 
void SeqListPushFront(PSeqList ps, DataType data) {
#if 0
	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++;
#endif
	//优化
	SeqListInsert(ps, 0, data);
}

//删除顺序表头部的元素
void SeqListPopFront(PSeqList ps) {
#if 0
	if (SeqListEmpty(ps)) {
		return;
	}
	for (int i = 1; i < ps->size; ++i) {
		ps->array[i - 1] = ps->array[i];
	}
	ps->size--;
#endif
	//优化
	SeqListErase(ps, 0);
}

// 在顺序表pos位置插入值为data的元素 
void SeqListInsert(PSeqList ps, int pos, DataType data) {
	assert(ps);
	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++;
}

// 删除顺序表中pos位置上的元素 
void SeqListErase(PSeqList ps, int pos) {
	assert(ps);
	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--;
}

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

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

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

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

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

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

// 销毁顺序表
void SeqListDestory(PSeqList ps) {
	if (ps->array) {
		free(ps->array);
		ps->array = NULL;
		ps->capacity = 0;
		ps->size = 0;
	}
}

// 顺序表的扩容
void CheckCapacity(PSeqList ps) {
	assert(ps);
	if (ps->size == ps->capacity) {
		//说明顺序表空间满了
		int newcapacity = ps->capacity * 2;
		//申请新空间
		DataType* pTemp = (DataType*)malloc(sizeof(DataType)*newcapacity);
		if (pTemp == NULL) {
			assert(0);
			return;
		}
		//将旧空间元素拷贝至新空间
		for (int i = 0; i < ps->size; ++i) {
			pTemp[i] = ps->array[i];
		}
		//释放旧空间
		free(ps->array);
		//更新参数
		ps->array = pTemp;
		ps->capacity = newcapacity;
	}
}