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



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

}

}

}

}

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

时间: 07-31

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

java题求代码,4、现在有如下的一个数组: int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} 要求将以上数组中值为0的项去掉,将不为0的值存入一个新的数组,生成的新数组为: int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5}

public class TEST { public static void main(String[] args) { int [] oldArr= {1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}; int [] newArr= new int[oldArr.length] ; int n=0; for (int i=0;i<oldArr.length;i++) { if(oldArr[i]==0) {} else { newArr[n]=oldArr[i]; n++; }

C语言创建一个数组,利用函数调用实现数组的初始化,逆置和清零

★创建一个数组,实现函数init初始化数组.empty清空数组.reverse函数完成数组元素的逆置. #include<stdio.h> #include<stdlib.h> #include<string.h> void menu() { printf("****************************************\n"); printf("***************1.初始化数组*************\n&

C#不允许在foreach循环中改变数组或集合中元素的值(注:成员的值不受影响)

C#不允许在foreach循环中改变数组或集合中元素的值(注:成员的值不受影响),如以下代码将无法通过编译. foreach (int x in myArray) { x++; //错误代码,因为改变了元素的值 Console.WriteLine(x); } 如果要让自定义的数据类型支持foreach循环,则该类型必须实现IEnumerable<T>接口,且存在对应此列表的IEnumerator<T>实现. 实际上,在.Net的底层(IL语言层面)而言, foreach (var

定义一个字符数组并初始化,统计字符&#39;a&#39;或&#39;A&#39;出现的次数

1 package com.imooc.array; 2 3 public class SortDemo2 { 4 5 public static void main(String[] args) { 6 //定义一个字符数组并初始化,统计字符'a'或'A'出现的次数 7 //定义一个字符数组ch并初始化 8 char[] ch={'a','b','c','A','a','d','a','e','f','g'}; 9 //循环遍历数组,统计字符'a'或'A'出现的次数 10 int sum=0;

c语言字符数组的初始化问题

1.字符数组的定义与初始化 字符数组的初始化,最容易理解的方式就是逐个字符赋给数组中各元素. char str[10]={ 'I',' ','a','m',' ',‘h’,'a','p','p','y'}; 即把10个字符分别赋给str[0]到str[9]10个元素 如果花括号中提供的字符个数大于数组长度,则按语法错误处理: 若小于数组 长度,则只将这些字符数组中前面那些元素,其余的元素自动定为空字符(即 '\0' ). 2.字符数组与字符串 在c 语言中,将字符串作为字符数组来处理.(c++中

C/C++ 数组的初始化

C/C++数组的初始化因为方法太多,而且规则也比较混乱,所以在使用的时候经常出现数组初始化就不对的问题,这里把关于数组的初始化存在需要谨慎的问题进行一个简单的总结,有遗漏的望同学们一起指出补充. 一维数组 静态分配 1. int a[3] = {0, 1, 2}; // 正确 int a[3]={0,1,2,3}; //错误,初始化值个数大于数组大小 int a[3]={0,,2}; //错误,初始化值被跳过 int a[3]={0,1,}; //错误,初始化值被跳过(即使是最后一个元素,添加逗

数组的初始化和二维数组、指针与数组

1.数组的初始化,比较简单,实例程如下: #include<stdio.h> # define M 12 int main(void){ int days[M]={31,28,31,30,31,30,31,30,30,31,30,31}; int i; for(i=0;i<M;i++) printf("Months %d has %2d days.\n",i+1,days[i]); return 0; } 运行结果如下: 2.未经初始化的数组: 实例程序: #incl

一维数组的初始化方面

怎样定义一个一维数组: 为N个连续变量分配存储空间 所有的变量数据类型必须相同 所有变量所占的字节大小必须相同 例子: int a[5]; 注意: 一位数组名不代表数组中所有的元素, 一位数组名代表数组中第一个元素的地址. 有关一位数组的操作: 初始化 完全初始化 int a[5] = {1, 2, 3, 4, 5}; 不完全初始化,未被初始化的元素的值自动为零 int a[5] = {1, 2, 3}; 不初始化,所有元素的值垃圾值 int a[5]; 错误的写法: int a[5]; a[5

vb中数组的初始化

vb中数组的初始化 问题: 计划使用数组存储以下值: "零分,班序,年名,序,组名,级名,总分3,总分5,总分9,总序,语序,数序,英序,物序,化序,政序,历序,地序,生序" 方法: 在vb中数组初始化比较麻烦 1.标准做法:     dim field(19) as string '需要手工计算下标上限     fiels(0)="零分" '逐行赋值     field(1)="班序"     ...     field(18)="生