数据结构(郝斌)】03线性结构-数组[连续存储数组的算法演示]

数组

1.只创建对象未初始化，该对象包含的内容为垃圾数据。

步骤

1.先创建一个数据类型结构体，该数据类型的名字struct Arr，有三个成员：pBase(存储数组第一个元素的地址)、len（数组所能容纳的最大元素的个数）、cnt（当前数组有效元素的个数）。

#include 
#include 
struct Arr
{
    /* data */
    int * pBase;//数组第一个元素的地址
    int len;//数组最大长度
    int cnt;//数组当前元素个数
};

2、封装几个函数 ：初始化、追加、插入、删除、是否为空、是否满、排序、倒置倒序、显示输出。

//初始化
void init_arr(struct Arr *pArr,int length);

3、使用：先创建一个结构体对象，调用所封装的方法实现对应功能。

int main(void)
{
    struct Arr arr;
    init_arr(&arr,12);
    printf("%d\n",arr.len);
    return 0;
}

初始化函数

参数：数组结构体指针，数组最大长度
（1）动态分配空间 malloc
记得强制转换类型
（2）判断数组第一个元素地址是否为空
如果为null，表示动态分配内存失败，退出程序
不为null，创建成功，初始化成员。
注意：
1.动态分配空间的对象是数组结构体的pbase成员(数组首元素地址)
2.开完空间要判断是否开空间成功，成功后初始化成员。

//初始化
void init_arr(struct Arr *pArr,int length)
{
    //注意是指针结构体的第一个元素地址开空间
    pArr->pBase=(int*)malloc(sizeof(int)*length);
    //判断是否动态开空间成功
    if(pArr->pBase == NULL) //失败
    {
        printf("动态分配内存失败！");
        exit(-1);//终止整个程序
    }
    else
    {
        pArr->len=length;
        pArr->cnt=0;
        printf("动态分配内存成功！");
    }
}

结果：

判断数组是否为空函数：

参数：数组结构体指针
is_empty函数判断

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

遍历打印数组函数：

参数：数组结构体指针
（1）判断数组是否为空
（2）为空，提示为空。
（3）不为空，输出数组有效内容。
注意：arr本身是一个结构体，不是数组，数组首地址也就是数组名为成员pBase(int型的数组)

//遍历
void show_arr(struct Arr *pArr)
{
    if (is_empty(pArr))
    {
        printf("数组为空\n");
    }
    else
    {
        //arr本身是一个结构体，不是数组，数组首地址也就是数组名为成员pBase(int型的数组)
        for(int i=0;i<pArr->cnt;++i)
            printf("%d ",pArr->pBase[i]);
        printf("\n");
    }
}

结果：

是否满函数

//是否满
bool is_full(struct Arr *pArr)
{
    if(pArr->cnt==pArr->len)
    {
        printf("该数组已满！");
        return true;
    }
    else
    {
        return false;
    }
}

追加函数：

参数：数组结构体指针，要插入的位置（第几个元素，也就是下边-1），要插入的数组元素
思路：先将要插入元素的下标元素逐个向后移动，最后赋值。
（1）判断数组是否已满，判断输入的位置pos参数是否不符合要求（小于0，超过当前数组长度–可以等于）
（2）从现存最后一个元素开始向后移动，直到目标位置（pos-1 也就是要插入的下标），然后赋值给目标位置。最后记得当前数组长度+1.
注意：循环的时候i初始值为当前数组最大下标值，最小为插入位置对应的下标值。

//插入(数组指针，插入位置--下标要加入的int型数字)
bool insert_arr(struct Arr *pArr,int pos,int val)
{
    // 
    int i;
    if(is_full(pArr))
    {
         printf("该数组已达到最大长度，插入失败！\n");
        return false;       
    }
    if (pos<0 || pos>pArr->cnt+1)//pos可以等于cnt+1也就相当于在数组末尾添加元素
    {
        printf("该位置不符合要求！\n");
        return false;
    }
    for(i=pArr->cnt-1;i>=pos-1;--i)
    {
        pArr->pBase[i+1]=pArr->pBase[i];//第一次将数组最后一个元素的值后移
        // printf("%daaa",pArr->pBase[i+1]);
    }
    pArr->pBase[pos-1]=val;
    pArr->cnt++;
    return true;
}

main测试

int main(void)
{
    struct Arr arr;
    init_arr(&arr,10);
    // show_arr(&arr);
    
    append_arr(&arr,0);
    append_arr(&arr,1);
    append_arr(&arr,2);
    append_arr(&arr,3);
    append_arr(&arr,4);
    append_arr(&arr,5);
    insert_arr(&arr,6,538);
    show_arr(&arr);
    // printf("%d\n",arr.pBase[0]);
    return 0;
}

结果：

输入插入位置小于1、超过数组当前最大下标+1后，插入失败

删除函数：

参数：待删除的数组元素值
（1）判断pos是否合法（小于1、大于cnt、为空）
（2）删除的思路：将待删除位置的后一位元素逐个向前移动
注意：要想获取到被删除的数组值，定义一个指针参数，在函数存储元素值。
数组赋值图解：
下图来源：https://www.cnblogs.com/wangbingc/p/9832397.html#valuation_array

//删除(,,返回删除的元素值)
bool delete_arr(struct Arr *pArr,int pos,int *pVal)
{
    int i;
    if (is_empty(pArr))
    {
        printf("数组为空，删除失败！\n");
        return false;
    }
    if (pos<1 || pos>pArr->cnt)
    {
        printf("pos不合法！删除失败!\n");
        return false;
    }
    *pVal=pArr->pBase[pos-1];//被删除的元素值
    for(i=pos-1;i<=pArr->cnt-1;i++)
    {
        pArr->pBase[i]=pArr->pBase[i+1];
    }
    printf("删除成功！删除的值为%d\n",*pVal);
    return true;
}

main测试：

int main(void)
{
    struct Arr arr;
    init_arr(&arr,10);
    // show_arr(&arr);
    int val;
    append_arr(&arr,0);
    append_arr(&arr,1);
    append_arr(&arr,2);
    append_arr(&arr,3);
    append_arr(&arr,4);
    append_arr(&arr,5);
    insert_arr(&arr,8,123);
    delete_arr(&arr,4,&val);
    show_arr(&arr);
    // printf("%d\n",arr.pBase[0]);
    return 0;
}

结果：

倒序函数：

思路：两头收尾交叉互换实现倒序

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

排序函数：

冒泡排序
第1（2、3、4…）个与后面的比较，小的f放前面。

代码思路：
两个for循环嵌套，第二层循环判断两个数值的大小，小的排前面，大的排后面。

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

main测试：

int main(void)
{
    struct Arr arr;
    init_arr(&arr,10);
    // show_arr(&arr);
    int val;
    append_arr(&arr,0);
    append_arr(&arr,1);
    append_arr(&arr,8);
    append_arr(&arr,3);
    append_arr(&arr,9);
    append_arr(&arr,5);
    insert_arr(&arr,4,123);
    show_arr(&arr);
    delete_arr(&arr,2,&val);
    show_arr(&arr);
    
    inversion_arr(&arr);
    printf("倒置后：");
    show_arr(&arr);
    sort_arr(&arr);
    printf("(冒泡)排序后：");
    show_arr(&arr);
    // printf("%d\n",arr.pBase[0]);
    return 0;
}

完整代码

#include 
#include  //malloc
#include  //exit
struct Arr
{
    /* data */
    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);//插入
bool delete_arr(struct Arr *pArr,int pos,int *pVal);//删除
bool is_empty(struct Arr *pArr);//是否为空
bool is_full(struct Arr *pArr);//是否满
void sort_arr(struct Arr *pArr);//排序
void inversion_arr(struct Arr *pArr);//倒序
void show_arr(struct Arr *pArr);//遍历

int main(void)
{
    struct Arr arr;
    init_arr(&arr,10);
    // show_arr(&arr);
    int val;
    append_arr(&arr,0);
    append_arr(&arr,1);
    append_arr(&arr,8);
    append_arr(&arr,3);
    append_arr(&arr,9);
    append_arr(&arr,5);
    insert_arr(&arr,4,123);
    show_arr(&arr);
    delete_arr(&arr,2,&val);
    show_arr(&arr);
    
    inversion_arr(&arr);
    printf("倒置后：");
    show_arr(&arr);
    sort_arr(&arr);
    printf("(冒泡)排序后：");
    show_arr(&arr);
    // printf("%d\n",arr.pBase[0]);
    return 0;
}
//初始化
void init_arr(struct Arr *pArr,int length)
{
    //注意是指针结构体的第一个元素地址开空间
    pArr->pBase=(int*)malloc(sizeof(int)*length);
    //判断是否动态开空间成功
    if(pArr->pBase == NULL) //失败
    {
        printf("动态分配内存失败！\n");
        exit(-1);//终止整个程序
    }
    else
    {
        pArr->len=length;
        pArr->cnt=0;
        printf("动态分配内存成功！\n");
    }
    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)
    {
        printf("该数组已满！");
        return true;
    }
    else
    {
        return false;
    }
}
//追加函数(数组指针，要加入的int型数字)
bool append_arr(struct Arr *pArr,int val)
{
    if (is_full(pArr))
        return false;
    else
    {
        //cnt表示数组下标
        pArr->pBase[pArr->cnt]=val;
        (pArr->cnt)++;
        printf("数组追加成功！%d\n",pArr->pBase[(pArr->cnt)-1]);
        // printf("val:%d=%d(pArr->pBase[pArr->cnt])\n",val,pArr->pBase[(pArr->cnt)-1]);
        return true;
    }
}
//插入(数组指针，插入位置--下标要加入的int型数字)
bool insert_arr(struct Arr *pArr,int pos,int val)
{
    // 
    int i;
    if(is_full(pArr))
    {
         printf("该数组已达到最大长度，插入失败！\n");
        return false;       
    }
    if (pos<=0 || pos>pArr->cnt+1)//pos可以等于cnt+1也就相当于在数组末尾添加元素
    {
        printf("该位置不符合要求！\n");
        return false;
    }
    for(i=pArr->cnt-1;i>=pos-1;--i)
    {
        pArr->pBase[i+1]=pArr->pBase[i];//第一次将数组最后一个元素的值后移
        // printf("%daaa",pArr->pBase[i+1]);
    }
    pArr->pBase[pos-1]=val;
    pArr->cnt++;
    return true;
}


//遍历
void show_arr(struct Arr *pArr)
{
    if (is_empty(pArr))
    {
        printf("数组为空\n");
    }
    else
    {
        //arr本身是一个结构体，不是数组，数组首地址也就是数组名为成员pBase(int型的数组)
        for(int i=0;i<pArr->cnt;++i)
            printf("%d ",pArr->pBase[i]);
        printf("\n");
    }
}


//删除(,,返回删除的元素值)
bool delete_arr(struct Arr *pArr,int pos,int *pVal)
{
    int i;
    if (is_empty(pArr))
    {
        printf("数组为空，删除失败！\n");
        return false;
    }
    if (pos<1 || pos>pArr->cnt)
    {
        printf("pos不合法！删除失败!\n");
        return false;
    }
    *pVal=pArr->pBase[pos-1];//被删除的元素值
    for(i=pos-1;i<=pArr->cnt-1;i++)
    {
        pArr->pBase[i]=pArr->pBase[i+1];
    }
    pArr->cnt--;//删除后记得数组个数-1
    printf("删除成功！删除的值为%d\n",*pVal);
    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;
            }
        }
    }
}