[C++知识库]动态法实现顺序表（C/C++）

写在最前面：

1. 这是顺序表的另一种定义方法，相对于静态法可以更好实现内存管理；
2. 此篇实现了“动态法实现顺序表”的定义、初始化、扩容、销毁顺序表的操作；对顺序表的一些常规操作因在静态法实现顺序表（C++/C）已经实现便不再重复。

/*动态法实现顺序表的基本操作*/
#include<stdio.h>
#include<stdlib.h> //malloc函数与free函数

#define InitSize 5 //顺序表的初始容量
typedef int Elemtype;
typedef int status;

/*使用动态法定义顺序表，初始化*/
typedef struct
{
	Elemtype* data;
	int maxsize;//动态法实现顺序表的容量最大值
	int length;//记录顺序当前的存储的数量
}SeqList;

status InitSeqList(SeqList& L)
{//为顺序表开辟一片连续的空间
	L.data = (Elemtype*)malloc(sizeof(Elemtype) * InitSize);
	if (!L.data)
		return false;
	L.length = 0;
	L.maxsize = InitSize;
	return true;
}

status IncreaseSize(SeqList& L, int len) {//扩容
	Elemtype* p = L.data;
	L.data = (Elemtype*)malloc((L.maxsize + len) * sizeof(Elemtype)); //申请更大的存储空间
	if (!L.data)
		return false;
	for (int i = 0; i < L.length; i++)
		L.data[i] = p[i];
	L.maxsize += len;
	free(p);//记得指针使用之后要及时释放
	return true;
}

status SeqListInsert(SeqList& L, int i, Elemtype e)/*在顺序表的尾部插入元素e*/
{
	if (i<1 || i>L.length + 1)
		return false;
	if (L.length == L.maxsize)
		return false;
	for (int j = L.length; j >= i; j--)
	{
		L.data[j] = L.data[j - 1];
	}
	L.data[i - 1] = e;
	L.length++;//插入元素后，顺便表的长度加1
	return true;
}

status PrintSeqList(SeqList L)
{//打印顺序表
	if (L.length != 0)
	{
		for (int i = 0; i < L.length - 1; i++)
			printf("%d  ", L.data[i]);
		printf("%d\n", L.data[L.length - 1]);
	}
	return 0;
}

void DestroyList(SeqList& L)
{//销毁顺序表
	free(L.data);
	L.data = NULL;
	L.length = 0;
	L.maxsize = 0;
}

int main()
{
	SeqList L;
	InitSeqList(L);
	for (int i = 1; i <= 5; i++)
	{
		SeqListInsert(L, i, i);
	}
	printf("此时的顺序表如下：\n");
	PrintSeqList(L);
	printf("扩容前顺序表的最大容量为%d\n", L.maxsize);
	IncreaseSize(L, 5);//给顺序表扩大容量
	printf("扩容后顺序表的最大容量为%d", L.maxsize);
	DestroyList(L);
	return 0;
}