编写了几个对数组进行多样操作的函数：初始化，追加，插入，删除，访问，判空，判满，排序，打印，倒置。
/*线性结构：把所有的结点(具有单个逻辑意义的个体)用一根直线穿起来
数组：元素类型相同，占内存大小相等*/
/*线性结构：把所有的结点(具有单个逻辑意义的个体)用一根直线穿起来
数组：元素类型相同，占内存大小相等*/
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的值从0(数组第一个数据)开始，在第pos个元素的前面插入元素
bool delete_arr(struct Arr* pArr,int pos,int* pval);
//删除 第二个参数是删除的位置，pos的值从0(数组第一个数据)开始。第三个参数是
//第三个参数是待删除元素的地址 函数执行成功 对其进行访问就可以得到删除的元素是谁
int get(struct Arr* pArr,int n);
//获取数组n号元素
bool is_full(struct Arr* pArr);
//判断数组是否为满
bool is_empty(struct Arr* pArr);
//判断数组是否为空
void sort_arr(struct Arr* pArr);
//将数组元素自小到大排序
void show_arr(struct Arr* pArr);
//展示数组
void inversion_arr(struct Arr* pArr);
//数组倒置
#include<stdlib.h>
#include<stdio.h>
#include<malloc.h>
int main(void)
{
struct Arr arr;
init_arr(&arr,10);
append_arr(&arr,0);
append_arr(&arr,1);
append_arr(&arr,2);
append_arr(&arr,3);
append_arr(&arr,4);
append_arr(&arr,5);
append_arr(&arr,6);
append_arr(&arr,7);
append_arr(&arr,8);
insert_arr(&arr,0,9); //插入测试
//int a;
//delete_arr(&arr,5,&a);
//printf("删除的是:%d\n",a); //删除测试
//inversion_arr(&arr); //倒序测试
//sort_arr(&arr); //排序测试
//int b = get(&arr,3);
//printf("%d",b); //获取数组n号元素测试
show_arr(&arr);
printf("当前有效元素个数：%d\n",(&arr) ->cnt);
return 0;
}
void init_arr(struct Arr* pArr,int length)
{
pArr -> pBase = (int*)malloc(sizeof(int) * length);
//这个函数会分配内存，如果分配不成功会返回null的
if(NULL == pArr -> pBase)
{
printf("动态内存分配失败！\n");
exit(-1);
}
else
{
pArr->len = length;
pArr->cnt = 0;
}
return;
}
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 is_empty(struct Arr* pArr)
{
if(0 == pArr->cnt)
return true;
else
return false;
}
bool append_arr(struct Arr* pArr,int val)
{
if(is_full(pArr))
return false; //数组满返回false
else //不满时追加
/*对应关系：
pArr->pBase[0] = 1; cnt = 1
pArr->pBase[1] = 1; cnt = 2
pArr->pBase[2] = 1; cnt = 3 所以说怎么追加？ */
{
pArr->pBase[pArr->cnt] = val;
(pArr->cnt)++; //当前有效元素个数+1
return true;
}
}
bool is_full(struct Arr* pArr)
{
if(pArr->cnt == pArr->len)
return true;
else
return false;
}
bool insert_arr(struct Arr* pArr,int pos,int val)
//我想在某个地方插入某个元素，现要将这个位置后面的所有元素向后移位1
{
int i;
if (is_full(pArr))
return false; //满了你还插啥？
else if(pos < 0 || pos > pArr->cnt)//1.pos不能大于有效个数，当等于有效个数的时候，相当于追加。2.不能小于0
return false;
else
{
if (pos == pArr->cnt)
{
append_arr(pArr, val);
return true;
}
else
{
for(i = pArr->cnt-1; i >= pos ; --i)
{
pArr->pBase[i+1] = pArr->pBase[i];//后项=前项 开始移位
}
pArr->pBase[pos] = val;
(pArr->cnt)++; //当前有效元素个数+1
return true;
}
}
}
bool delete_arr(struct Arr* pArr,int pos,int* pVal)
{
if(is_empty(pArr))
return false;
else if(pos < 0 || pos >= pArr -> cnt)//pos 不能小于0 而且需要小于有效元素个数，因为我们是从0算起的
return false;
else
{
*pVal = pArr->pBase[pos];
for(int i=pos; i < pArr->cnt-1;++i)
{
pArr->pBase[i] = pArr->pBase[i+1];
}
(pArr->cnt) --; //数组有效数字 -1
return true;
}
}
void inversion_arr(struct Arr* pArr)
{
int i = 0; //数组首数据下标
int 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 i,j,temp;
for(i=0; i < pArr->cnt; ++i)
{
for(j = i+1; j<pArr->cnt; ++j)
{
if(pArr->pBase[i] > pArr->pBase[j])
{
temp = pArr->pBase[i];
pArr->pBase[i] = pArr->pBase[j];
pArr->pBase[j] = temp;
}
}
}
}
int get(struct Arr* pArr,int n)
{
return pArr->pBase[n];
}
