首页 > 代码库 > 动态数组,数组初始化,数组内存释放,向数组中添加一个元素,向数组中添加多个元素,数组打印,顺序查找,二分查找,查找数组并返回地址,冒泡排序,改变数组中某个元素的值,删除一个数值,删除所有,查找含有

动态数组,数组初始化,数组内存释放,向数组中添加一个元素,向数组中添加多个元素,数组打印,顺序查找,二分查找,查找数组并返回地址,冒泡排序,改变数组中某个元素的值,删除一个数值,删除所有,查找含有



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);

 

/************************************************************************/

/*插入数值,headback1代表前面插入,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;

}

 

/************************************************************************/

/*插入数值,headback1代表前面插入,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

           }

       }

   }

}