数据结构【顺序表的动态分配】【保姆级】【一】

数据表动态分配代码实现

头文件以及所定义的初始值

#include <stdlib.h>
#include <stdio.h>
#define InitSize 10

• <stdlib.h>是malloc所需要头文件
• <stdio.h>是printf所需要的头文件
• InitSize:顺序表初始长度以及最大存储元素的数量

定义一个顺序表

//定义顺序表
typedef struct
{
	int* data;
	int maxSize;
	int length;
}sqList;

• int* data:定义一个指针 这个指针将来的作用就是用来存放开辟空间的首元素地址
• int maxSize:顺序表所存放元素的最大数量
• int length:顺序表的最大长度

初始化顺序表

//初始化顺序表
void initList(sqList* sq)
{
	sq->data = (int*)malloc(InitSize * sizeof(int));
	sq->maxSize = InitSize;
	sq->length = 0;
}

• malloc作用是在内存上开辟空间,此处开辟了10*4=40个字节的空间,也就是可以存放10个元素

测试初始化顺序表

int main()
{
	//声明一个顺序表
	sqList L;
	//初始化顺序表
	initList(&L);
	//向开辟的空间内添加元素
	int i = 0;
	for (i = 0; i < InitSize; i++)
	{
		//*(L.data + i) = i + 1;
		L.data[i] = i + 1;
		L.length++;
	}
	//遍历查看顺序表数据
	for (i = 0; i < InitSize; i++)
	{
		printf("%d ", *(L.data + i));
	}
    //顺序表的maxSize和length
    printf("\n%d %d", L.maxSize, L.length);
}

执行结果展示

• 顺序表中存放了10个元素,顺序表的最大元素数量maxSize为10，长度为10

内存图

扩容顺序表

//扩容顺序表
void IncreaseList(sqList* L,int len)
{
	int* p = L->data;                      //存方原来顺序表的首地址，
	L->data = (int*)malloc((L->maxSize + len) * sizeof(int));//根据新增长度重新开辟一段连续的地址空间构建新的顺序表
	if (L->data == NULL) {
		return 1;
	}
	for (int i = 0; i < L->maxSize; i++)   	//将原来表中内容拷贝到新表中
		L->data[i] = p[i];
	L->maxSize = L->maxSize + len;         	//更新当前表的最大容量
	free(p);                      			//释放原来表的内存空间
}

测试扩容

int main()
{
	
	//声明一个顺序表
	sqList L;
	//初始化顺序表
	initList(&L);
	//向开辟的空间内添加元素
	int i = 0;
	for (i = 0; i < InitSize; i++)
	{
		//*(L.data + i) = i + 1;
		L.data[i] = i + 1;
		L.length++;
	}
	//遍历查看顺序表数据(扩容前的数据)
    printf("扩容前:\n");
	for (i = 0; i < InitSize; i++)
	{
		printf("%d ", *(L.data + i));
	}
	printf("\n扩容前:maxSize=%d length=%d", L.maxSize, L.length);
	//动态扩展顺序表 需要传入顺序表的地址，还有扩容的大小
	int increaseNum = 5;
	IncreaseList(&L, increaseNum);
	for (i = L.maxSize- increaseNum; i < L.maxSize; i++)
	{
		//其余元素值值为0
		L.data[i] = i+1;
		L.length++;
	}
	printf("\n增加后的数组元素遍历结果:len=%d\n",L.length);
	for (i = 0; i < L.maxSize; i++)
	{
		printf("%d ", *(L.data + i));
	}
    printf("\n%d %d", L.maxSize, L.length);
	return 0;
}

运行图

• 由图可知，扩容后顺序表可添加15个元素，比原来多了5个元素，达到了扩容的效果

内存图

顺序表动态分配完整代码

#include <stdio.h>
#include <stdlib.h>
#define InitSize 10
//定义顺序表
typedef struct
{
	int* data;
	int maxSize;
	int length;
}sqList;
//初始化顺序表
void initList(sqList* sq)
{
	sq->data = (int*)malloc(InitSize * sizeof(int));
	sq->maxSize = InitSize;
	sq->length = 0;
}
//扩容顺序表
void IncreaseList(sqList* L,int len)
{
	int* p = L->data;                      //存方原来顺序表的首地址，
	L->data = (int*)malloc((L->maxSize + len) * sizeof(int));//根据新增长度重新开辟一段连续的地址空间构建新的顺序表
	if (L->data == NULL) {
		return 1;
	}
	for (int i = 0; i < L->maxSize; i++)   //将原来表中内容拷贝到新表中
		L->data[i] = p[i];
	L->maxSize = L->maxSize + len;         //更新当前表的最大容量
	free(p);                      //释放原来表的内存空间
}
int main()
{

	//声明一个顺序表
	sqList L;
	//初始化顺序表
	initList(&L);
	//向开辟的空间内添加元素
	int i = 0;
	for (i = 0; i < InitSize; i++)
	{
		//*(L.data + i) = i + 1;
		L.data[i] = i + 1;
		L.length++;
	}
	//遍历查看顺序表数据(扩容前的数据)
	printf("扩容前数组遍历结果:maxSize=%d length=%d\n", L.maxSize, L.length);
	for (i = 0; i < InitSize; i++)
	{
		printf("%d ", *(L.data + i));
	}
	//动态扩展顺序表 需要传入顺序表的地址，还有扩容的大小
	int increaseNum = 5;
	IncreaseList(&L, increaseNum);
	for (i = L.maxSize - increaseNum; i < L.maxSize; i++)
	{
		//其余元素值值为0
		L.data[i] = i + 1;
		L.length++;
	}
	printf("\n增加后的数组元素遍历结果:maxSize=%d length=%d\n", L.maxSize,L.length);
	for (i = 0; i < L.maxSize; i++)
	{
		printf("%d ", *(L.data + i));
	}
	return 0;
}

本次的博客内容就到这里了，如果本篇博客对您有帮助的话还请一键三连，您的支持就是我的最大动力啊!!