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



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

           }

       }

   }

}

 

时间: 2024-02-19 12:20:11

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

JavaScript实现点击单选按钮改变输入框中文本域内容的方法_javascript技巧

本文实例讲述了JavaScript实现点击单选按钮改变输入框中文本域内容的方法.分享给大家供大家参考.具体如下: 这里实现点击单选按钮改变输入框中文本域内容的方法,是一个JavaScript 的简单应用,可以减少用户的输入,提升用户操作易用性,它类似一个TAB选项卡一样的功能,并可以完成后提交表单,值得学习. 运行效果截图如下: 具体代码如下: <html> <head> <title>JavaScript点击单选框改变输入框内容</title> </

Java数组,去掉重复值、增加、删除数组元素的方法_java

如下所示: import java.util.List; import java.util.ArrayList; import java.util.Set; import java.util.HashSet; public class lzwCode { public static void main(String [] args) { testA(); System.out.println("==========================="); testB(); System

删除数组条目中重复的条目(可能有多个),返回值是一个仅包含被删除的重复条目的新数组。_javascript技巧

今日在bluediea看到淘宝在线招聘,相信淘宝的技术还是很牛的,于是赶紧打开看看题目并试着做做. 到了第三题时卡了偶老半天,并不是做不出来,感觉有很简便的方法但自己就是一时想不出来,不过费了九牛二虎之力终于完成本题,给出了一个另自己还比较满意的答案,欢迎各位朋友指点! 题目如下: 请给Array本地对象增加一个原型方法,它的用途是删除数组条目中重复的条目(可能有多个),返回值是一个仅包含被删除的重复条目的新数组. [Ctrl+A 全选 注:如需引入外部Js需刷新才能执行] 复制代码 代码如下:

释放动态申请数组内存-C++中动态申请的数组内存异常时内存释放问题

问题描述 C++中动态申请的数组内存异常时内存释放问题 在C++的一个方法中动态申请了一段数组的内存,还未通过delete[] 语句释放这段内存,方法异常,此时代码不会执行后面的delete[] 语句了,那么前面申请的这段数组内存怎么释放? C++中的auto_prt只支持单个对象动态内存的管理,对于数组动态申请的内存怎么管理? 解决方案 应该在运行期系统自动帮你归还,前提是你的数组是由class构成,但不是内置类型.详见EFFECTIVE C++第三版条款52(写了placement new也

c++-用new申请了一个结构体数组,delete时内存错误

问题描述 用new申请了一个结构体数组,delete时内存错误 strong text //////////////////////////////////////CLOCK算法部分//////////////////void CLOCK(){ arr *page_t; int ijpointertimes=0flag=-1num=0;//pointer为查找位置 page_t=new arr[m];//==============================开始计算============

[WinForm]在一个界面把值用一个数组保存然后存到一个实体类中.

问题描述 界面有多个TxtBox值... 解决方案 解决方案二:怎么实现?高手来挖解决方案三:this.m_texts=newstring[textBoxes.Length];for(inti=0;i<textBoxes.Length;i++){m_texts[i]=textBoxes[i].Text;} 解决方案四:List<string>list=newList<string>();foreach(Controlcinthis.Controls){if(c.GetType

c语言-C语言数组删除指定数值问题....

问题描述 C语言数组删除指定数值问题.... int b; int a[5] = { 1, 2, 3, 4, 5 }; scanf_s("%d",&b); int r = 0; int i; for ( i = 0; i<5; i++){ if (b == a[i]){//要删除的数据 a[i] = r; } else{ printf("%dn",a[i]); } }//这样的话确实能删除一个数,但是如果我真的想把数值0肤赋值给数组中的元素呢?怎么办?

c语言中字符数组系统初始化为什么?

问题描述 c语言中字符数组系统初始化为什么? c语言中声明一个字符数组,如果自己没有初始化,那系统初始化为什么?是被初始化为空字符吗?我的实验结果好像是空字符 解决方案 在debug调试下,vc会将它初始化为0xcc 0xcc...,也就是"烫烫烫烫...",release运行的时候,vc++不会初始化,内容随机,但是很大可能是0,因为只有在堆内存被重新分配的时候,才可能出现其他值. 其它编译器不好说. 解决方案二: C语言字符数组的初始化C语言字符数组的初始化

java-JAVA中数组定义new分配内存空间的问题

问题描述 JAVA中数组定义new分配内存空间的问题 JAVA中在定义一个数组的时候,根据书上内容形式,举一个例子 int[] arr=new int[]{3,4,5,}; 但是在实际中,我见到过或者使用更多的是 int[] arr={3,4,5}; 这个时候要不要new去分配内存又有什么区别呢? 在JAVA中 是不是没有new 分配的时候 数组arr在内存栈中 new分配内存空间时 数组arr就到了堆内存中呢 解决方案 现在也不是很理解,找了一个大神告诉我说 第二种是静态初始化,在编译的时候就