C语言- 基础数据结构和算法 - 动态数组

听黑马程序员教程《基础数据结构和算法 (C版本)》，照着老师所讲抄的，

视频地址https://www.bilibili.com/video/BV1vE411f7Jh?p=1

喜欢的朋友可以去看看。

动态数组

#include<stdio.h>
#include<stdlib.h>
#include<string.h> 

/*
动态数组，视频地址https://www.bilibili.com/video/BV1vE411f7Jh?spm_id_from=333.999.0.0
动态增长内存，，策略-将存放数据的内存放在 - 堆上。

*/
// 定义动态数组的结构体
typedef struct DYNAMICARRAY{
    int* pAddr;        // 存放数组的地址（首地址） 获取地址上的值方式为:pAddr[i]
    int size;        // 元数个数
    int capacity;    // 空间容量，申请的容量最多能放多少个元素。
}Dynamic_Array;

// 对 DYNAMICARRAY 结构体操作的函数

// 初始化
Dynamic_Array* Init_Array(); 

// 插入元素
void Push_back_Array(Dynamic_Array* array,int value); 

// 删除（根据位置删除）
void RemoveByPos_Array(Dynamic_Array* arr,int pos);

// 删除（根据值删除）
void RemoveByValue_Array(Dynamic_Array* arr,int value); 

// 查找，根据值查找位置
int Find_Array(Dynamic_Array* arr,int value); 

// 打印
void Print_Array(Dynamic_Array* arr); 

// 释放动态数组的内存
void FreeSpace_Array(Dynamic_Array* arr); 

// 清空数组
void Clear_Array(Dynamic_Array* arr); 

// 获得动态数组的容量
int capacity_Array(Dynamic_Array* arr); 

// 获得动态数组当前元素个数
int Size_Array(Dynamic_Array* arr); 

// 根据位置获得某个元素的值
int At_Array(Dynamic_Array* arr,int pos); 

// 测试 ------------------------------------------------------------------------
void test01(){
    // 初始化动态数组
    Dynamic_Array* myArray = Init_Array(); 

    // 输出容量、元素个数
    printf("元素个数：%d\n",myArray->size);
    printf("容量大小：%d\n",myArray->capacity);

    // 插入元素
    int i;
    for(i=0;i<10;i++){
        Push_back_Array(myArray,i);
    }
    // 打印
    Print_Array(myArray); 

    // 插入
    Push_back_Array(myArray,99);
    // 打印
    Print_Array(myArray);     

    // 删除（根据值删除）
    RemoveByValue_Array(myArray,9);
    // 打印
    Print_Array(myArray); 

    // 删除（根据位置删除）
    RemoveByPos_Array(myArray,2);
    // 打印
    Print_Array(myArray); 

    // 输出容量、元素个数
    printf("元素个数：%d\n",myArray->size);
    printf("容量大小：%d\n",myArray->capacity);

    // 查找第5个位置元素值（从 0 开始数）
    printf("第5位元素的值是：%d\n",At_Array(myArray,5));

    // 销毁
    FreeSpace_Array(myArray);
} 

int main(){
    printf("好好学习，天天向上~！（动态数组 20220529）\n\n");

    test01();

    return 0;
}

// 对 DYNAMICARRAY 结构体操作的函数
// 初始化
Dynamic_Array* Init_Array(){
    // 申请内存，开辟空间，
    Dynamic_Array* myArray = (Dynamic_Array*)malloc(sizeof(Dynamic_Array));
    // 初始化
    myArray->size = 0;
        // 预设20个元素的空间
    myArray->capacity=20;
        // 按预设的20个空间，申请内存，并取得首地址。
    myArray->pAddr = (int*)malloc(sizeof(int) * myArray->capacity);

    return myArray;
} 

// 插入元素
void Push_back_Array(Dynamic_Array* arr,int value){
    if(arr==NULL){
        return ;
    }
    // 判断空间是否够，如果不够，则申请原空间2倍的空间
    if(arr->size == arr->capacity){
        // 1、申请更大的空间。默认新空间是旧空间的2倍。
        int* newSpace = (int*)malloc(sizeof(int) * arr->capacity * 2);
        // 2、拷贝数据到新的空间
        memcpy(newSpace,arr->pAddr,arr->capacity * sizeof(int));
        // 3、释放旧空间内存
        free(arr->pAddr);
        // 4、更新容量和首地址
        arr->capacity = arr->capacity * 2 ;
        arr->pAddr = newSpace;
    }
    // 插入元素
    arr->pAddr[arr->size] = value;
    arr->size++; 

} 

// 删除（根据位置删除）
void RemoveByPos_Array(Dynamic_Array* arr,int pos){
    if(arr==NULL){
        return;
    }
    if(pos <0 || pos >= arr->size){    // 位置不能小于0或大于元素个数
        return;
    }
    // 用for循环，把要删除的位置下一个位置的元素全部前移一位覆盖
    int i;
    for(i=pos;i<=arr->size-1;i++){
        arr->pAddr[i] = arr->pAddr[i+1];
    }
    // 重新标识元素个数（减 1）
    arr->size--;
}

// 删除（根据值删除） 第一次出现的位置
void RemoveByValue_Array(Dynamic_Array* arr,int value){
    if(arr==NULL){
        return;
    }
    // 先找值的位置
    int pos = Find_Array(arr,value);
    // 找到位置后，根据位置删除
    RemoveByPos_Array(arr,pos);
} 

// 查找，根据值查找位置
int Find_Array(Dynamic_Array* arr,int value){
    if(arr==NULL){
        return 0;
    }
    // 先找值的位置
    int pos = -1;        // 默认 -1 也就是没找到
    int i;
    for(i=0;i<arr->size;i++){
        if(arr->pAddr[i]==value){
            pos = i;
            break;        // 找到后退出，要不然会找到最后一个值的位置
        }
    }
    return pos;
}

// 打印
void Print_Array(Dynamic_Array* arr){
    if(arr==NULL){
        return;
    }
    int i;
    for(i=0;i<=arr->size-1;i++){
        printf("%d ",arr->pAddr[i]);
    }
    printf("\n\n");
} 

// 释放动态数组的内存
void FreeSpace_Array(Dynamic_Array* arr){
    if(arr==NULL){
        return;
    }
    if(arr->pAddr!=NULL){
        free(arr->pAddr);
    }
    free(arr);
} 

// 清空数组
void Clear_Array(Dynamic_Array* arr){
    if(arr==NULL){
        return;
    }
    arr->size=0;
}

// 获得动态数组的容量
int capacity_Array(Dynamic_Array* arr){
    if(arr==NULL){
        return ;
    }
    return arr->capacity;
}

// 获得动态数组当前元素个数
int Size_Array(Dynamic_Array* arr){
    if(arr==NULL){
        return ;
    }
    return arr->size;
}

// 根据位置获得某个元素的值
int At_Array(Dynamic_Array* arr,int pos){
    if(arr==NULL){
        return ;
    }
    return arr->pAddr[pos];
}