数据结构：动态顺序表

动态顺序表

实现基于动态数组的顺序表的以下基本操作：

1. 顺序表的初始化

2. 在顺序表的尾部插入值为data的元素

3. 删除顺序表最后一个元素

4. 在顺序表的头部插入值为data的元素

5. 删除顺序表头部的元素

6. 在顺序表pos位置插入值为data的元素

7. 删除顺序表中pos位置上的元素

8. 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的下标，否则返回-1

9. 检测顺序表是否为空，如果为空返回非0值，非空返回0

10. 返回顺序表中有效元素的个数

11. 返回顺序表的容量大小

12. 将顺序表中的元素清空

13. 删除顺序表中第一个值为data的元素

14. 销毁顺序表

15. 顺序表的扩容

代码如下：

引入头文件，定义顺序表

#pragma once

typedef int DataType;
#define INIT_SIZE 10 

typedef struct SeqList {
	DataType* _array; //数据块指针
	int _capacity; // 顺序表的总大小 
	int _size; // 顺序表中有效元素的个数 
}SeqListD;
typedef SeqListD* PSeqListD; 

// 顺序表的初始化 
void SeqListInit(PSeqListD pSeq);
// 在顺序表的尾部插入值为data的元素 
void SeqListPushBack(PSeqListD pSeq, DataType data);
// 删除顺序表最后一个元素 
void SeqListPopBack(PSeqListD pSeq);
// 在顺序表的头部插入值为data的元素 
void SeqListPushFront(PSeqListD pSeq, DataType data);
// 删除顺序表头部的元素 
void SeqListPopFront(PSeqListD pSeq);
// 在顺序表pos位置插入值为data的元素 
void SeqListInsert(PSeqListD pSeq, int pos, DataType data);
// 删除顺序表中pos位置上的元素 
void SeqListErase(PSeqListD pSeq, int pos);
// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的下标，否则返回-1 
int SeqListFind(PSeqListD pSeq, DataType data);
// 检测顺序表是否为空，如果为空返回非0值，非空返回0 
int SeqListEmpty(PSeqListD pSeq);
// 返回顺序表中有效元素的个数 
int SeqListSize(PSeqListD pSeq);
// 返回顺序表的容量大小 
int SeqListCapacity(PSeqListD pSeq);
// 将顺序表中的元素清空 
void SeqListClear(PSeqListD pSeq);
// 删除顺序表中第一个值为data的元素 
void SeqListRemove(PSeqListD pSeq, DataType data);
// 销毁顺序表 
void SeqListDestroy(PSeqListD pSeq);
// 顺序表的扩容 
void CheckCapacity(PSeqListD pSeq);

具体功能的实现
代码如下：

#include"SList.h"
#include<stdio.h>
#include<assert.h>
#include<malloc.h>
#include<string.h>
#include<stdlib.h>

// 顺序表的初始化 
void SeqListDInit(PSeqListD pSeq) {
	assert(pSeq);
	pSeq->_array = (DataType*)malloc(sizeof(DataType)*INIT_SIZE);
	if (pSeq->_array == 0) {
		printf("申请失败！\n");
		return;
	}
	pSeq->_size = 0;
	pSeq->_capacity = INIT_SIZE;
}
//顺序表扩容
void ChackCapacity(PSeqListD pSeq) {
	assert(pSeq);
	if (pSeq->_size >= pSeq->_capacity) {
		DataType *p = (DataType*)realloc(pSeq->_array, 2 * (pSeq->_capacity)*sizeof (DataType));
		if (p == NULL) {
			printf("内存申请失败\n");
			return;
		}
		else {
			pSeq->_array = p;
			pSeq->_capacity = 2 * pSeq->_capacity;
		}
	}
}

// 在顺序表的尾部插入值为data的元素 
void SeqListPushBack(PSeqListD pSeq, DataType data) {
	assert(pSeq);
	ChackCapacity(pSeq);
	pSeq->_array[pSeq->_size] = data;
	pSeq->_size++;
}

// 删除顺序表最后一个元素 
void SeqListPopBack(PSeqListD pSeq) {
	assert(pSeq);
	if (pSeq->_size == 0) {
		printf("顺序表为空，无法删除\n");
		return;
	}
	pSeq->_size--;
}

// 在顺序表的头部插入值为data的元素 
void SeqListPushFront(PSeqListD pSeq, DataType data) {
	assert(pSeq);
	ChackCapacity(pSeq);
	for (int i = pSeq->_size; i > 0; i--) {
		pSeq->_array[i] = pSeq->_array[i - 1];
	}
	pSeq->_array[0] = data;
	pSeq->_size++;
}

// 删除顺序表头部的元素 
void SeqListPopFront(PSeqListD pSeq) {
	assert(pSeq);
	if (pSeq->_size == 0) {
		printf("顺序表为空，无法删除\n");
		return;
	}
	for (int i = 0; i < pSeq->_size; i++) {
		pSeq->_array[i] = pSeq->_array[i + 1];
	}
	pSeq->_size--;
}

// 在顺序表pos位置插入值为data的元素 
void SeqListInsert(PSeqListD pSeq, int pos, DataType data) {
	assert(pSeq);
	ChackCapacity(pSeq);
	for (int i = pSeq->_size; i > pos; i--) {
		pSeq->_array[i] = pSeq->_array[i - 1];
	}
	pSeq->_array[pos] = data;
	pSeq->_size++;
}

// 删除顺序表中pos位置上的元素 
void SeqListErase(PSeqListD pSeq, int pos) {
	assert(pSeq);
	if (pos <= 0 || pos >= pSeq->_size) {
		printf("输入不合法\n");
		return;
	}
	for (int i = pos; i < pSeq->_size - 1; i++) {
		pSeq->_array[i] = pSeq->_array[i + 1];
	}
	pSeq->_size--;
}

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

// 检测顺序表是否为空，如果为空返回非0值，非空返回0 
int SeqListEmpty(PSeqListD pSeq) {
	assert(pSeq);
	if (pSeq->_size == 0) {
		printf("顺序表为空\n");
	}
	printf("顺序表有效元素个数为%d", pSeq->_size);
	return 0;
}

// 返回顺序表中有效元素的个数 
int SeqListSize(PSeqListD pSeq) {
	assert(pSeq);
	if (pSeq == 0) {
		printf("顺序表为空");
		return;
	}
	return pSeq->_size;
}

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

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

// 删除顺序表中第一个值为data的元素 
void SeqListRemove(PSeqListD pSeq, DataType data) {
	assert(pSeq);
	for (int i = 0; i < pSeq->_size-2; i++) {
		if (pSeq->_array[i] == data) {
			pSeq->_array[i] = pSeq->_array[i + 1];
		}
		pSeq->_array[i + 1] = pSeq->_array[i + 2];
	}
	pSeq->_size--;
}

// 销毁顺序表 
void SeqListDestroy(PSeqListD pSeq) {
	assert(pSeq);
	free(pSeq->_array);
	pSeq->_array = NULL;
	pSeq->_capacity = 0;
	pSeq->_size = 0;
}