动态数组--C语言版

0.动态数组结构体创建

struct dynamicArray
{
	void** pArray;  //维护真实在堆区创建的数组指针

	int m_capacity; //数组的容量

	int m_size;    //数组的大小
};

1.动态数组初始化

struct dynamicArray* initDynamicArray(int capacity)
{
	if (capacity <= 0)
	{
		return NULL;
	}
	//给数组分配空间
	struct dynamicArray* array = malloc(sizeof(struct dynamicArray));

	if (array == NULL)
	{
		return NULL;
	}


	array->m_capacity = capacity;   //容量
	array->m_size = 0;    //当前大小
	//维护在堆区的数组指针
	array->pArray = malloc(sizeof(void*) * array->m_capacity);

	return array;
}

2.动态数组插入元素

1. 参数1：需要操作的数组
2. 参数2：插入的位置
3. 参数3：插入的值

void insertDynamicElement(struct dynamicArray* array, int pos, void* data)
{
	if (array == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	//考虑插入的无效位置,因为数组元素是挨着的，中间不能空
	if (pos<0 || pos>array->m_size)
	{
		pos = array->m_size;  //如果插入位置不符合规范，让插入位置强制为数组末尾
	}
	//如果数组已满，需要动态扩展容量
	if (array->m_size == array->m_capacity)
	{
		//申请更大的空间
		int newCapacity = array->m_capacity * 2;
		//新的动态数组
		void** newDynamicArray = malloc(sizeof(void*) * newCapacity);
		//将原来的数据拷贝到新空间下
		memcpy(newDynamicArray, array->pArray, sizeof(void*) * array->m_size);
		//释放原有的空间
		free(array->pArray);
		//更新新空间的指向
		array->pArray = newDynamicArray;
		//更新新容量
		array->m_capacity = newCapacity;
	}
	//移动数组中的元素
	//如果插入的位置是最后一个位置，即尾插，下面的代码不执行
	for (int i = array->m_size - 1; i >= pos; i--)
	{
		array->pArray[i + 1] = array->pArray[i];
	}
	//插入新的元素
	array->pArray[pos] = data;
	//更新大小
	array->m_size++;
}

3.动态数组删除元素

（1）按照位置进行删除

void removeDynamicElementByPos(struct dynamicArray* array, int pos)
{
	if (array == NULL)
	{
		return;
	}
	if (pos<0 || pos >= array->m_size)
	{
		pos = array->m_size - 1; //删除最后一个元素
	}

	for (int i = pos; i < array->m_size - 1; i++)
	{
		array->pArray[i] = array->pArray[i + 1];
	}
	array->m_size--;
}

（2）按照值进行删除

void removeDynamicElementByValue(struct dynamicArray* array, void* data, int(*dataCompare)(void*, void*))
{
	if (array == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	int res = 0;
	for (int i = 0; i < array->m_size; i++)
	{
		res = dataCompare(data, array->pArray[i]);
		if (res == 1)
		{
			//此时的为需要删除的位置
			for (int j = i; j < array->m_size-1; j++)
			{
				array->pArray[j] = array->pArray[j + 1];
			}
			array->m_size--;
			break;
			return;
		}
	}
	if (res == 0)
	{
		printf("查无此信息, 无法删除\n");
	}
	
}


int dataCompare(void* data1, void* data2)
{
	struct Person* p1 = data1;
	struct Person* p2 = data2;
	if (p1->name == p2->name && p1->age == p2->age)
	{
		return 1;
	}
	else return -1;
}

4.销毁动态数组

void deleteDynamicArray(struct dynamicArray* array)
{
	if (array == NULL)
	{
		return;
	}
	//一层一层销毁
	//先把内层的指针进行销毁
	if (array->pArray != NULL)
	{
		free(array->pArray);
		array->pArray = NULL;
	}
	//再把外层指针进行销毁
	free(array);
	array = NULL;
	printf("动态数组销毁成功\n");
}

5.遍历动态数组

void printArray(struct dynamicArray* array, void(*myPrint)(void*))
{
	if (array == NULL)
	{
		return;
	}
	if (myPrint == NULL)
	{
		return;
	}
	for (int i = 0; i < array->m_size; i++)
	{
		//由于不知道数组中元素的类型，采用回调函数，采用自定义的数据类型
		(*myPrint)(array->pArray[i]);
	}
	printf("\n");
}

void myPrint(void* data)
{
	struct Person* p = data;
	printf("姓名:%s\t年龄:%d\n", p->name, p->age);
}

6.测试代码

//测试的结构
struct Person
{
	char name[64];
	int age;
};

void test01()
{
//初始化动态数组
	struct dynamicArray* array = initDynamicArray(5);
	printf("插入前:容量:%d, 大小:%d\n", array->m_capacity, array->m_size);
	struct Person p1 = { "亚瑟", 10 };
	struct Person p2 = { "张飞", 26 };
	struct Person p3 = { "关羽", 28 };
	struct Person p4 = { "项羽", 25 };
	struct Person p5 = { "宫本", 45 };
	struct Person p6 = { "妲己", 18 };
	//插入每一个元素
	//预测打印结果:  妲己 张飞 宫本 亚瑟 项羽 关羽
	insertDynamicElement(array, 0, &p1);
	insertDynamicElement(array, 0, &p2);
	insertDynamicElement(array, -1, &p3);
	insertDynamicElement(array, 2, &p4);
	insertDynamicElement(array, 1, &p5);
	insertDynamicElement(array, 0, &p6);
	//按照位置进行删除
	//removeDynamicElement(array, 2);
	//按照值进行删除
	removeDynamicElementByValue(array, &p3, dataCompare);
	printf("插入后:容量:%d, 大小:%d\n", array->m_capacity, array->m_size);
	//打印输出结果
	printArray(array, myPrint);
	deleteDynamicArray(array);
}