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

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

（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;

}

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