数据结构-顺序表（动态分配存储空间）

（1）顺序表的结构定义：

结构型定义：（动态分配存储空间）

/** * 动态分配存储空间 */
#define InitSize 100 //动态分配存储空间时，不限制最大，只给定一个初始值
#define ListIncrement 10 //分配增量
typedef	struct
{
   
	int* data;   //指向所分配的存储空间的基地址
	int length;  //当前的长度，已经存储元素后占用的长度
	int listsize;  //当前分配的存储空间的大小，若不足，可再进行分配
}SeqList;

初始化顺序表

/** * 初始化顺序表，动态分配存储空间 * @param L 顺序表L，引用型 */
void Init_SeqList(SeqList& L) {
   
	L.data = (int*)malloc(sizeof(int) * InitSize);
	L.length = 0;
	L.listsize = InitSize;
}

创建顺序表

/** * 创建顺序表时，动态分配存储空间，当需要插入的元素个数大于初始的空间大小时，可继续申请空间 * @param L 顺序表L，引用型 * @param n 需要插入的元素个数 * @return 0表示失败，1表示成功 */
int Create_SeqList(SeqList& L, int n) {
   
	if (n > L.listsize)
	{
   
		/* 指针名=(数据类型*)realloc(要改变内存大小的指针名，新的大小),在原有的空间上增加空间 */
		int* newbase = (int*)realloc(L.data, sizeof(int) * (L.listsize + ListIncrement));
		if (newbase)
		{
   
			L.data = newbase;   //新基址
			L.listsize += ListIncrement;  //增加存储容量
		}
		else {
   
			return 0;
		}
	}
	/* 存入数据 */
	for (int i = 0; i < n; ++i)
	{
   
		scanf_s("%d", &L.data[i]);
	}
	L.length = n;
	return 1;
}

注意：动态分配存储空间时，如果原先分配的存储空间不足时可以继续申请空间。按照之前设置的增量来增加存储容量。

输出顺序表

/** * 输出顺序表 * @param L 顺序表 */
void Print_SeqList(SeqList L) {
   
	for (int i = 0; i < L.length; i++)
		printf("%d ", L.data[i]);
	printf("\n");
}

在顺序表中插入元素

/** * 在动态分配存储空间的顺序表中插入一个元素 * @param L 顺序表，引用型，动态分配存储空间 * @param location 需要插入在第location个位置 * @param elem 插入的元素值 * @return 1表示插入成功，0表示插入失败 */
int InsertElem_SeqList(SeqList& L, int location, int elem) {
   
	if (location<1 || location>L.length + 1)
	{
   
		return 0;
	}
	if (L.length >= L.listsize)		//当前存储空间已满，增加分配
	{
   
		int* newbase = (int*)realloc(L.data, sizeof(int) * (L.listsize + ListIncrement));
		if (newbase)
		{
   
			L.data = newbase;
			L.listsize += ListIncrement;
		}
	}
	for (int i = L.length; i >= location; --i)
	{
   
		L.data[i] = L.data[i - 1];
	}
	L.data[location - 1] = elem;
	L.length++;
	return 1;
}

在顺序表中删除元素

/** * 删除指定位置的元素，同时将删除的数据带出 * @param L 顺序表L，引用类型 * @param location 删除第location个位置的元素 * @param elem 引用型，用于带出删除的元素值 * @return 返回1表示插入成功，返回0表示插入失败 */
int DeleteElem_SeqList(SeqList& L, int location, int& elem) {
   
	if (location<1 || location>L.length)  //判断删除的位置是否有效
		return 0;
	elem = L.data[location - 1];
	for (int i = location; i < L.length; ++i)   //将元素从前往后一次向前移一个位置
		L.data[i - 1] = L.data[i];
	L.length--;
	return 1;
}

完整测试函数

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
/** * 动态分配存储空间 */
#define InitSize 100 //动态分配存储空间时，不限制最大，只给定一个初始值
#define ListIncrement 10 //分配增量
typedef	struct
{
   
	int* data;   //指向所分配的存储空间的基地址
	int length;  //当前的长度，已经存储元素后占用的长度
	int listsize;  //当前分配的存储空间的大小，若不足，可再进行分配
}SeqList;

/** * 初始化顺序表，动态分配存储空间 * @param L 顺序表L，引用型 */
void Init_SeqList(SeqList& L) {
   
	L.data = (int*)malloc(sizeof(int) * InitSize);
	L.length = 0;
	L.listsize = InitSize;
}

/** * 创建顺序表时，动态分配存储空间，当需要插入的元素个数大于初始的空间大小时，可继续申请空间 * @param L 顺序表L，引用型 * @param n 需要插入的元素个数 * @return 0表示失败，1表示成功 */
int Create_SeqList(SeqList& L, int n) {
   
	if (n > L.listsize)
	{
   
		/* 指针名=(数据类型*)realloc(要改变内存大小的指针名，新的大小),在原有的空间上增加空间 */
		int* newbase = (int*)realloc(L.data, sizeof(int) * (L.listsize + ListIncrement));
		if (newbase)
		{
   
			L.data = newbase;   //新基址
			L.listsize += ListIncrement;  //增加存储容量
		}
		else {
   
			return 0;
		}
	}
	/* 存入数据 */
	for (int i = 0; i < n; ++i)
	{
   
		scanf_s("%d", &L.data[i]);
	}
	L.length = n;
	return 1;
}

/** * 输出顺序表 * @param L 顺序表 */
void Print_SeqList(SeqList L) {
   
	for (int i = 0; i < L.length; i++)
		printf("%d ", L.data[i]);
	printf("\n");
}

/** * 在动态分配存储空间的顺序表中插入一个元素 * @param L 顺序表，引用型，动态分配存储空间 * @param location 需要插入在第location个位置 * @param elem 插入的元素值 * @return 1表示插入成功，0表示插入失败 */
int InsertElem_SeqList(SeqList& L, int location, int elem) {
   
	if (location<1 || location>L.length + 1)
	{
   
		return 0;
	}
	if (L.length >= L.listsize)		//当前存储空间已满，增加分配
	{
   
		int* newbase = (int*)realloc(L.data, sizeof(int) * (L.listsize + ListIncrement));
		if (newbase)
		{
   
			L.data = newbase;
			L.listsize += ListIncrement;
		}
	}
	for (int i = L.length; i >= location; --i)
	{
   
		L.data[i] = L.data[i - 1];
	}
	L.data[location - 1] = elem;
	L.length++;
	return 1;
}

/** * 删除指定位置的元素，同时将删除的数据带出 * @param L 顺序表L，引用类型 * @param location 删除第location个位置的元素 * @param elem 引用型，用于带出删除的元素值 * @return 返回1表示插入成功，返回0表示插入失败 */
int DeleteElem_SeqList(SeqList& L, int location, int& elem) {
   
	if (location<1 || location>L.length)  //判断删除的位置是否有效
		return 0;
	elem = L.data[location - 1];
	for (int i = location; i < L.length; ++i)   //将元素从前往后一次向前移一个位置
		L.data[i - 1] = L.data[i];
	L.length--;
	return 1;
}

/** * 主函数 * @return 结束 */
int main() {
   

	/** * 创建动态分配存储空间的L时 */
	SeqList L;
	Init_SeqList(L);

	/* 创建顺序表――输入数据 */
	int n;
	printf("输入需要创建的表的长度：\n");
	scanf_s("%d", &n);
	printf("输入表中的元素：\n");
	Create_SeqList(L, n);
	printf("创建顺序表完成:\n");
	Print_SeqList(L);

	/* 插入元素――指定插入位置和值 */
	int elemLoc;
	int elem;
	printf("输入需要插入的位置和元素的值:\n");
	scanf_s("%d %d", &elemLoc, &elem);
	InsertElem_SeqList(L, elemLoc, elem);
	printf("插入数据完成:\n");
	Print_SeqList(L);

	/* 删除元素――指定删除位置 */
	printf("输入需要删除的位置:\n");
	scanf_s("%d", &elemLoc);
	DeleteElem_SeqList(L, elemLoc, elem);
	printf("删除数据完成：\n");
	Print_SeqList(L);
	printf("删除的元素为：%d\n", elem);

	return 0;

}

创作不易，喜欢的话加个关注点个赞，谢谢谢谢谢谢。