数据结构-动态数组

思路：用一个结构体作控制器，里面放数组的大小，容量，和首地址，这个数组空间可以存放任意类型的数据（void*）

动态数组的优点：随机访问元素效率高

缺点：

1 需要分配一块连续的存储区域（很大区域，有可能分配失败）

2 删除和插入某个元素效率低

DArray.h

#pragma once
#include<stdlib.h>
#include<string.h>
typedef struct DYNAMICARRAY//定义一个动态数组控制器
{
	void** address;//指向数组，这个数组可以存放任意类型
	int container;//数组容量
	int size;//数组大小
}DArray;

//比较函数指针
typedef int(*Comparison)(void* data1, void* data2);

//打印函数指针
typedef void(*PrintData)(void*);



//初始化数组
void* Init_DynamicArray();
//指定位置插入
void Insert_DynamicArray(void* darray,int pos,void* data);
//尾部插入操作
void PushBack_DynamicArray(void* darray, void* data);
//头部插入
void PushFront_DynamicArray(void* darray, void* data);
//指定位置删除
void RemoveByPos_DynamicArray(void* darray, int pos);
// 尾部删除操作
void PopBack_DynamicArray(void* darray);
//头部删除操作
void PopFront_DynamicArray(void* darray);
//值删除
void RemoveByVal_DynamicArray(void* darray, void* data, Comparison compare);
//获得指定位置元素
void* Get_DynamicArray(void* darray, int pos);
//数组大小
int Size_DynamicArray(void* darray);
//数组容量
int Capacity_DynamicArray(void* darray);
//遍历
void Print_DynamicArray(void* darray, PrintData print);
//销毁数组
void Destroy_DynamicArray(void* darray);

DArray.c

#include"DArray.h"
// 初始化数组
void* Init_DynamicArray()
{
	DArray* darray = (DArray*)malloc(sizeof(DArray));
	if (darray == NULL)
	{
		return NULL;
	}
	darray->container = 5;
	darray->size = 0;
	darray->address = (void**)malloc(sizeof(void*)*darray->container);
	return darray;

}
//指定位置插入
void Insert_DynamicArray(void* darray, int pos, void* data)
{
	if (darray == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	DArray* array = (DArray*)darray;
	//判断空间是否足够
	if (array->size == array->container)
	{
		int newcontainer = array->container * 2;//扩展2倍空间
		void** Newaddress = (void**)malloc(sizeof(void*)*newcontainer);
		//把旧的数据拷贝到新的空间
		memcpy(Newaddress, array->address, sizeof(void*)*array->container);
		//释放旧的空间
		free(array->address);
		array->address = Newaddress;
		array->container = newcontainer;
	}

	//判断pos是否越界,越界就往尾部插入
	if (pos<0 || pos>array->size)
	{
		pos = array->size;
	}
	//往后移动元素
	int i = array->size - 1;
	for (; i >= pos; --i)
	{
		array->address[i + 1] = array->address[i];
	}
	array->address[pos] = data;
	++array->size;
	return;

}
//尾部插入操作
void PushBack_DynamicArray(void* darray, void* data)
{
	if (darray == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	DArray* array = (DArray*)darray;
	Insert_DynamicArray(array, array->size, data);
	
}
//头部插入
void PushFront_DynamicArray(void* darray, void* data)
{
	if (darray == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	DArray* array = (DArray*)darray;
	Insert_DynamicArray(array, 0, data);
	

}
//指定位置删除
void RemoveByPos_DynamicArray(void* darray, int pos)
{
	if (darray == NULL)
	{
		return;
	}
	DArray* array = (DArray*)darray;
	//数据是否为空
	if (array->size == 0)
	{
		return;
	}

	//判断pos是否越界,越界就不删除
	if (pos<0 || pos>array->size-1)
	{
		return;
	}
	//往前移动元素
	int i = array->size - 1;
	for (; i > pos; ++pos)
	{
		array->address[pos] = array->address[pos+1];
	}
	--array->size;
	
}
// 尾部删除操作
void PopBack_DynamicArray(void* darray)
{
	if (darray == NULL)
	{
		return;
	}
	
	DArray* array = (DArray*)darray;
	//数组是否为空
	if (array->size == 0){
		return;
	}
	RemoveByPos_DynamicArray(array, array->size - 1);
	
}
//头部删除操作
void PopFront_DynamicArray(void* darray)
{

	if (darray == NULL)
	{
		return;
	}
	
	DArray* array = (DArray*)darray;
	//数组是否为空
	if (array->size == 0){
		return;
	}
	RemoveByPos_DynamicArray(array, 0);
	

}
//值删除
void RemoveByVal_DynamicArray(void* darray, void* data, Comparison compare)
{
	if (darray == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	DArray* array = (DArray*)darray;
	//数组是否为空
	if (array->size == 0){
		return;
	}
	//查找相同元素删除
	int i;
	for (i = 0; i < array->size; ++i)
	{
		if (compare(data, array->address[i]))
		{
			RemoveByPos_DynamicArray(array, i);
			break;
		}
	}
	
}
//获得指定位置元素
void* Get_DynamicArray(void* darray, int pos)
{
	if (darray == NULL)
	{
		return NULL;
	}
	DArray* array = (DArray*)darray;
	//数组是否为空
	if (pos < 0 || pos >= array->size){
		return NULL;
	}
	return array->address[pos];


}
//数组大小
int Size_DynamicArray(void* darray)
{
	if (darray == NULL){
		return -1;
	}
	DArray* array = (DArray*)darray;
	return array->size;

}
//数组容量
int Capacity_DynamicArray(void* darray)
{
	if (darray == NULL){
		return -1;
	}
	DArray* array = (DArray*)darray;
	return array->container;

}

//遍历
void Print_DynamicArray(void* darray, PrintData print)
{
	if (darray == NULL){
		return;
	}
	DArray* array = (DArray*)darray;
	int i = 0;
	for (; i < array->size; ++i)
	{
		print(array->address[i]);
	}
	
}

//销毁数组
void Destroy_DynamicArray(void* darray)
{

	if (darray == NULL){
		return;
	}
	free(darray);

}

main.c

#define _CRT_SECURE_NO_WARNINGS
#include "DArray.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct STUDENT
{
	char name[100];
	int age;

}student;


//比较函数指针
int MyComparison(void* data1, void* data2)
{
	student* s1 = (student*)data1;
	student* s2 = (student*)data2;
	return strcmp(s1->name, s2->name)==0 || s1->age==s2->age;
}

//打印函数指针
void MyPrintData(void* data)
{
	student* s1 = (student*)data;
	printf("Name:%s,Age:%d\n", s1->name, s1->age);
	
}

int main()
{
	//初始化数组
	void* darray=Init_DynamicArray();

	student s1 = { "zhangsan", 0 };
	student s2 = { "lixi", 1 };
	student s3 = { "wangwu",2 };
	student s4 = { "zhaoliu", 3 };
	student s5 = { "niuqi", 4 };
	student s6 = { "wuba", 5 };

	//尾部插入操作
	PushBack_DynamicArray(darray, &s2);
	PushBack_DynamicArray(darray, &s1);
	
	//头部插入
	PushFront_DynamicArray(darray, &s3);
	PushFront_DynamicArray(darray, &s4);
	
	//指定位置插入
	Insert_DynamicArray(darray, 4, &s5);
	Insert_DynamicArray(darray, 5, &s6);

	//打印
	Print_DynamicArray(darray, MyPrintData);
	printf("------------下面开始删除元素-----------\n");

	//指定位置删除
	RemoveByPos_DynamicArray(darray, 1);
	RemoveByPos_DynamicArray(darray, 0);

	// 尾部删除操作
	PopBack_DynamicArray(darray);

	//头部删除操作
	PopFront_DynamicArray(darray);

	//值删除
	RemoveByVal_DynamicArray(darray, &s1, MyComparison);
	

	//获得指定位置元素
	student* S1 = (student*)Get_DynamicArray(darray, 0);
	printf("Name:%s,Age:%d\n", S1->name, S1->age);

	//数组大小
	int size=Size_DynamicArray(darray);
	printf("%d\n",size);
	//数组容量
	int Cap=Capacity_DynamicArray(darray);
	printf("%d\n", Cap);
	
	//销毁数组
	Destroy_DynamicArray(darray);
	
	getchar();
	return 0;
}

打印结果：