数组的增，删

#include 
#include malloc.h> //它包含了malloc函数
#include // 它包含了exit函数
#include //c语言中无bool类型，需要加上此头文件

//定义了一个数据类型，该数据类型的名字叫做struct Arr， 该数据类型含有三个成员变量
struct Arr
{
    int * pBase; //存储的是西湖组第一个元素的地址
    int len;  //数组所能容纳的最大元素个数
    int cnt;  //当前数组的有效元素个数
};
void init_arr(struct Arr * pArr, int length);
void show_arr(struct Arr * pArr);
bool is_empty(struct Arr * pArr);
bool append_arr(struct Arr * pArr, int val);//追加
bool insert_arr(struct Arr * pArr, int pos, int val); //pos的值从1开始
bool is_full(struct Arr * pArr);
bool delete_arr(struct Arr * pArr,int pos, int * pVal); //pVal是返回删除元素的位置
void inversion_arr(struct Arr * pArr);
void sort_arr(struct Arr * pArr);
int main()
{
    struct Arr arr; //定义了arr变量，它的类型为struct Arr
    struct Arr val;

    init_arr(&arr, 6);
    show_arr(&arr);
    append_arr(&arr, 2);
    append_arr(&arr, 42);
    append_arr(&arr, 100);
    append_arr(&arr, 65);
    append_arr(&arr, 88);
    if(delete_arr(&arr, 2, &val))
    {
        printf("删除成功！\n");
        printf("您删除的元素是： %d\n", val);
    }
    else
        printf("删除失败！\n");
    show_arr(&arr);
    printf("倒置后的数组为： \n");
    inversion_arr(&arr);
     /* append_arr(&arr, 3);
    append_arr(&arr, 4);
    insert_arr(&arr, 1, 0);
    append_arr(&arr, 5);
    append_arr(&arr, 6);
    if(append_arr(&arr, 8))
    {
        printf("追加成功\n");
    }
    else
    {
        printf("追加失败\n");
    }*/
    show_arr(&arr);
    printf("排序后的数组为：\n");
    sort_arr(&arr);
    show_arr(&arr);
    return 0;
}

void init_arr(struct Arr * pArr, int length) //数组形参中必须要包括首地址和数组长度
{
    pArr->pBase = (int *)malloc(sizeof(int)*length); //pArr->pBase表示pArr这个指针变量指向结构体变量中pBase这个成员； 为数组动态分配空间
    if(pArr->pBase==NULL)
    {
        printf("动态内存分配失败\n");
        exit(-1);//  终止整个程序
    }
    else
    {
        pArr->len = length; //动态分配数组成功，给数组的长度赋值
        pArr->cnt = 0; //给数组的有效长度初始化
    }
    return ;
}
void show_arr(struct Arr * pArr)
{
    int i;
    if(is_empty(pArr)) //pArr就是地址，前面不需要加&
        printf("数组为空\n");
    else
        {
            for( i=0;icnt;i++)
            {
                printf("%d ",pArr->pBase[i]);//pArr指向的人家主函数中的那个结构体变量的pBase成员
            }
        }
    printf("\n");
}
bool is_empty(struct Arr * pArr)
{
    if(pArr->cnt==0) //如果数组的有效数组上的为0
        return true;
    else
        return false;
}
bool is_full(struct Arr * pArr)
{
    if(pArr->cnt==pArr->len) //如果数组的有效长度等于数组的长度，则数组满了
        return true;
    else
        return false;
}
bool append_arr(struct Arr * pArr, int val)
{
    //满时返回false
    if(is_full(pArr))
        return false;

    //不满时追加
    pArr->pBase[pArr->cnt] = val;//此处可以写几个数字试一下就知道要填pArr->cnt
   pArr->cnt++; //有效数组长度加1
    return true;
}
bool insert_arr(struct Arr * pArr, int pos, int val)
{
    int i;
    if(pArr->cnt==pArr->len)
        return false;
    if(pos1||pos>pArr->cnt+1) //注意是cnt+1
        return false;
    for(i=pArr->cnt-1;i>=pos-1;i--) //试几组数据就可以找出规律。是有效数组的长度而不是数组的长度
    {
        pArr->pBase[i+1] = pArr->pBase[i]; //把i位置的元素赋给i+1位置
    }
    pArr->pBase[pos-1] = val;
    pArr->cnt++;
    return true;
}
bool delete_arr(struct Arr * pArr,int pos, int * pVal)
{
    int i;
    if(is_empty(pArr))
        return false;
    if(pos1||pos>pArr->cnt)
        return false;

    *pVal = pArr->pBase[pos-1]; //*pVal相当于主函数中的val；等待删除的元素赋给了形参pVal指向的主函数中的val；主函数则获取到了待删除元素
    for(i=pos;icnt;i++)
    {
        pArr->pBase[i-1] = pArr->pBase[i];//i位置的元素赋给i-1
    }
    pArr->cnt--;
    return true;

}
void inversion_arr(struct Arr * pArr) //倒置函数
{
    int i=0,j=pArr->cnt-1,t; //定义两个变量，i和j分别位于数组两端
    while(ij)
    {
        t = pArr->pBase[i]; //用交换的原型t=a;a-b;b=t
        pArr->pBase[i] = pArr->pBase[j];
        pArr->pBase[j] = t;
        ++i;
        --j;
    }
    return;
}
void sort_arr(struct Arr * pArr) //用选择排序
{
    int i, j, t;
    for(i=0;icnt;i++)
    {
        for(j=i+1;jcnt;j++)
        {
            if(pArr->pBase[i]>pArr->pBase[j])
            {
                t = pArr->pBase[i]; //用交换的原型t=a;a-b;b=t
                pArr->pBase[i] = pArr->pBase[j];
                pArr->pBase[j] = t;
            }
        }
    }
}