数据结构与算法入门

动态数组模型分析

#include <stdio.h>
#include <malloc.h>
typedef unsigned int UI;

struct Donshuzu {
	int* pShuzuTou;   // 首地址
	UI iRonliang;     // 容量
	UI iShuliang;     // 已存储的数量
};
void ChuShiHua(struct Donshuzu*);
void KaipiKJ(struct Donshuzu*);
void Zengjia(struct Donshuzu*, int);
/*
传递普通而不是指针的特点：
1、传递地址效率高一点；
2、在不改变值只是要输出的时候一般不用地址；
3、指针传入的是地址，函数里面写"->"；直接传入，函数里面写"."(在主函数里面写".")。
*/
void ShuChu(struct Donshuzu);
void Zengjiazhong(struct Donshuzu*, int, UI);
void ShanChuWei(struct Donshuzu*);
void ShanChuAll(struct Donshuzu*);
void ShiFangSZ(struct Donshuzu*);
void ShanChuZhong(struct Donshuzu*, UI);

void ChuShiHua(struct Donshuzu* pstshuzu)
{
	pstshuzu->iRonliang = 5;
	pstshuzu->pShuzuTou = (int*)malloc(sizeof(int) * pstshuzu->iRonliang);
	pstshuzu->iShuliang = 0;
}
void KaipiKJ(struct Donshuzu* pstshuzu)
{
	// 判断是否满了
	if (pstshuzu->iRonliang == pstshuzu->iShuliang)
	{
		// 容量变大
		pstshuzu->iRonliang += 10;
		// 申请空间
		int* pTemp = (int*)malloc(sizeof(int) * pstshuzu->iRonliang);
		// 将原数据复制进新空间
		for (UI i = 0; i < pstshuzu->iShuliang; i++)
			pTemp[i] = pstshuzu->pShuzuTou[i];
		// 将原空间进行释放
		free(pstshuzu->pShuzuTou);
		// 将数组头指针指向新空间
		pstshuzu->pShuzuTou = pTemp;
	}
}
void Zengjia(struct Donshuzu* pstshuzu, int iShujv)
{
	// 这里传一级指针就可以，因为传入的pstshuzu是地址，只要修改地址就能修改取值。
	// 比如传入Zengjia的是地址，传入KaipiKJ的值和前者的地址正好的相同的。不过传二级三级等等也行
	KaipiKJ(pstshuzu);
	// 数据装进去
	pstshuzu->pShuzuTou[pstshuzu->iShuliang] = iShujv;
	// 已存储变量++
	pstshuzu->iShuliang++;
}
void ShuChu(struct Donshuzu pstshuzu)
{
	if (&pstshuzu == NULL)
	{
		printf("参数错误\n");
		return;
	}
	printf("容量：%u 已存数量：%u\n", pstshuzu.iRonliang, pstshuzu.iShuliang);
	printf("数据：");
	for (UI i = 0; i < pstshuzu.iShuliang; i++)
		printf("%d ", pstshuzu.pShuzuTou[i]);
	printf("\n");
}
void Zengjiazhong(struct Donshuzu* pstshuzu, int iShujv, UI iXiabiao)
{
	// 参数合法性检测
	if (NULL == pstshuzu) {
		printf("参数错误\n");
		return;
	}
	KaipiKJ(pstshuzu);
	// 当下标大于数量，就插入在最后一个位置
	if (iXiabiao > pstshuzu->iShuliang)
		iXiabiao = pstshuzu->iShuliang;
	// 向后挪
	for (UI i = pstshuzu->iShuliang; i > iXiabiao; i--)
		pstshuzu->pShuzuTou[i] = pstshuzu->pShuzuTou[i - 1];
	// 将数据赋到指定位置
	pstshuzu->pShuzuTou[iXiabiao] = iShujv;
	// 数量增加1
	pstshuzu->iShuliang++;
}
void ShanChuWei(struct Donshuzu* pstshuzu)
{
	if (NULL == pstshuzu)
		return;
	pstshuzu->iShuliang--;
}
void ShanChuAll(struct Donshuzu* pstshuzu)
{
	if (NULL == pstshuzu)
		return;
	pstshuzu->iShuliang = 0;
}
void ShiFangSZ(struct Donshuzu* pstshuzu)
{
	if (NULL == pstshuzu)
		return;
	pstshuzu->iShuliang = 0;
	pstshuzu->iRonliang = 0;
	free(pstshuzu->pShuzuTou);
	pstshuzu->pShuzuTou = NULL;
}
void ShanChuZhong(struct Donshuzu* pstshuzu, UI iWeiZhi)
{
	if (NULL == pstshuzu)
		return;
	if (pstshuzu->iShuliang <= iWeiZhi)
	{
		ShanChuWei(pstshuzu);
		return;
	}
	// 后边的往前移动
	for (UI i = iWeiZhi - 1; i < pstshuzu->iShuliang - 1; i++)
		pstshuzu->pShuzuTou[i] = pstshuzu->pShuzuTou[i + 1];
	// 数量-1
	pstshuzu->iShuliang--;
}

int main()
{
	struct Donshuzu stDshuzu;

	ChuShiHua(&stDshuzu);

	Zengjia(&stDshuzu, 1);
	Zengjia(&stDshuzu, 2);
	Zengjia(&stDshuzu, 3);
	Zengjia(&stDshuzu, 4);
	Zengjia(&stDshuzu, 5);
	Zengjia(&stDshuzu, 6);
	Zengjia(&stDshuzu, 7);
	Zengjia(&stDshuzu, 8);
	Zengjia(&stDshuzu, 9);

	Zengjiazhong(&stDshuzu, 3, 24);
	ShuChu(stDshuzu);

	ShanChuZhong(&stDshuzu, 3);
	ShuChu(stDshuzu);

	ShanChuWei(&stDshuzu);
	ShanChuWei(&stDshuzu);
	ShuChu(stDshuzu);

	ShanChuAll(&stDshuzu);
	ShuChu(stDshuzu);

	ShiFangSZ(&stDshuzu);
	ShuChu(stDshuzu);

	ChuShiHua(&stDshuzu);
	Zengjia(&stDshuzu, 4);
	Zengjia(&stDshuzu, 6);
	ShuChu(stDshuzu);

	free(stDshuzu.pShuzuTou);

	return 0;
}
/*
容量：15 已存数量：10
数据：1 2 3 4 5 6 7 8 9 3
容量：15 已存数量：9
数据：1 2 4 5 6 7 8 9 3
容量：15 已存数量：7
数据：1 2 4 5 6 7 8
容量：15 已存数量：0
数据：
容量：0 已存数量：0
数据：
容量：5 已存数量：2
数据：4 6
*/