自己实现一个动态数组(C语言)

chenweimin 2月前 ⋅ 457 阅读
  1. 在C语言中系统库没有提供可变数组,自己实现一个动态数组
  2. 编写头文件,创建DynamicArray.h 
    #if 1
    /*
    数组实现动态数组
    */
    #pragma once
    #include <stdlib.h>
    #include <string.h>
    /*真假枚举类*/
    enum  _Bool_
    {
    	//假
    	_FALSE,
    	//真
    	_TRUE
    };
    /*
    动态数组结构体
    */
    typedef struct DynamicArray {
    	//数据指针数组
    	void** data;
    	//容量
    	int capacity;
    	//数据大小
    	int size;
    } DynamicArray;
    
    /*创建动态数组*/
    DynamicArray* creat_array(int capacity);
    
    /*
    插入数据 
    array 动态数据指针
    pos 插入位置 索引 如果插入索引位置不正确 默认插入规则为插入到最尾部
    data 插入数据指针
    */
    int insert_array_data(DynamicArray * array,int pos,void * data);
    
    
    /*遍历动态数组*/
    void foreach_array_data(DynamicArray* array, void(*print_array)(void* iteam));
    
    /*根据索引获取数据*/
    void* get_array_data(DynamicArray* array, int pos);
    
    /*销毁动态数组*/
    void destroy_array(DynamicArray* array);
    
    /*根据索引下标删除数据*/
    int delete_array_data(DynamicArray* array, int pos);
    
    /*清空数组*/
    int clean_array(DynamicArray* array);
    
    /*获取数组大小*/
    int size_array(DynamicArray* array);
    #endif 
    ​
  3. 编写实现 DynamicArray.c
    #if 1
    #pragma once
    #include "DynamicArray.h"
    
    
    /*
    创建动态数组
    */
    DynamicArray* creat_array(int capacity) {
    
    	//在堆区分配动态数据结构体内存
    	DynamicArray * array = malloc(sizeof(DynamicArray));
    	if (NULL==array) {
    		return NULL;
    	}
    
    	//在堆区分配存放数据指针数组内存
    	void ** _data = malloc(sizeof(void*) * capacity);
    
    	if (NULL==array)
    	{
    		return NULL;
    	}
    	//初始化动态数组
    	array->data = _data;
    	array->capacity = capacity;
    	array->size = 0;
    
    	return array;
    }
    
    /*
    插入数据
    array 动态数据指针
    pos 插入位置 索引 如果插入索引位置不正确 默认插入规则为插入到最尾部
    data 插入数据指针
    */
    int insert_array_data(DynamicArray* array, int pos, void* data) {
    	if (NULL==array) {
    		return _FALSE;
    	}
    	if (NULL == data) {
    		return _FALSE;
    	}
    	//插入数据前判断容量是否足够 如果不够则以两倍容量扩容
    	if (array->capacity==array->size)
    	{
    		int new_capacity = (array->capacity) * 2;
    		//把原来内存中的数据移动到新分配的内存中
    		void ** new_data=malloc(sizeof(void*) * new_capacity);
    		memcpy(new_data, array->data, sizeof(void*) * (array->size));
    		//释放原来数组存放数据内存空间
    		free(array->data);
    		array->data = NULL;
    		//关联新配内存
    		array->data = new_data;
    	}
    
    	//判断插入索引是否是有效位置 如果不是则按照默认规则 插入到尾部
    	if (pos <0||pos>array->size)
    	{
    		pos = array->size;
    	}
    	//如果插入位置在索引有效位置 并且不是在尾部位置 则插入到指定位置后需要把后面元素后移
    	for (int i = array->size -1; i >= pos; i--)
    	{
    		//后移数据
    		(array->data)[i+1] = (array->data)[i];
    		
    	}
    	//插入数据
    	(array->data)[pos] = data;
    	(array->size)++;
    	return _TRUE;
    }
    
    
    /*遍历动态数组*/
    void foreach_array_data(DynamicArray* array, void(*print_array)(void* iteam)) {
    	if (NULL==array)
    	{
    		return;
    	}
    	if (NULL== print_array)
    	{
    		return;
    	}
    
    	for (int  i = 0; i < array->size; i++)
    	{
    		print_array((array->data)[i]);
    	}
    
    }
    
    
    /*获取索引位置的元素*/
    void* get_array_data(DynamicArray* array, int pos) {
    	if (NULL==array)
    	{
    		return NULL;
    	}
    	//超出索引位置
    	if (pos <0||pos>array->size-1)
    	{
    		return NULL;
    	}
    	return array->data[pos];
    }
    
    
    
    void destroy_array(DynamicArray* array) {
    	if (NULL == array)
    	{
    		return NULL;
    	}
    	//释放堆空间数据存储指针的空间
    	free(array->data);
    	array->data = NULL;
    	//释放动态数据结构体堆空间
    	free(array);
    	array = NULL;
    }
    
    /*根据索引下标删除数据*/
    int delete_array_data(DynamicArray* array, int pos) {
    	if (NULL == array)
    	{
    		return _FALSE;
    	}
    
    	if (pos <0 || pos>array->size-1)
    	{
    		return _FALSE;
    	}
    	//删除索引所在数据 后面数据向前移动
    	for (int i = pos; i <array->size -1;i++)
    	{
    		
    	 (array->data)[i] = (array->data)[i + 1];
    	}
    	//更新数组大小
    	(array->size)--;
    }
    
    /*清空数组*/
    int clean_array(DynamicArray* array) {
    	if (NULL== array)
    	{
    		return _FALSE;
    	}
    	array->data = NULL;
    	array->size = 0;
    	return _TRUE;
    }
    
    /*获取数组大小*/
    int size_array(DynamicArray* array) {
    	if (NULL == array)
    	{
    		return -1;
    	}
    	return array->size;
    }
    #endif​
  4. 测试动态数组 TestDynamicArray.c
    #if 1
    #pragma once
    #include "DynamicArray.h"
    #include <stdio.h>
    typedef struct Person {
    	char name[64];
    	int age;
    }Person;
                                                 
    
    void test_print_array(void * data) {
    
    	Person* p = data;
    	printf("数据的名称为:%s,年龄为:%d\n", p->name, p->age);
    }
    int main(int argc, char* argv[]) {
    
    	//创建一个动态数组
    	DynamicArray * array = creat_array(5);
    	//插入数据
    	Person p = { "孙悟空",500 };
    	Person p1 = { "猪八戒",1500 };
    	Person p2 = { "沙悟净",2500 };
    	Person p3 = { "白龙马",3500 };
    	Person p4 = { "唐僧",4500 };
    	Person p5 = { "玉皇大帝",5500 };
    	Person p6 = { "如来佛祖",6500 };
    
    
    	insert_array_data(array, 0, &p);
    	insert_array_data(array, 1, &p1);
    	insert_array_data(array, 2, &p2);
    	insert_array_data(array, 3, &p3);
    	insert_array_data(array, 4, &p4);
    	insert_array_data(array, 1, &p5);
    	insert_array_data(array, 0, &p6);
    
    	foreach_array_data(array, test_print_array);
    	//如来佛祖 孙悟空 玉皇大帝 猪八戒 沙悟净 白龙马 唐僧 
    	//打印数组长度
    	int array_size =size_array(array);
    	printf("数组的长度为:%d\n", array_size);
    	printf("----------------------------------------------\n");
    	Person * per = get_array_data(array, 3);
    	printf("查找到的数据的名称为:%s,年龄为:%d\n", per->name, per->age);
    	printf("----------------------------------------------\n");
    
    	//删除动态数组中的数据
    	delete_array_data(array,4);
    	 array_size = size_array(array);
    	printf("数组的长度为:%d\n", array_size);
    	foreach_array_data(array, test_print_array);
    	printf("----------------------------------------------\n");
    	//清空数组
    	clean_array(array);
    	array_size = size_array(array);
    	printf("数组的长度为:%d\n", array_size);
    	//销毁动态数组
    	destroy_array(array);
    	return EXIT_SUCCESS;
    }
    #endif 
    ​

全部评论: 0

    我有话说: