连续存储---数组

本文讲数组存储数据的相关方法实现，包括数组的插入、删除、排序、追加、反转、遍历等。
后面博客会讲离散存储链表的实现，然后两者做下效率对比。

# include <stdio.h>
# include <malloc.h>  
# include <stdlib.h>

//定义了一个数据类型，该数据类型的名字叫做struct Arr, 
//该数据类型含有三个成员，分别是pBase, len, cnt
typedef struct Arr
{
    int * pBase; //存储的是数组第一个元素的地址
    int len;     //数组所能容纳的最大元素的个数
    int cnt;     //当前数组有效元素的个数
}*pArr;
//数组存储数据的基本方法
void initArr(pArr pArrary, int length);//初始化
bool appendArr(pArr pArrary, int val); //追加
bool insertArr(pArr pArrary, int pos, int val); //插入
bool deleteArr(pArr pArrary, int pos);//删除
int get();
bool isEmpty(pArr pArrary);//数组是否为空
bool isFull(pArr pArrary);//数组是否为满
void sortArr(pArr pArrary);//普通排序 
void sortArr2(pArr pArrary);//冒泡排序 
void showArr(pArr pArrary); //遍历数组
void inversionArr(pArr pArrary);//反转数组
//测试程序
int main(int argc, char *argv[])
{
    struct Arr arr;
    //int val;
    initArr(&arr, 6);
    showArr(&arr);//遍历数组 
    appendArr(&arr, 1);//追加
    appendArr(&arr, 10);
    appendArr(&arr, -3);
    appendArr(&arr, 6);
    appendArr(&arr, 88);
    printf("依次往数组追加数据:1,10,-3,6,88\n");
    showArr(&arr);
    insertArr(&arr, 4, 3);//插入，第五个位置插入3，pos的值从0开始 
    printf("数组第五个位置插入3\n");
    showArr(&arr);
    deleteArr(&arr, 1); //删除，第二个位置
    printf("删除数组第二个位置的元素\n"); 
    showArr(&arr);
    sortArr(&arr);//普通排序数组 ,从大到小 
    printf("普通排序数组 ,从大到小\n"); 
    showArr(&arr);//遍历数组 
    inversionArr(&arr);//反转数组 
    printf("反转数组 \n");
    showArr(&arr);//遍历数组 
    appendArr(&arr, 0);
    printf("往数组尾部追加元素0\n");
    showArr(&arr);//遍历数组 
    sortArr2(&arr);//冒泡排序，从小到大 
    printf("冒泡排序，从小到大 \n");
    showArr(&arr);//遍历数组 
    printf("测试结束!\n");
    return 0;
}
//初始化数组
void initArr(pArr pArrary, int length)
{
    pArrary->pBase = (int *)malloc(sizeof(int)*length);
    if (NULL == pArrary->pBase)
    {
        printf("malloc error\n");
        exit(-1);
    }
    pArrary->len = length;
    pArrary->cnt = 0;
}
//数组是否为空
bool isEmpty(pArr pArrary)
{
    return ( (pArrary->cnt == 0 )? true : false);
}
//数组是否为满
bool isFull(pArr pArrary)
{
    return( (pArrary->len == pArrary->cnt )? true : false);
}
//追加
bool appendArr(pArr pArrary, int val)
{
    if (isFull(pArrary))
    {
        return false;
    }
    pArrary->pBase[pArrary->cnt] = val;
    pArrary->cnt ++;
}
//pos表示插入的位置，取值为:0,1,2......0表示第一个位置 
bool insertArr(pArr pArrary, int pos, int val)
{
    if (isFull(pArrary))
    {
        return false;
    }
    if (pos < 0 || pos >= pArrary->cnt)
    {
        return false;
    }
    else
    {
        for (int i = pArrary->cnt;i >=pos;i--)
        {
            pArrary->pBase[i] = pArrary->pBase[i-1];
        }
        pArrary->pBase[pos] = val;
        pArrary->cnt++;//没注意到 
    }
}
//pos表示删除的位置，取值为:0,1,2......0表示第一个位置
bool deleteArr(pArr pArrary, int pos)
{
    if (isEmpty(pArrary))
    {
        return false;
    }
    //插入的位置大于有效值的个数时 
    if (pos < 0 || pos >= pArrary->cnt)
    {
        return false;
    }
    for (int i = pos;i<pArrary->cnt;i++)
    {
        pArrary->pBase[i] = pArrary->pBase[i+1];
    }
    pArrary->cnt --;
}
int get()
{

}
//排序 
void sortArr(pArr pArrary)
{
    int n = pArrary->cnt;
    int tmp;
    for(int i = 0;i < n ;i++)
    {
        for(int j = 0; j < n; j++)
        {
            if(pArrary->pBase[i] > pArrary->pBase[j])
            {
                tmp = pArrary->pBase[j];
                pArrary->pBase[j] = pArrary->pBase[i];
                pArrary->pBase[i] = tmp;
            }
        }   
    }
}
//冒泡排序
void sortArr2(pArr pArrary)
{
    int i,j,n,tmp;
    n = pArrary->cnt;
    //有n个元素，总共需要比较n-1趟 
    for (j = 0; j < n-1 ; j++)
    {
        //每一趟，需要比较 n-1-j次 
        for(i = 0;i < n-1-j;i++)
        {
            if (pArrary->pBase[i] > pArrary->pBase[i+1])
            {
                tmp = pArrary->pBase[i+1];
                pArrary->pBase[i+1] = pArrary->pBase[i];
                pArrary->pBase[i] = tmp;            
            }
        } 
    }
}
//遍历数组 
void showArr(pArr pArrary)
{
    for(int i = 0;i<pArrary->cnt;i++)
    {
        printf("Arrary[%d] = %d\n",i,pArrary->pBase[i]);
    }
}
//反转数组
void inversionArr(pArr pArrary)
{
    int n = pArrary->cnt;
    int i,tmp;
    for (i = 0;i < n/2; i++)
    {
        tmp = pArrary->pBase[i];
        pArrary->pBase[i] = pArrary->pBase[n-1-i];
        pArrary->pBase[n-1-i] = tmp;
    }
}

实验结果：