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
}
}
}
}