数组算法

# include <stdio.h>
# include <malloc.h>  //包含 malloc 函数
# include <stdlib.h>    //包含 exit 函数

//定义了一个数据类型，类型的名字叫struct Arr，该数据类型含有三个成员，分别是 pBase，len，cnt
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 开始
bool delete_arr(struct Arr *pArr,int pos,int *val);//删除，int *val 是删除的值
bool is_empty(struct Arr *pArr);
bool is_full();
void sort_arr(struct Arr *pArr);//排序
void show_arr(struct Arr *pArr);
void inversion_arr(struct Arr *pArr);  //倒置

int main(voie)
{
    struct Arr arr;
    int deleteVal;  //删除的值


    init_arr(&arr,6);
    show_arr(&arr);
    appent_arr(&arr,1);
    insert_arr(&arr,1,99);

    if(delete_arr(&arr,1,&deleteVal))
    {
        printf("删除成功\n");
        printf("您删除的元素是 %d\n",deleteVal)
    }
    else
    {
        printf("删除失败！")
    }

    inversion_arr(&arr);

    return 0;
}



// 初始化数组
void init_arr(struct Arr *pArr,int length)
{
    pArr -> pBase = (int *)malloc(sizeof(int) * length)
    if (NULL == pArr -> pBase)//内存分配失败，如内存已满，无法分配多余内存。
    {
        printf("动态内存分配失败");
        exit(-1);  //终止整个程序
    }else{
        pArr -> len = length;
        pArr -> cnt = 0;
    }
}

//判断数组是否为空 
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 ture;
    else
        return false;
}

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

//追加
bool append_arr(struct Arr *pArr,int val)
{
    //数组满返回 false
    if(is_full(pArr))
        return false

    //数组没有满
    pArr -> pBase[pArr->cnt] = val;
    (pArr->cnt)++; 
    return true
}

//插入
bool insert_arr(struct Arr *pArr,int pos,int val)
{
    int i;

    //数组已满，插入失败
    if(is_full(pArr))
        return false

    //插入位置从1开始计算
    //位置小于1，或者大于有效个数长度，插入失败
    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;
}

//删除，int *val 是删除的值
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[i]
    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->ctn -1;
    int t;

    while(i<j)
    {
        t = pArr->pBase[i];
        pArr->pBase[i] = pArr->pBase[j];
        pArr->pBase[j] = t;
        ++i;
        --j;
    }
    rerutn;
}

//排序
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;
            } 
        }
    }
}

优点：

读取速度快。

缺点：

• 插入删除元素慢。
• 事先需要知道数据长度。
• 需要大块连续的内存块。