(C语言)数据结构-线性表之动态定长顺序表（完整代码）

动态定长顺序表的基本操作

//初始化的顺序表L
ElemType* SeqListInit();
//销毁（释放）顺序表的空间
int SeqListDestory(SeqList* L);
//顺序表动态扩容
void CheckCapacity(SeqList* L);
//顺序表尾插
int SeqListPushBack(SeqList* L, ElemType x);
//顺序表尾删
int SeqListPopBack(SeqList* L);
//顺序表头插
int SeqListPushFront(SeqList* L, ElemType x);
//顺序表头删
int SeqListPopFront(SeqList* L);
//输出顺序表的内容
int SeqListPrint(SeqList* L);
//返回顺序表中元素的下标
int SeqListFind(SeqList* L, ElemType x);
//顺序表任意位置插入元素
int SeqListInsert(SeqList* L, size_t i, ElemType x);
//删除顺序表指定下标的元素
int SeqListErase(SeqList* L, size_t i);
//返回数据表中元素的个数
size_t SeqListSize(SeqList* L);
//修改指定位置元素的值
int SeqListAt(SeqList* L, size_t i, ElemType x);

完整代码

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#define TRUE 1
#define FALSE 0
typedef int ElemType;

typedef struct SeqList
{
	ElemType* arr;		//用于指向动态开辟的数组空间
	size_t size;		//有效数据个数
	size_t capacity;	//容量大小
}SeqList;


//销毁（释放）顺序表的空间
int SeqListDestory(SeqList* L);
//顺序表动态扩容
void CheckCapacity(SeqList* L);
//顺序表尾插
int SeqListPushBack(SeqList* L, ElemType x);
//顺序表尾删
int SeqListPopBack(SeqList* L);
//顺序表头插
int SeqListPushFront(SeqList* L, ElemType x);
//顺序表头删
int SeqListPopFront(SeqList* L);
//输出顺序表的内容
int SeqListPrint(SeqList* L);
//返回顺序表中元素的下标
int SeqListFind(SeqList* L, ElemType x);
//顺序表任意位置插入元素
int SeqListInsert(SeqList* L, size_t i, ElemType x);
//删除顺序表指定下标的元素
int SeqListErase(SeqList* L, size_t i);
//返回数据表中元素的个数
size_t SeqListSize(SeqList* L);
//修改指定位置元素的值
int SeqListAt(SeqList* L, size_t i, ElemType x);



/***
*	函数名称：ElemType* SeqListInit()
*	函数功能：返回一个初始化的顺序表L
*	入口参数：none
*	出口参数：ElemType* L
*	返回类型：ElemType*
***/
SeqList* SeqListInit()
{
	SeqList* L;
	L = (SeqList*)malloc(sizeof(SeqList));
	L->arr = NULL;		//初始顺序表为空
	L->size = 0;		//初始数据个数为0
	L->capacity = 0;	//初始空间容量为0
	return L;
}

/***
*	函数名称：int SeqListDestory(SeqList* L)
*	函数功能：销毁（释放）顺序表的空间
*	入口参数：SeqList* L
*	出口参数：1
*	返回类型：int
***/
int SeqListDestory(SeqList* L)
{
	//assert() 断言 值为假(0)时终止程序执行
	assert(L != NULL);
	free(L->arr);		//释放动态开辟的数组空间
	L->arr = NULL;		//指针指向空
	L->size = 0;		//数据个数置为0
	L->capacity = 0;	//空间容量置为0
	return 1;
}

/***
*	函数名称：void CheckCapacity(SeqList* L) 
*	函数功能：判断顺序表是否已满，若容量已满则进行2倍扩容
*	入口参数：SeqList* L
*	出口参数：none
*	返回类型：void
***/
void CheckCapacity(SeqList* L) 
{
	assert(L != NULL);			//assert() 断言 值为假(0)时终止程序执行
	//判断容量是否已满
	if(L->size == L->capacity){
		size_t newcapacity;		//新容量
		//判断现有容量是否为0
		if (L->capacity == 0)
			newcapacity = L->capacity = 4;	//设置默认容量为4
		else
			newcapacity = L->capacity * 2;	//将现有容量的2倍大小存入newcapacity中
		//realloc(void *__ptr, size_t __size)：更改已经配置的内存空间，即更改由malloc()函数分配的内存空间的大小。
		//将L->arr扩容至newcapacity大小后赋给新的指针p
		ElemType* p = (ElemType*)realloc(L->arr, newcapacity * sizeof(ElemType));
		//判断空间是否开辟失败，失败则返回错误 结束程序
		if (p == NULL) {
			perror("realloc");
			exit(-1);
		}
		else {
			//空间开辟成功
			L->arr = p;		//扩容空间p赋值给L->arr
			L->capacity = newcapacity; //更新容量
		}
	}
}

/***
*	函数名称：int SeqListPushBack(SeqList* L, ElemType x)
*	函数功能：从顺序表尾部插入一个元素x
*	入口参数：SeqList* L, ElemType x
*	出口参数：1
*	返回类型：int
***/
int SeqListPushBack(SeqList* L, ElemType x) {
	assert(L != NULL);		//断言 顺序表L存在
	CheckCapacity(L);		//检查顺序表是否已满，已满则扩容
	L->arr[L->size] = x;	//尾部插入数据x
	L->size++;				//有效数据个数+1
	return 1;
}

/***
*	函数名称：int SeqListPopBack(SeqList* L)
*	函数功能：从顺序表尾部删除一个元素
*	入口参数：SeqList* L
*	出口参数：1
*	返回类型：int
***/
int SeqListPopBack(SeqList* L) {
	assert(L != NULL);		//L必须存在
	assert(L->size > 0);	//顺序表不能为空
	L->size--;	//数据有效个数-1
	return 1;
}

/***
*	函数名称：int SeqListPushFront(SeqList* L, ElemType x)
*	函数功能：从顺序表头部插入一个元素x
*	入口参数：SeqList* L, ElemType x
*	出口参数：1
*	返回类型：int
***/
int SeqListPushFront(SeqList* L, ElemType x) {
	assert(L != NULL);		//断言 顺序表L存在
	CheckCapacity(L);		//检查顺序表是否已满，已满则扩容
	//将顺序表整体后移一位，空出第一个的位置
	for (size_t i = L->size; i > 0; i--)
	{
		L->arr[i] = L->arr[i - 1];
	}
	L->arr[0] = x;			//尾部插入数据x
	L->size++;				//有效数据个数+1
	return 1;
	
}

/***
*	函数名称：int SeqListPopFront(SeqList* L)
*	函数功能：从顺序表头部删除一个元素
*	入口参数：SeqList* L
*	出口参数：1
*	返回类型：int
***/
int SeqListPopFront(SeqList* L) {
	assert(L != NULL);		//L必须存在
	assert(L->size > 0);	//顺序表不能为空
	//顺序表整体前移，用后一个覆盖前一个
	for (size_t i = 0; i < L->size; i++)
	{
		L->arr[i] = L->arr[i + 1];
	}
	//顺序表长度-1
	L->size--;
	return 1;
}

/***
*	函数名称：int SeqListPrint(SeqList* L)
*	函数功能：打印出顺序表的内容
*	入口参数：SeqList* L
*	出口参数：1
*	返回类型：int
***/
int SeqListPrint(SeqList* L) {
	assert(L != NULL);
	if (L->size == 0) return 0;
	for (size_t i = 0; i < L->size; i++)
	{
		printf("%d ", L->arr[i]);
	}
	return 1;
}

/***
*	函数名称：int SeqListFind(SeqList* L, ElemType x)
*	函数功能：在顺序表中查找元素x的值，返回下标i
*	入口参数：(SeqList* L, ElemType x
*	出口参数：i|-1
*	返回类型：int
***/
int SeqListFind(SeqList* L, ElemType x) {
	assert(L != NULL);
	for (int i = 0; i < L->size; i++)
	{
		//查找到改元素， 返回该元素的下标
		if (L->arr[i] == x) {
			
			return i;
		}
	}
	return -1;	//找不到返回-1
}

/***
*	函数名称：int SeqListInsert(SeqList* L, size_t i, ElemType x)
*	函数功能：在顺序表指定下标i的位置插入元素x
*	入口参数：SeqList* L, size_t i, ElemType x
*	出口参数：1
*	返回类型：int
***/
int SeqListInsert(SeqList* L, size_t i, ElemType x) {
	assert(L != NULL);
	assert(i >= 0 && i<=L->size);
	CheckCapacity(L);
	//将顺序表第i个元素整体往后位移，空出第i个元素的位置
	for (size_t j = L->size; j > i; j--)
	{
		L->arr[j] = L->arr[j - 1];
	}
	L->arr[i] = x;		//将x插入到i的位置
	L->size++;			//顺序表长度+1
	return 1;
}

/***
*	函数名称：int SeqListErase(SeqList* L, size_t i)
*	函数功能：删除顺序表的第i个元素
*	入口参数：SeqList* L, size_t i
*	出口参数：1
*	返回类型：int
***/
int SeqListErase(SeqList* L, size_t i) {
	assert(L != NULL);
	assert(L->size > 0);
	assert(i >= 0 && i < L->size);
	//将顺序表从第i个元素开始整体前移一位，覆盖前面的元素
	for (size_t j = i; j < L->size; j++)
	{
		L->arr[j] = L->arr[j + 1];
	}
	//元素个数-1
	L->size--;
	return 1;
}

/***
*	函数名称：size_t SeqListSize(SeqList* L)
*	函数功能：返回数据表中元素的个数
*	入口参数：SeqList* L, size_t i
*	出口参数：L->size
*	返回类型：size_t
***/
size_t SeqListSize(SeqList* L) {
	assert(L != NULL);
	return L->size;
}

/***
*	函数名称：int SeqListAt(SeqList* L, size_t i, ElemType x)
*	函数功能：修改指定下标i位置的元素的值为x
*	入口参数：SeqList* L, size_t i, ElemType x
*	出口参数：1
*	返回类型：int
***/
int SeqListAt(SeqList* L, size_t i, ElemType x) {
	assert(L != NULL);
	assert(L->size > 0);
	assert(i >= 0 && i <= L->size);
	L->arr[i] = x;
	return 1;
}

int main() {
	int n,x,i;
	SeqList* L;
	L = SeqListInit();
	while (1) {
		printf("----------------------------------------------------------------------------------------\n");
		printf("********1.显示顺序表的值			2.插入一个元素到顺序表的尾部***\n");
		printf("********3.插入一个元素到顺序表的头部		4.从顺序表的尾部删除一个元素***\n");
		printf("********5.从顺序表的头部删除一个元素		6.查找元素x在顺序表中的位置****\n");
		printf("********7.在顺序表指定的位置插入元素		8.删除（释放）顺序表***********\n");
		printf("********9.在顺序表中删除指定下标位置的数据	10.修改指定下标位置的数据******\n");
		printf("********11.返回顺序表的元素个数			12.退出程序********************\n");
		printf("请输入选项：");
		scanf("%d", &n);
		if (n == 15) break;
		switch (n)
		{
		case 1:
			if (SeqListPrint(L))
				printf("\n顺序表的值打印成功！\n");
			else
				printf("\n顺序表的值打印失败！\n");
			break;
		case 2:
			printf("请输入要插入的元素：");
			scanf("%d", &x);
			if (SeqListPushBack(L, x))
				printf("元素%d插入成功！\n",x);
			else
				printf("元素%d插入失败！\n",x);
			break;
		case 3:
			printf("请输入要插入的元素：");
			scanf("%d", &x);
			if (SeqListPushFront(L,x))
				printf("元素%d插入成功！\n", x);
			else
				printf("元素%d插入失败！\n", x);
			break;
		case 4:
			if (SeqListPopBack(L))
				printf("成功从尾部删除一个元素！\n");
			else
				printf("从尾部删除一个元素失败！\n");
			break;
		case 5:
			if (SeqListPopFront(L))
				printf("成功从头部删除一个元素！\n");
			else
				printf("从头部删除一个元素失败！\n");
			break;
		case 6:
			printf("请输入要查找的元素：");
			scanf("%d", &x);
			if ((i = SeqListFind(L, x)) != -1)
				printf("元素%d在顺序表中的下标是%d\n", x,i);
			else
				printf("元素%d不在顺序表中\n",x);
			break;
		case 7:
			printf("请输入要插入的位置和插入的值（1 2）：");
			scanf("%d %d", &i, &x);
			if (SeqListInsert(L, i, x))
				printf("元素%d插入位置%d成功\n",x,i);
			else
				printf("元素%d插入位置%d失败\n", x, i);
			break;
		case 8:
			if(SeqListDestory(L))
				printf("释放顺序表成功！\n");
			else
				printf("顺序表释放失败！\n");
			break;
		case 9:
			printf("请输入要删除元素的位置：");
			scanf("%d", &i);
			if (SeqListErase(L, i))
				printf("位置%d的元素删除成功！\n",i);
			else
				printf("位置%d的元素删除失败！\n",i);
			break;
		case 10:
			printf("请输入要修改的位置和修改的值（1 2）：");
			scanf("%d %d", &i, &x);
			if (SeqListAt(L, i, x))
				printf("位置%d的元素成功修改为%d\n", i, x);
			else
				printf("修改失败\n");
			break;
		case 11:
			printf("顺序表的元素个数为%d个\n", SeqListSize(L));
			break;
		default:
			break;
		}
	}
	return 0;
}