2020-10-17数据结构：数组

#include <stdio.h>
#include <stdlib.h>  //包含了exit函数
#include <malloc.h>  //包含了malloc函数
#include <stdbool.h>  //包含了bool类型
struct Arr{
    int cnt;  //当前数组有效元素的个数
    int len;  //数组所能容纳的最大元素的个数
    int *pBase;  //存储的是数组第一个元素的地址
};

void init_arr(struct Arr *pArr,int length);  //分号不能省
void show_arr(struct Arr *);
bool is_empty(struct Arr *);
bool append_arr(struct Arr *,int);  //追加
bool is_full(struct Arr *);
bool insert_arr(struct Arr *,int position,int val); //position的值从1开始
bool delete_arr(struct Arr *,int pos,int *pVal);
void inversion_arr(struct Arr *pArr);  //倒置
void sort_arr(struct Arr *);  //排序

int main(void)
{
    struct Arr arr;
    int val;

    init_arr(&arr,6);

    append_arr(&arr,1);
    append_arr(&arr,-6);
    append_arr(&arr,22);
    append_arr(&arr,45);
    append_arr(&arr,10);
    //append_arr(&arr,6);
    //append_arr(&arr,7);
    //insert_arr(&arr,5,99);
    //delete_arr(&arr,4,&val);

    printf("删除的元素是：%d\n",val);

    show_arr(&arr);

    inversion_arr(&arr);
    printf("倒置之后的数组：\n");
    show_arr(&arr);

    sort_arr(&arr);
    printf("排序之后的数组：\n");
    show_arr(&arr);

    return 0;
}

void init_arr(struct Arr *pArr,int length)
{
    //(*pArr).len = 99;
    pArr->pBase = (int *)malloc(sizeof(int)*length);  //相当于pArr指针变量所指向的结构体变量的pBase成员
    if (NULL == pArr->pBase){
        printf("动态内存分配失败！\n");
        exit(-1);  //终止整个程序   exit(x);x不为0都为异常退出
    }else{
        pArr->len = length;
        pArr->cnt = 0;
    }
    return;
}

bool is_empty(struct Arr *pArr)
{
    if(0 == pArr->cnt)
        return true;
    else
        return false;
}

bool is_full(struct Arr *pArr)
{
    if(pArr->cnt == pArr->len)
        return true;
    else
        return false;
}

void show_arr(struct Arr *pArr){
    if( is_empty(pArr)){
        printf("数组为空！\n");
    }
    else
    {
        int i = 0;
        for(;i<pArr->cnt;i++){
            printf("%d\n",pArr->pBase[i]);
        }
    }
}

bool append_arr(struct Arr *pArr,int val)
{
    //满时返回false
    if( is_full(pArr)){
        printf("追加失败！\n");
        return false;
    }
    //不满时追加
    else{
        pArr->pBase[pArr->cnt] = val;
        pArr->cnt++;
        return true;
    }

}

bool insert_arr(struct Arr *pArr,int position,int val)
{
    int i;
    if(is_full(pArr))
        return false;

    if(position<1 || position>pArr->cnt+1)
        return false;

    for(i=pArr->cnt-1;i>=position-1;i--){
        pArr->pBase[i+1] = pArr->pBase[i];
    }
    pArr->pBase[position-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(pos<1||pos>pArr->cnt)
        return false;

    *pVal = pArr->pBase[pos-1];

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

void inversion_arr(struct Arr *pArr)
{
    int i = 0;
    int j = pArr->cnt-1;
    int t;

    while(i<j){
        t = pArr->pBase[i];
        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;i<pArr->cnt;i++){
        for(j=i+1;j<pArr->cnt;j++){
            if(pArr->pBase[i]>pArr->pBase[j]){
                t = pArr->pBase[i];
                pArr->pBase[i] = pArr->pBase[j];
                pArr->pBase[j] = t;
            }
        }
    }
    return;
}