数据结构入门之———连续存储结构【数组】

数据结构入门之—连续存储结构【数组】

郝斌

Xcode

#include <stdio.h>
#include <stdbool.h>        //bool 类型 头文件
#include <stdlib.h>     //包含了exit（）、malloc（）函数原型

/*  定义一个数据类型m，该数据类型的名字叫做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);      //追加  把val的值 加到数组的末尾
bool insert_arr(struct Arr * pArr,int pos, int val);    //pos的值从1开始 在pos位置的前面插入值val
 bool delete_arr(struct Arr *,int pos,int *pVal);    //f删除数组中第pos个位置的元素值，且令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(void)
{
    struct Arr arr;
    int val;
    
    init_arr(&arr,6);
    show_arr(&arr);
    append_arr(&arr,1);
    append_arr(&arr,10);
    append_arr(&arr,-3);
    append_arr(&arr,88);
    append_arr(&arr,11);
    
    show_arr(&arr);
    inversion_arr(&arr);
    printf("倒置之后的数组内容是：\n");
    show_arr(&arr);
    sort_arr(&arr);
    printf("升序之后的数组内容是：\n");
    show_arr(&arr);
    delete_arr(&arr,3,&val);
    printf("删除了第3个元素，它原先的值为: %d\n",val);
    show_arr(&arr);
    
    return 0;
}
/*操作：初始化数组*/
/*前提条件：有一个长度固定的待初始化的数组*/
/*后置条件：该链表初始化为空*/
void init_arr(struct Arr *pArr,int length)
{
    pArr->pBase = (int *)malloc(sizeof(int)*length);
    if(NULL == pArr->pBase)
    {
        printf("动态内存分配失败！\n");
        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(pArr) )
    {
        printf("数组为空！\n");
    }
    else
    {
        for(int i =0;i<pArr->cnt;++i)
            printf("%d ",pArr->pBase[i]);
        printf("\n");
    }
}
/*操作：在数组长度允许的条件下，在数组元素后面增加val的值*/
/*前提条件：有一个长度固定的数组指针和待增加的值*/
/*后置条件：返回是否成功增加的结果*/
bool append_arr(struct Arr *pArr,int val)
{
    //数组满时
    if(is_full(pArr))
        return false;
    //数组不满时
    else
    {
        pArr->pBase[pArr->cnt] = val;
        (pArr->cnt)++;
    }
    return true;
        
}
/*操作：在数组的固定位置插入一个元素*/
/*前提条件：有一个长度固定的数组指针、待插入的位置pos、待插入的值val*/
/*后置条件：返回是否成功插入val值的结果*/
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;
}
/*操作：删除一个数组中固定位置pos的值并且显示该删除的值*/
/*前提条件：有一个长度固定的数组指针、待删除的元素位置pos、该元素的值&pVal*/
/*后置条件：返回是否成功删除结果及待删除的值大小*/
 bool delete_arr(struct Arr * pArr,int pos,int *pVal)
{
    if(is_empty(pArr))
        return false;
    if(pos<1||pos>pArr->cnt)
        return false;
    *pVal = pArr->pBase[pos-1];
    for(int 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 t;
    for(int i = 0 ; i<pArr->cnt ; i++)
    {
        for(int 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;
}

程序运行示例：

数组为空！
1 10 -3 88 11
倒置之后的数组内容是：
11 88 -3 10 1
升序之后的数组内容是：
-3 1 10 11 88
删除了第3个元素，它原先的值为: 10
-3 1 11 88
Program ended with exit code: 0

---