动态数组，数组初始化，数组内存释放，向数组中添加一个元素，向数组中添加多个元素，数组打印，顺序查找，二分查找，查寻数组并返回地址，冒泡排序，改变数组中某个元素的值，删除一个数值，删除所有，查找含有
1定义接口：
Num.h
#ifndef_NUM_H_
#define_NUM_H_
#include<stdio.h>
#include<stdlib.h>
/************************************************************************/
/*数组的结构体类型 */
/************************************************************************/
structarraystruct
{
int *p; //指针保存数组的起始点
intlength; //保存数组的长度
intstate; //数组的状态，0代表无序，1代表有序从小到大，2有序从大到小
intreallength;//实际存储在数组中的数值的数量
};
/************************************************************************/
/*所查的目标数的存储位置的结构体 */
/************************************************************************/
structtargetnumaddr
{
int **pp; //存放的是查到的数值的地址，这里是一个数组
intaddrlen; //保存地址的数组的长度
};
//增加，删除，查找（顺序查找，二分查找），修改，排序（冒泡查找）,插入
/************************************************************************/
/*初始化数组 */
/************************************************************************/
externvoidinit(structarraystruct *pdata);
/************************************************************************/
/*重新初始化数组，目的是释放内存 */
/************************************************************************/
externvoidreinit(structarraystruct *pdata);
/************************************************************************/
/*增加一个元素，int num位要增加的值 */
/************************************************************************/
externvoidaddobject(structarraystruct *pdata,intnum);
/************************************************************************/
/*增加一个数组，*pnum表示增加的数组，n:表示增加的数组的大小 */
/************************************************************************/
externvoidaddobjects(structarraystruct *pdata,int *pnum,intn);
/************************************************************************/
/*打印数组的所有内容 */
/************************************************************************/
externvoidprintfall(structarraystruct *pdata);
/************************************************************************/
/*返回第一个找到数据的地址 */
/************************************************************************/
externint *finddata(structarraystruct *pdata,intnum);
/************************************************************************/
/*通过升序的方式实现排序 */
/************************************************************************/
externvoidsortByAsc(structarraystruct *pdata);
/************************************************************************/
/*冒泡排序实现升序排列 */
/************************************************************************/
externvoidBubbleSortAsc(structarraystruct *pdata);
/************************************************************************/
/*冒泡排序实现降序排列 */
/************************************************************************/
externvoidBubbleSortDesc(structarraystruct *pdata);
/************************************************************************/
/*通过选择排序将数组升序排列 */
/************************************************************************/
voidSelectionSortAsc(structarraystruct *pdata);
/************************************************************************/
/*通过选择排序将数组降序排列 */
/************************************************************************/
voidSelectionSortDesc(structarraystruct *pdata);
/************************************************************************/
/*二分查找,查询的是开始数组的排序的是从小到大的情况 */
/************************************************************************/
externint *binarySearchFromAscArr(structarraystruct *pdata,intnum);
/************************************************************************/
/*开始查找，开始查找的数组的顺序是从大到小的顺序 */
/************************************************************************/
externint *binarySearchFromDescArr(structarraystruct *pdata,intnum);
/************************************************************************/
/*升序或者降序，Asc标识升序排列，DESC标识降序排列 */
/************************************************************************/
externvoidsort(structarraystruct *pdata,intAscOrDesc);
/************************************************************************/
/*顺序查找 */
/************************************************************************/
externint *sequenceFind(structarraystruct *pdata,intnum);
/************************************************************************/
/*将数组中制定的值全部替换成新的值 */
/************************************************************************/
externvoidchange(structarraystruct *pdata,intoldnum,intnewnum);
/************************************************************************/
/*删除一个制定的数 */
/************************************************************************/
externvoiddeleteone(structarraystruct *pdata,intnum);
/************************************************************************/
/*删除所有的指定的值 */
/************************************************************************/
externvoiddeleteall(structarraystruct *pdata,intnum);
/************************************************************************/
/*返回一片内存，包含所有找到的元素的首地址，并把这些值封装到结构体中 */
/************************************************************************/
externstructtargetnumaddrfindadlldata(structarraystruct *pdata,intnum);
/************************************************************************/
/*插入数值，headback：1代表前面插入，0代表后面插入 */
/************************************************************************/
externvoidinsert(structarraystruct *pdata,intnum,intinsertnum,intheadback);
#endif
定义Num.c
#include"Num.h"
/************************************************************************/
/*初始化数组 */
/************************************************************************/
voidinit(structarraystruct *pdata)
{
//1.将数组指针初始化为NULL
pdata->p = NULL;
//2.将数组的长度初始化为0
pdata->length = 0;
//3.将数组的状态初始化为0，表示无序的
pdata->state = 0;
//4.实际分配的内存的长度赋值为0
pdata->reallength = 0;
}
/************************************************************************/
/*重新初始化数组，目的是释放内存 */
/************************************************************************/
voidreinit(structarraystruct *pdata)
{
//1.判断结构体里数组是否NULL，如果没有数组的长度等肯定还是位0
if (pdata->p == NULL)
{
return;
}
else
{
//释放内存
free(pdata->p);
//1.将数组指针赋值成NULL
pdata->p = NULL;
//2.将数组的长度复制成0
pdata->length = 0;
//3.将数组的状态复制成0，表示无序的
pdata->state = 0;
//4.实际分配的内存的大小设置成0
pdata->reallength = 0;
}
}
/************************************************************************/
/*增加一个元素，int num位要增加的值 */
/************************************************************************/
voidaddobject(structarraystruct *pdata,intnum)
{
//首先自动开辟一个内存空间
//1.判断是否已经有值了，如果没有，就用malloc的方式添加，
//如果是realloc就用realloc
if (pdata->p == NULL)
{
pdata->p = (int *)malloc(sizeof(int)* 1);
pdata->length = 1;
pdata->reallength = 1;
pdata->p[pdata->length - 1] = num;
}
else
{
//1.如果数组的长度和值的实际长度相等，那么需要在开辟新的空间
//2.如果数组的长度和值的实际长度不相等，这时候肯定是实际长度小于length
//3.最后的代码可以重构成如下代码
if (pdata->length == pdata->reallength)
{
pdata->p = (int *)realloc(pdata->p,sizeof(int)*(pdata->length + 1));
}
//实际的数组长度增加1
pdata->length += 1;
//实际存储在数组中的数值的数量
pdata->reallength += 1;
//存储数值，赋值
pdata->p[pdata->length - 1] = num;
}
}
/************************************************************************/
/*增加一个数组，*pnum表示增加的数组，n:表示增加的数组的大小 */
/************************************************************************/
voidaddobjects(structarraystruct *pdata,int *pnum,intn)
{
//1、判断数组是否为NULL
if (pdata->p == NULL)
{
//分配空间
pdata->p = (int *)malloc(sizeof(int) * n);
//数组标识增加n个元素
pdata->length = n;
//实际长度
pdata->reallength = n;
for (inti = 0;i <n;i++)
{
//拷贝数组值
pdata->p[i] = pnum[i];
}
}
else
{
//分为两种情况
//1、如果实际长度+n之后小于数组的最大长度，这时候直接赋值
if (pdata->reallength + n <=pdata->length)
{
inti;
for (i = 0; i <n;i++)
{
pdata->p[i + pdata->reallength] = pnum[i];
}
//数组标识增加n个元素
pdata->reallength += n;
}
//如果数组的实际长度+n之后大于数组的能够存储的最大length数，这时候要开辟新空间
else
{
pdata->p = (int *)realloc(pdata->p,sizeof(int)*(pdata->reallength + n));
//数组的最大长度
pdata->length = pdata->reallength + n;
inti;
for (i = 0; i <n;i++)
{
pdata->p[i + pdata->reallength] = pnum[i];
}
//将数组的实际长度增加
pdata->reallength += n;
}
}
}
/************************************************************************/
/*打印数组的所有内容 */
/************************************************************************/
voidprintfall(structarraystruct *pdata)
{
inti ;
for (i = 0; i <pdata->reallength;i++)
{
printf("%d\n",*(pdata->p+i));
}
putchar(10);
}
/************************************************************************/
/*顺序查找 */
/************************************************************************/
int *sequenceFind(structarraystruct *pdata,intnum)
{
inti = 0;
//顺序循环
for (i = 0; i <pdata->reallength;i++)
{
//判断是否相等
if (num == pdata->p[i])
{
//返回一个地址
return &pdata->p[i];
break;//跳出循环
}
}
returnNULL;
}
/************************************************************************/
/*二分查找,查询的是开始数组的排序的是从小到大的情况 */
/************************************************************************/
int *binarySearchFromAscArr(structarraystruct *pdata,intnum)
{
//起始位置
intstart = 0;
//最终位置
intend =pdata->reallength - 1;
while (start <= end)
{
intmiddle = (start + end) / 2;
if (num == pdata->p[middle])
{
//返回地址
return &pdata->p[middle];
}
elseif (num < pdata->p[middle])
{
end =middle - 1;
}
elseif (num > pdata->p[middle])
{
start =middle + 1;
}
}
returnNULL;
}
/************************************************************************/
/*开始查找，开始查找的数组的顺序是从大到小的顺序 */
/************************************************************************/
int *binarySearchFromDescArr(structarraystruct *pdata,intnum)
{
//起始位置
intstart = 0;
//结束位置
intend =pdata->reallength - 1;
while (start < end)
{
intmiddle = (start + end) / 2;
if (pdata->p[middle] == num)
{
//返回地址
return &pdata->p[middle];
}
elseif (pdata->p[middle] > num)
{
start =middle + 1;
}
elseif (pdata->p[middle] < num)
{
end =middle - 1;
}
}
returnNULL;
}
/************************************************************************/
/*返回第一个找到数据的地址 */
/************************************************************************/
int *finddata(structarraystruct *pdata,intnum)
{
if (pdata->state == 0)
{
sequenceFind(pdata,num);
}
elseif (pdata->state == 1)
{
binarySearchFromAscArr(pdata,num);
}
else
{
binarySearchFromDescArr(pdata,num);
}
returnNULL;
}
/************************************************************************/
/*通过升序的方式实现排序,冒泡排序 */
/************************************************************************/
voidBubbleSortAsc(structarraystruct *pdata)
{
inti,j;
for (i = 0; i <pdata->reallength - 1;i++)
{
for (j = 0; j <pdata->reallength - i - 1;j++)
{
//将两个值替换(如果前面的大于后面的，替换，排序完成之后最后的数值一定大于之前的数值)
if (pdata->p[j] > pdata->p[j + 1])
{
pdata->p[j] = pdata->p[j] ^ pdata->p[j + 1];
pdata->p[j + 1] = pdata->p[j] ^ pdata->p[j + 1];
pdata->p[j] = pdata->p[j] ^ pdata->p[j + 1];
}
}
}
//代表从小到大
pdata->state = 1;
}
/************************************************************************/
/*通过降序的方式实现排序 */
/************************************************************************/
voidBubbleSortDesc(structarraystruct *pdata)
{
inti,j;
for (i = 0; i <pdata->reallength - 1;i++)
{
for (j = 0; j <pdata->reallength - i - 1;j++)
{
//将两个值替换(如果前面的小于后面的，替换，排序完成之后最后的数值一定小于之前的数值)
if (pdata->p[j] < pdata->p[j + 1])
{
pdata->p[j] = pdata->p[j] ^ pdata->p[j + 1];
pdata->p[j + 1] = pdata->p[j] ^ pdata->p[j + 1];
pdata->p[j] = pdata->p[j] ^ pdata->p[j + 1];
}
}
}
//代表从大大小
pdata->state = 0;
}
/************************************************************************/
/*通过选择排序将数组升序排列 */
/************************************************************************/
//voidSelectionSortAsc(struct arraystruct *pdata)
//{
// int i, j,min;
// for (i = 0; i < pdata->reallength;i++)
// {
// min =i;
// //每次从i的下一个元素开始查找和替换
// for (j = i + 1; j <pdata->reallength;j++)
// {
// if (pdata->p[min] >pdata->p[j])
// {
// min = j;
// }
// }
// pdata->p[i] = pdata->p[i] ^pdata->p[min];
// pdata->p[min] = pdata->p[i] ^pdata->p[min];
// pdata->p[i] = pdata->p[i] ^pdata->p[min];
// }
// pdata->state = 1;
//}
//
///************************************************************************/
///*通过选择排序将数组降序排列 */
///************************************************************************/
//voidSelectionSortDesc(struct arraystruct *pdata)
//{
// int i, j, max;
// for (i = 0; i < pdata->reallength; i++)
// {
// max = i;
// for (j = i + 1; j <pdata->reallength; j++)
// {
// if (pdata->p[i] < pdata->p[j])
// {
// max = j;
// }
// }
// pdata->p[i] = pdata->p[i] ^pdata->p[max];
// pdata->p[max] = pdata->p[i] ^pdata->p[max];
// pdata->p[i] = pdata->p[i] ^pdata->p[max];
// }
// pdata->state = 0;
//}
/************************************************************************/
/*升序或者降序，Asc标识升序排列，DESC标识降序排列 */
/************************************************************************/
voidsort(structarraystruct *pdata,intAscOrDesc)
{
if (AscOrDesc == 0)
{
BubbleSortDesc(pdata);
}
else
{
BubbleSortAsc(pdata);
}
}
/************************************************************************/
/*将数组中制定的值全部替换成新的值 */
/************************************************************************/
voidchange(structarraystruct *pdata,intoldnum,intnewnum)
{
//首先找到地址信息，如果找到了才可以将原来的值修改
int *p = finddata(pdata,oldnum);
if (p == NULL)
{
printf("修改失败，没有找到");
return;
}
else
{
*p =newnum;
}
}
/************************************************************************/
/*删除一个制定的数 */
/************************************************************************/
voiddeleteone(structarraystruct *pdata,intnum)
{
//首先查找到数值的地址
int *p = finddata(pdata,num);
if (p == NULL)
{
return;//没有找到
}
else
{
intcurr =p -pdata->p;
for (inti =curr;i <pdata->length - 1;i++)
{
//从后向前移动
pdata->p[i] = pdata->p[i + 1];
}
//数组元素减1
pdata->reallength -= 1;
}
}
/************************************************************************/
/*删除所有的指定的值 */
/************************************************************************/
voiddeleteall(structarraystruct *pdata,intnum)
{
for (int *p =finddata(pdata,num);p !=NULL;p =finddata(pdata,num))
{
int curr =p -pdata->p;//cur就是要删除的下标
for (inti =curr;i <pdata->reallength - 1; i++)
{
pdata->p[i] = pdata->p[i + 1];//从后向前移动
}
pdata->reallength -= 1;//数组元素减去1
}
}
int *find(int *p,intnum,intn)
{
for (inti = 0;i <n;i++)//循环
{
if (p[i] == num)//判断
{
returnp +i;//返回找到的地址
break;
}
}
returnNULL;//代表没有找到
}
/************************************************************************/
/*返回一片内存，包含所有找到的元素的首地址，并把这些值封装到结构体中 */
/************************************************************************/
structtargetnumaddrfindadlldata(structarraystruct *pdata,intnum)
{
structtargetnumaddrres1;//构建结构体变量
inti = 0;//统计找到多少个。
for (int *p =find(pdata->p,num,pdata->reallength - 1); p !=NULL;p =find(p + 1, num, (pdata->reallength - 1) - (p -pdata->p)))
{
i++;
}
res1.addrlen = i;//长度
int **pint = (int **)malloc(sizeof(int *)* i);//指针数组
res1.pp = pint;
for (int *p =find(pdata->p,num,pdata->reallength - 1), j = 0;p !=NULL;j++,p =find(p + 1, num, (pdata->reallength - 1) - (p -pdata->p)))
{
//循环赋值
pint[j] = p;
}
returnres1;
}
/************************************************************************/
/*插入数值，headback：1代表前面插入，0代表后面插入 */
/************************************************************************/
voidinsert(structarraystruct *pdata,intnum,intinsertnum,intheadback)
{
int *p = finddata(pdata,num);//查找数据
if (p == NULL)
{
return;//没有找到
}
else
{
//找到,前面插入，否则后面插入
if (headback == 1)
{
if (pdata->reallength < pdata->length)//不需要分配
{
int curr =p -pdata->p;//获取要插入位置的下标
for (inti =pdata->reallength - 1; i >=curr;i--)
{
//从后向前移动
pdata->p[i + 1] = pdata->p[i];
}
//实现插入，前面插入
pdata->p[curr] = insertnum;
//长度加1
pdata->reallength++;
}
else
{
//获取要插入位置的下标
int curr =p -pdata->p;
//增加分配内存
pdata->p = (int *)realloc(pdata->p, (pdata->length + 1)*sizeof(int));
//实际长度+1
pdata->reallength++;
for (inti =pdata->reallength - 1; i >=curr;i--)
{
pdata->p[i + 1] = pdata->p[i];//从后向前移动
}
pdata->p[curr] = insertnum;//实现插入，前面插入
pdata->length++;//长度加1
}
}
else
{
if (pdata->length<pdata->reallength)//不需要分配
{
int curr =p -pdata->p;//获取要插入位置的下标
for (inti =pdata->reallength - 1; i >curr;i--)//实现移动
{
pdata->p[i + 1] = pdata->p[i];//从后向前移动
}
pdata->p[curr + 1] = insertnum;//实现插入，hou插入
pdata->length++;//长度加1
}
else
{
int curr =p -pdata->p;//获取要插入位置的下标
pdata->p = (int *)realloc(pdata->p, (pdata->length + 1)*sizeof(int));//增加分配内存
pdata->reallength++;//实际长度+1；
for (inti =pdata->reallength - 1; i >curr;i--)//实现移动
{
pdata->p[i + 1] = pdata->p[i];//从后向前移动
}
pdata->p[curr + 1] = insertnum;//实现插入，hou插入
pdata->length++;//长度加1
}
}
}
}