数据结构--动态内存分配实现数组

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<stdbool.h>

typedef struct Arr{
    int *pBase;       /*存储的是数组第一个元素的地址*/
    int len;          /*数组的长度*/
    int cnt;          /*当前数组有效元素的个数*/
    int increasement; /*增量*/
}Arr_Type;

void Init_Arr(Arr_Type *pArr, int length);            /*初始化数组*/
bool Is_Empty(Arr_Type *pArr);                        /*判断数组时候为空*/
bool Is_Full(Arr_Type *pArr);                         /*判断数组是否满*/
void Show_Arr(Arr_Type *pArr);                        /*显示数组*/
bool Append_Arr(Arr_Type *pArr, int val);             /*添加数组元素*/
void Inversion_Arr(Arr_Type *pArr);                   /*倒置数组*/
bool Insert_Arr(Arr_Type * pArr, int pos, int value); /*向数组中插入一个元素*/
void Sort_Arr(Arr_Type *pArr);                        /*对数组排序*/
bool Delete_Arr(Arr_Type *pArr, int pos, int *val);   /*删除一个元素*/

int
main(int argc, char *argv[])
{
    Arr_Type arr;
    int val = 10;
    int delete_data;

    Init_Arr(&arr, val);
    Append_Arr(&arr,9);
    Append_Arr(&arr,19);
    Append_Arr(&arr,659);
    Append_Arr(&arr,36);
    Append_Arr(&arr,25);
    Append_Arr(&arr,76);

    printf("原始的数组是： ");
    Show_Arr(&arr);

    Inversion_Arr(&arr);
    printf("倒置后的数组是:");
    Show_Arr(&arr);

    Sort_Arr(&arr);
    printf("排序后的数组是:");
    Show_Arr(&arr);

    if (Delete_Arr(&arr, 3, &delete_data)) {
        printf("删除数据成功，删除的数据为：delete_data = %d\r\n", delete_data);
        Show_Arr(&arr);
    } else {
        printf("删除数据失败,请从自身找原因！！！\r\n");
    }

    Insert_Arr(&arr, 2, 111);
    printf("插入数据后的数组是：");
    Show_Arr(&arr);
}


/*数组初始化*/
void
Init_Arr(Arr_Type *pArr, int length)
{
    pArr->pBase = (int *)malloc(sizeof(int)*length);

    if (NULL == pArr->pBase) {
        printf("动态内存分配失败！！！\r\n");
        exit(-1);
    }

    if (pArr->pBase != NULL) {
        pArr->len = length;
        pArr->cnt = 0;
        printf("动态内存分配成功！！！\r\n");
    }

}

/*打印数组*/
void
Show_Arr(Arr_Type *pArr)
{
    int i;

    if (Is_Empty(pArr)){
        printf("数组为空！！！\r\n");
    } else  {
        for (i = 0; i<pArr->cnt; i++)
            printf("%d ",pArr->pBase[i]);
        printf("\r\n");
    }
}

/*追加新元素*/
bool
Append_Arr(Arr_Type *pArr, int val)
{
    if (Is_Full(pArr)) {
        printf("数组已经满了，无法添加新元素！！！\r\n");
        return false;
    } else {
        pArr->pBase[pArr->cnt] = val;
        (pArr->cnt)++;
        return true;
    }
}

/*判断是否满*/
bool
Is_Empty(Arr_Type *pArr)
{
    if (0 == pArr->cnt) {
        return true;
    } else
        return false;
}
/*判断是否为空*/
bool
Is_Full(Arr_Type *pArr)
{
    if (pArr->cnt == pArr->len) {
        return true;
    } else
        return false;
}

/*倒置*/
void
Inversion_Arr(Arr_Type *pArr)
{
    int i = 0;                /*指向数组第一个元素*/
    int j = pArr->cnt - 1;    /*指向数组最后一个元素*/
    int t;
    if (pArr->cnt == 0) {
        printf("数组为空，无法倒置！！！\r\n");
        return ;
    }
    while (i < j) {
        t = pArr->pBase[i];
        pArr->pBase[i] = pArr->pBase[j];
        pArr->pBase[j] = t;
        i++;
        j--;
    }

    return;
}

/*在数组中插入一个数据*/
bool
Insert_Arr(Arr_Type * pArr, int pos, int value)
{
    int i;

    if (Is_Full((pArr))) {
        printf("数组已经满了！！！\r\n");
        return false;
    }

    if (pos < 1 || pos > pArr->len+1) {
        printf("往哪插呢！，数组越界了！！！\r\n");
        return false;
    }

    for (i = pArr->cnt; i >= pos; i--) {
        pArr->pBase[i] = pArr->pBase[i-1];
    }

    pArr->pBase[pos - 1] = value;
    pArr->cnt++;

    return true;
}

/*对数组排序*/
void
Sort_Arr(Arr_Type *pArr)
{
    int i,j;
    int t;

    for (i = 0; i < pArr->cnt - 1; i++) {
        for (j = 0; j < pArr->cnt - i- 1; j++)
        {
            if (pArr->pBase[j] > pArr->pBase[j+1]) {
                t = pArr->pBase[j];
                pArr->pBase[j] = pArr->pBase[j+1];
                pArr->pBase[j+1] = t;
            }
        }
    }

    return;
}

/*删除数组中的一个数据*/
bool
Delete_Arr(Arr_Type *pArr, int pos, int *val)
{
    int i;

    if (Is_Empty(pArr)) {
        printf("数组为空，怎么删除呢！！！\r\n");
        return false;
    }

    if (pos < 1 || pos > pArr->cnt) {
        printf("要删除的位置不存在！！！\r\n");
        return false;
    } else {
        *val = pArr->pBase[pos - 1];

        for (i = pos; i < pArr->cnt; i++) {
            pArr->pBase[i - 1] = pArr->pBase[i];
        }

        pArr->cnt--;

        return true;
    }
}

#if 0
程序输出结果是：
动态内存分配成功！！！
原始的数组是： 9 19 659 36 25 76
倒置后的数组是:76 25 36 659 19 9
排序后的数组是:9 19 25 36 76 659
删除数据成功，删除的数据为：delete_data = 25
 19 36 76 659
插入数据后的数组是：9 111 19 36 76 659
#endif