连续存储数组的算法（包含数组倒置、冒泡排序……）

线性结构【把所有的结点用一根直线穿起来】

　　连续存储【数组】、离散存储【链表】（不连续的，可分隔开来）

#include<stdio.h>
#include<malloc.h>//包含malloc函数
#include<stdlib.h>//包含exit函数
//定义了一个(复合)数据类型，名字叫struct Arr，该数据类型有三个成员:
struct Arr{
    int * pBase; //存储的是数组第一个元素的地址
    int len; //数组所能容纳的最大元素个数
    int cnt; //当前数组有效元素的个数
};

void init_arr(struct Arr *pArr,int length); //初始化
bool append_arr(struct Arr *pArr,int val); //追加
bool insert_arr(struct Arr *pArr,int pos,int val); //插入，pos的值从1开始，表示在第pos个元素上插入
bool delete_arr(struct Arr *pArr,int pos,int *pVal); //删除
int get(); //获取某下标的值
bool is_empty(struct Arr *pArr);//判断数组是否为空
bool is_full(struct Arr *pArr); //判断数组是否满
void sort_arr(struct Arr *pArr); //排序
void show_arr(struct Arr *pArr); //输出
void inversion_arr(struct Arr *pArr); //倒置

int main(){
    struct Arr arr;//仅仅是用struct Arr数据类型定义了一个arr变量，并未初始化
    int val;
    
    init_arr(&arr,6);//不能直接传结构体变量，传实参(结构体变量)给形参赋值，没有联系！
    show_arr(&arr);//此处可以直接传变量
    append_arr(&arr,1);
    insert_arr(&arr,1,99);
    delete_arr(&arr,1,&val);
    return 0;
}

void init_arr(struct Arr *pArr,int length){
    pArr->pBase = (int *)malloc"(sizeof(int)*length);//sizeof(int)*length表示内存大小
    if (pArr->pBase == NULL){ //检测分配内存是否成功
        printf("动态内存分配失败");
        exit(-1);//终止整个程序
    }
    else{
        pArr -> len = length;
        pArr -> cnt = 0;
    }
    return;//函数终止
}

bool is_empty(struct Arr *pArr){
    if(pArr->cnt == 0){
        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(pAarr)){//此处不能传&pArr，因为pArr已经接收了结构体变量的地址
        printf("数组为空");
    }
    else{ //输出数组有效内容
        for(int i =0;i < pArr->cnt; i++){
            printf("%d ", pArr->pBase[i]);
        }
    }
}

bool append_arr(struct Arr *pArr,int val){
    if(is_full(pArr)){
        return false;//数组满时返回false
    }
    else{//不满时追加
        pArr->pBase[pArr->cnt] = val;//追加元素的下标就是pArr->cnt，数组目前的有效长度
        (pArr->cnt)++;//添加了一个元素，所以有效长度加一
        return true;
    }
}

bool insert_arr(struct Arr *pArr,int pos,int val){
    int i;
    if(is_full(pArr)){
        return false;
    }
    
    if(pos<1 || pos > pArr->cnt+1 ){ 
        return false;
    }
    
    for(i = pArr->cnt-1;i>=pos-1;i--){
        pArr->pBase[i+1] = pArr->pBase[i];
    }
    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(pos<1 || pos > pArr->cnt){
        return false;
    }
    *pVal=pArr->pBase[pos-1];//等待被删除的元素赋值给形参对应的主函数中的val
    for(i=pos;i< pAr->cnt;i++){
        pArr->pBase[i-1] = pArr->pBase[i];
    }
    (pArr->cnt)--;
}

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--;
    }
}

void sort_arr(struct Arr *pArr){
    int i,j,t;
    for(i=0;i < pArr->cnt;i++){   //冒泡排序优化算法，最多进行(pArr->cnt)-1轮比较
        for(j=i+1;j<pArr->cnt;j++){ //若j=0，那么条件就是j < pArr->cnt-i-1
            if(pArr->pBase[i]>pArr->pBase[j]){
                 t = pArr->pBase[i];
                 pArr->pBase[i]=pArr->pBase[j];
                 pArr->pBase[j] = t;
            }
        }
    }
}