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

}

}

}

}

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

1. ❤️思维导图整理大厂面试高频数组19: 股票问题III的dp数组构建/初始化和空间优化难点, 力扣123❤️

   此专栏文章是对力扣上算法题目各种方法的总结和归纳, 整理出最重要的思路和知识重点并以思维导图形式呈现, 当然也会加上我对导图的详解. 目的是为了更方便快捷的记忆和回忆算法重点(不用每次都重复看题解), ...

2. 深拷贝与浅拷贝~动态内存释放有关

   浅拷贝就是对象的数据成员之间的简单赋值,如你设计了一个没有类而没有提供它的复制构造函数,当用该类的一个对象去给令一个对象赋值时所执行的过程就是浅拷贝,如: class A{ public: A(int ...

3. 在 PHP 中从数组中删除一个元素

   问: 有没有一种简单的方法可以使用 PHP 从数组中删除一个元素,从而使 foreach ($array) 不再包含该元素? 我认为将它设置为 null 会做到这一点,但显然它不起作用. 答1: hu ...

4. LeetCode简单题之删除一个元素使数组严格递增

   题目 给你一个下标从 0 开始的整数数组 nums ,如果 恰好 删除 一个 元素后,数组 严格递增 ,那么请你返回 true ,否则返回 false .如果数组本身已经是严格递增的,请你也返回 tr ...

5. [JS]请给Array本地对象增加一个原型方法，它用于删除数组条目中重复的条目(可能有多个)，返回值是一个包含被删除的重复条目的新数组。

   请给Array本地对象增加一个原型方法,它用于删除数组条目中重复的条目(可能有多个),返回值是一个包含被删除的重复条目的新数组. 刚开始复习js题还不太习惯 CSDN上看了一个帖子,说是牛客上的标答, ...

6. LeetCode 1909. 删除一个元素使数组严格递增

   文章目录 1. 题目 2. 解题 1. 题目 给你一个下标从 0 开始的整数数组 nums ,如果 恰好 删除 一个 元素后,数组 严格递增 ,那么请你返回 true ,否则返回 false . 如果 ...

7. .net 遍历数组找重复值写入一个新数组_面试 | 数组类算法精析

   点击上方蓝字设为星标 每周一.三.五上午 8:30 准时推送 下面开始今天的学习- 面试中的算法问题,有很多并不需要复杂的数据结构支撑.就是用数组,就能考察出很多东西了.其实,经典的排序问题,二分搜索 ...

8. php 清空一个数组_php如何删除一个数组

   php如何删除一个数组2020-07-10 01:16:35 php删除一个数组的方法:1.使用unset函数删除一个数组元素,且保持原有索引不变:2.使用"array_splice&quo ...

9. java 释放数组_java集合ArrayList中clear方法内存释放分析

   最近在看ArrayList源码的时候看到了ArrayList的clear方法,源码如下: public void clear() { modCount++; // clear to let GC do ...

最新文章

1. 2021软科世界大学学术排名发布！哈佛蝉联全球第一，清华位居国内榜首
2. [跟我学UML] UML包图中的包引入和包合并
3. 三国志幻想大陆服务器维护,三国志幻想大陆8月14日更新维护公告
4. 一步步学习微软InfoPath2010和SP2010--第二章节--表单需求：使用决策矩阵（6）--结合基于客户端和基于浏览器的控件...
5. 【简报】超棒的免费Web字体服务：Adobe Edge Web字体
6. axios.all()解决并发请求的问题
7. UVA1594 UVALive4723 Ducci Sequence【vector+set】
8. 2021 ZUST，XCPC选拔赛
9. 【bzoj1050】[HAOI2006]旅行comf 并查集
10. 8.1 Zend_View(2)
11. 射频识别技术漫谈(25)——Felica简介
12. 360摄像机往事：一半芯片江湖，一半理想国度
13. Python基础实战之文字游戏——模拟武侠类场景中的两派战斗场面
14. 暗黑管理系列：发红包的管理杠杆率和量级作用
15. spamhaus反垃圾邮件联盟黑名单PBL申诉详细步骤
16. MP地面站二次开发教程（四）地面站优化及其功能测试
17. PS 移动工具和复制
18. 计算机系统原理题,计算机系统的组成及工作原理试题及答案.doc
19. [原]几条简单命令查询硬件信息
20. 人工智能与高性能计算

热门文章

1. 电网操作：线路、主变、母线操作讲解
2. 爬虫实战：批量爬取京东内衣图片（自动爬取多页，非一页）
3. opengl加载显示3D模型RAW类型文件
4. JavaScript实现按位的isPowerOfTwo算法（附完整源码）
5. wxWidgets：wxValidator概述
6. boost::mpl模块实现insert相关的测试程序
7. boost::gil模块临界点threshold的测试程序
8. boost::fusion::fused_procedure用法的测试程序
9. Boost：字符串的RLE压缩的测试程序
10. ITK:创建一个二进制球结构元素