数据结构之顺序表的操作

/*
    时间:2019年10月11日22:09:45
    说明:函数的形参以struct Arr*类型,
    因为指针变量只占4个字节,
    如果传入的形参是struct Arr类型,struct Arr所占字节大于4个,内存更浪费了
*/
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

//定义了一个数据类型,该数据类型的名字叫struct Arr,该数据类型含有三个成员,分别是pBase,len,cnt;
struct Arr{
    int* pBase;//存储的是数组第一个元素的地址
    int len;  //数组所能容纳的最大元素的个数
    int cnt;//当前数组有效元素的个数

};

void init_arr(struct Arr *,int length);  //初始化数组
bool append_arr(struct Arr*,int val);//追加元素到末尾
bool insert_arr(struct Arr*,int position,int val);  //在position位置插入val值,position的值从1开始
bool delete_arr(struct Arr*,int position,int *pVal); //删除第position个元素,position从1开始
int get();
bool is_empty(struct Arr *);            //判断数组是否为空数组
bool is_full(struct Arr *);            //判断数组是否已满
void sort_arr(struct Arr *);                     //给数组排序
void show_arr(struct Arr *);         //打印数组
void inversion_arr(struct Arr *);   //将数组倒置

int main(void)
{
    struct Arr arr;
    int val;
    init_arr(&arr,6);
    append_arr(&arr,6);
    append_arr(&arr,5);
    append_arr(&arr,8);
    show_arr(&arr);
    insert_arr(&arr,4,9);
    show_arr(&arr);
    delete_arr(&arr,3,&val) ;
    printf("%d\n",val);
    show_arr(&arr);
    inversion_arr(&arr);
    show_arr(&arr);
    sort_arr(&arr);
    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(0 == pArr->cnt)
   {
      return true;
   }
   else
   {
    return false;
   }
}

bool is_full(struct Arr *pArr)
{
    if(pArr->len == pArr->cnt)
    {
        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");
    }
}

bool append_arr(struct Arr* pArr,int val)
{
    if(is_full(pArr))   //满时返回false
    {
        return false;
    }
    else     //不满时追加
    {
        int position = pArr->cnt;
        pArr->pBase[position] = val;
        pArr->cnt += 1;
        return true;
    }
}

bool insert_arr(struct Arr* pArr,int position,int val)
{
    if(is_full(pArr) || position < 1 || position > pArr->cnt+1 || position > pArr->len)
    {
        return false;
    }
    else
    {
        for(int i = pArr->cnt;i >= position-1;i--)
        {
            pArr->pBase[i] = pArr->pBase[i-1];
        }
       
        pArr->pBase[position-1] = val;
        pArr->cnt += 1;
        return true;
    }
}

bool delete_arr(struct Arr* pArr,int position,int *pVal)
{
    if(is_empty(pArr))
    {
        return false;
    }
    else if(position < 1 || position > pArr->cnt)
    {
        printf("删除失败!");
        return false;
    }
    else
    {
        *pVal = pArr->pBase[position-1];
       for(int i = position;i < pArr->cnt;i++)
       {
            pArr->pBase[i-1] = pArr->pBase[i];
       }
      pArr->cnt -= 1;

       return true;
    }
}

void inversion_arr(struct Arr *pArr)
{
   int i = 0,j = pArr->cnt - 1;
   int temp;
   while(i < j)
   {
       temp = pArr->pBase[i];
       pArr->pBase[i] = pArr->pBase[j];
       pArr->pBase[j] = temp;
       i++;
       j--;
   }
}

//冒泡排序
void sort_arr(struct Arr * pArr)
{
    int temp;
    for(int i = 0;i < pArr->cnt - 1;i++)
    {
        for(int j = 0;j < pArr->cnt - i -1;j++)
        {
            if(pArr->pBase[j] > pArr->pBase[j+1])
            {
               temp = pArr->pBase[j];
               pArr->pBase[j] = pArr->pBase[j+1];
               pArr->pBase[j+1] = temp;
            }
        }
    }
}