数据结构数组接口和封装

最新推荐文章于 2023-12-14 15:59:45 发布
最新推荐文章于 2023-12-14 15:59:45 发布
阅读量494 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y8350318/article/details/44197143
版权
/*********************************************************
*文件名： 动态数组.h
*创建者：ycj
*创建时间：2015-3-10
*文件说明：动态数组的增加，删除，查找，修改,排序,插入的声明
**********************************************************/


#include <stdio.h>
#include <stdlib.h>


//动态数组的属性
struct data
{
int *p;//指针保存数组的起始点
int length;//保存数组的长度
int stat;//0代表无序，1代表有序从小到大，2代表从大到小
int reallength;//实际分配的内存长度
};


//保存findalldata中数据的个数和地址
struct findres
{
int **pp;//指针保存找到的元素的地址（指针数组）
int n;//保存找到数值的个数
};


void init(struct data *pdata);//初始化


void reinit(struct data *pdata);//使用之后初始化


void addobject(struct data *pdata, int num);//增加一个数据


void addobjects(struct data *pdata, int *pnum, int n);//增加一个数组
//pnum：指向数组，n：数组元素个数


void printfall(struct data *pdata);//打印所有的数据


void sort(struct data *pdata, int flag);//排序
//obj=0;.从小到大，否则从大到小


int *finddata(struct data *pdata, int num);//查找首次出现的数据


void change(struct data *pdata, int oldnum, int newnum);//实现修改


void insert(struct data *pdata, int num, int insertnum, int headback);//数据插入
//headback:1代表前面插入，0代表后面插入,num表示插入数据位置


void deletone(struct data *pdata, int num);//删除第一个找到的数据


struct findres findalldata(struct data *pdata, int num);//找出所有的相同的数据
//返回一个结构体，包含找到元素的个数和地址

void deletall(struct data *pdata, int num);//删除所有能找到的数据




/*********************************************************
*文件名： 动态数组.c
*创建者：ycj
*创建时间：2015-3-10
*文件说明：实现动态数组的增加，删除，查找，修改,排序,插入
**********************************************************/
#include "动态数组.h"


//初始化
void init(struct data *pdata)//使用之前初始化
{
pdata->p = NULL;//意味着还没有初始化
pdata->length = 0;//长度为0
pdata->stat = 0;//代表无序
pdata->reallength = 0; //实际长度
}


//使用之后初始化
void reinit(struct data *pdata)
{
if (pdata->p == NULL)
{
return;
}
else
{
free(pdata->p);//释放内存
pdata->p = NULL;//意味着还没有初始化
pdata->length = 0;//长度为0
pdata->stat = 0;//代表无序
pdata->reallength = 0; //实际长度
}
}


//增加一个数据
void addobject(struct data *pdata, int num)
{
if (pdata->p == NULL)
{
pdata->p = (int *)malloc(sizeof(int));//增加一个数据
pdata->length += 1;//数组标识增加一个元素
pdata->reallength += 1; //实际长度
pdata->p[pdata->length - 1] = num;//赋值
}
else
{
if (pdata->length == pdata->reallength)//判断是否有空余空间
{
pdata->p = (int *)realloc(pdata->p, (pdata->length + 1) * sizeof(int));
pdata->length += 1;//数组标识增加一个元素
pdata->reallength += 1; //实际长度
pdata->p[pdata->length - 1] = num;//赋值
}
else
{
pdata->length += 1;//数组标识增加一个元素
pdata->p[pdata->length - 1] = num;//赋值
}
}
}


//增加一个数组
void addobjects(struct data *pdata, int *pnum, int n)//数组作为参数退化为指针
{
if (pdata->p == NULL)
{
pdata->p = (int *)malloc(sizeof(int) * n);//增加n个数据
for (int i = 0; i < n; i++)
{
pdata->p[i] = pnum[i];//拷贝数组
}
pdata->length += n;//数组标识增加n个元素
pdata->reallength += n; //实际长度
}
else
{
if (pdata->length + n <= pdata->reallength)//判断是否有空余空间
{
for (int i = 0; i < n; i++)
{
pdata->p[i + pdata->length] = pnum[i];//拷贝数组
}
pdata->length += n;//数组标识增加n个元素
}
else
{
pdata->p = (int *)realloc(pdata->p, (pdata->length + n) * sizeof(int));//重新分为内存
for (int i = 0; i < n; i++)
{
pdata->p[i + pdata->length] = pnum[i];//拷贝数组
}
pdata->length += n;//数组标识增加n个元素
pdata->reallength += n; //实际长度
}
}

}


//打印所有的数据
void printfall(struct data *pdata)
{
for (int i = 0; i < pdata->length; i++)
{
printf("%d\n", pdata->p[i]);
}
}


//数组排序（冒泡法）
void sort(struct data *pdata, int flag)//obj=0;从小到大，否则从大到小
{
if (flag == 0)
{
for (int i = 0; i < pdata->length - 1; i++)
{
for (int j = 0; j < pdata->length - 1 - i; 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->stat = 1;//代表有序，从小到大
}
else
{
for (int i = 0; i < pdata->length - 1; i++)
{
for (int j = 0; j < pdata->length - 1 - i; 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->stat = 2;//代表有序，从大到小
}
}


//查找数据
int * finddata(struct data *pdata, int num)
{
if (pdata->stat == 0)
{
for (int i = 1; i < pdata->length; i++)//顺序循环
{
//printf("查找第%d次\n", i);
if (num == pdata->p[i])//判定是否相等
{
return &pdata->p[i];//返回一个地址
}
}
return NULL;
}
else if (pdata->stat == 1)//二分查找法,从小到大
{
int tou = 0;
int wei = pdata->length - 1;
int zhong = (tou + wei) / 2;
while (tou <= wei)//循环终止条件
{
zhong = (tou + wei) / 2;
//printf("tou=%d,zhong=%d,wei=%d\n", tou, zhong, wei);
if (num == pdata->p[zhong])
{
return &pdata->p[zhong];//返回一个地址
}
else if (num > pdata->p[zhong])
{
tou = zhong + 1;
}
else
{
wei = zhong - 1;
}
}
return NULL;
}
else//二分查找法//从大到小
{
int tou = 0;
int wei = pdata->length - 1;
int zhong = (tou + wei) / 2;
while (tou <= wei)//循环终止条件
{
zhong = (tou + wei) / 2;
//printf("tou=%d,zhong=%d,wei=%d\n", tou, zhong, wei);
if (num == pdata->p[zhong])
{
return &pdata->p[zhong];//返回一个地址
}
else if (num < pdata->p[zhong])
{
tou = zhong + 1;
}
else
{
wei = zhong - 1;
}
}
return NULL;
}
}


//从一个地址开始，N个范围之内找到(内部调用)
int * find(int *p, int num, int n)
{
for (int i = 0; i < n; i++)
{
if (p[i] == num)
{
return p + i;
}
}
return NULL;//代表没有找到
}


//返回一个结构体，包含找到元素的个数和地址
struct findres findalldata(struct data *pdata, int num)
{
//实际开发用链表，一个接着，接着（这里用数组简单实现）
struct findres res1;//构建结构体变量
int i = 0;
for (int *p = find(pdata->p, num, pdata->length); p != NULL; p = find(p + 1, num, (pdata->length) - (p - pdata->p + 1)))
{
i++;
}
//printf("%d\n", i);
res1.n = i;
int **pint = (int **)malloc(sizeof(int *) * i);//指针数组
res1.pp = pint;
int j = 0;
for (int *p = find(pdata->p, num, pdata->length); p != NULL; j++, p = find(p + 1, num, (pdata->length) - (p - pdata->p + 1)))
{
pint[j] = p;//循环赋值
//printf("%p,%d\n", pint[j], *pint[j]);
}
return res1;
}


//实现修改
void change(struct data *pdata, int oldnum, int newnum)
{
int *p = finddata(pdata, oldnum);
if (p == NULL)
{
printf("修改失败，没有找到\n");
}
else
{
*p = newnum;//修改数据
}
}


//数据插入
void insert(struct data *pdata, int num, int insertnum, int headback)
{
int *p = finddata(pdata, num);//找到数据
if (p == NULL)
{
printf("插入失败，没有找到\n");
return;//没有找到
}
else
{
//找到，1前面插入,否则后面插入
if (headback == 1)
{
if (pdata->length < pdata->reallength)//不需要分配内存
{
int curr = p - pdata->p; //获取要插入位置的下标
for (int i = pdata->length - 1; i >= curr; i--)
{
pdata->p[i + 1] = pdata->p[i];//从后往前移动
}
pdata->p[curr] = insertnum;
pdata->length += 1;//长度加1
}
else
{
int curr = p - pdata->p;
pdata->p = (int *)realloc(pdata->p, (pdata->length + 1) * sizeof(int));//增加分配内存
pdata->reallength += 1; //实际长度
for (int i = pdata->length - 1; i >= curr; i--)
{
pdata->p[i + 1] = pdata->p[i];//从后往前移动
}
pdata->length += 1;//长度加1
pdata->p[curr] = insertnum;//实现插入，前面插入
}


}
else
{
if (pdata->length < pdata->reallength)//不需要分配内存
{
int curr = p - pdata->p; //获取要插入位置的下标
for (int i = pdata->length - 1; i > curr; i--)
{
pdata->p[i + 1] = pdata->p[i];//从后往前移动
}
pdata->p[curr + 1] = insertnum;//实现插入，后面插入
pdata->length += 1;//长度加1
}
else
{
int curr = p - pdata->p;
pdata->p = (int *)realloc(pdata->p, (pdata->length + 1) * sizeof(int));//增加分配内存
pdata->reallength += 1; //实际长度
for (int i = pdata->length - 1; i > curr; i--)
{
pdata->p[i + 1] = pdata->p[i];//从后往前移动
}
pdata->p[curr + 1] = insertnum;//实现插入，后面插入
pdata->length += 1;//长度加1
}
}
}
return;
}


//删除第一个找到的数据
void deletone(struct data *pdata, int num)
{
int *p = finddata(pdata, num);//查找数据
if (p == NULL)
{
printf("not find!\n");
return;//没有找到
}
else
{
int curr = p - pdata->p;//元素的下标
//printf("%d,%p\n", *p, p);
//printf("%d,%p\n", pdata->p[curr], &pdata->p[curr]);
for (int i = curr; i < pdata->length - 1; i++)
{
pdata->p[i] = pdata->p[i + 1];
}
pdata->length -= 1;//数组元素减去1
}
}


//删除全部
void  deleteall(struct data *pdata, int num) //删除所有能找到的数据
{
for (int *p = finddata(pdata, num); p != NULL; p = finddata(pdata, num))
{
int  curr = p - pdata->p;//cur就是要删除的下标
//printf("\n%d,%p", *p, p);
//printf("\n%d,%p", pdata->p[curr], &pdata->p[curr]);//输出数据
for (int i = curr; i < pdata->length - 1; i++)
{
pdata->p[i] = pdata->p[i + 1];//从后向前移动
}
pdata->length -= 1;//数组元素减去1


}
}


/*********************************************************
*文件名： test.c
*创建者：ycj
*创建时间：2015-3-10
*文件说明：测试各模块
**********************************************************/

#include <stdio.h>
#include <stdlib.h>
#include "动态数组.h"
#pragma comment(lib, "数组lib.lib")//引用静态库


//两种测试方式
void main()
{
int a[10] = { 231, 112, 1233, 14123, 112, 116, 71, 11, 29, 11252 };
struct data *pdata = (struct data *)malloc(sizeof(struct data));//pdata存在堆上
init(pdata);
addobject(pdata, 100);
reinit(pdata);


addobject(pdata, 10);
addobjects(pdata, a, 10);
change(pdata, 14123, 0);
deletone(pdata, 11252);
sort(pdata, 0);//obj=0;从小到大，否则从大到小
printfall(pdata);


printf("\n\n");
//测试insert模块
insert(pdata, 29, 1111, 0);
insert(pdata, 29, 1111, 1);


printfall(pdata);


printf("\n\n");


//测试finddata模块
//块语句屏蔽信息
{
int *pfind = finddata(pdata, 1233);
if (pfind != NULL)
{
printf("查找结果：%d,%p\n", *pfind, pfind);//输出查找结果
}
else
{
printf("not find\n");
}
}


{
int *pfind = finddata(pdata, 1);
if (pfind != NULL)
{
printf("查找结果：%d,%p\n", *pfind, pfind);//输出查找结果
}
else
{
printf("not find\n");
}
}


//测试findalldata模块
{
struct findres res1 = findalldata(pdata, 112);
for (int i = 0; i < res1.n; i++)
{
printf("res1 %p,%d\n", *(res1.pp + i), **(res1.pp + i));//二级指针遍历指针数组
}
free(res1.pp);//释放内存
}


system("pause");
}






void main1()
{
int a[10] = { 231, 112, 1233, 14123, 112, 116, 71, 11, 29, 11252 };
struct data  data1;//data1存在栈上
//测试init，addobject，addobjects,change,deletone,sort,printfall模块
init(&data1);
addobject(&data1, 100);
reinit(&data1);


addobject(&data1, 10);
addobjects(&data1, a, 10);
change(&data1, 14123, 0);
deletone(&data1, 11252);
sort(&data1, 0);//obj=0;从小到大，否则从大到小
printfall(&data1);


printf("\n\n");
//测试insert模块
insert(&data1, 29, 1111, 0);
insert(&data1, 29, 1111, 1);


printfall(&data1);


printf("\n\n");


//测试finddata模块
//块语句屏蔽信息
{
int *pfind = finddata(&data1, 1233);
if (pfind != NULL)
{
printf("查找结果：%d,%p\n", *pfind, pfind);//输出查找结果
}
else
{
printf("not find\n");
}
}


{
int *pfind = finddata(&data1, 1);
if (pfind != NULL)
{
printf("查找结果：%d,%p\n", *pfind, pfind);//输出查找结果
}
else
{
printf("not find\n");
}
}


//测试findalldata模块
{
struct findres res1 = findalldata(&data1, 112);
for (int i = 0; i < res1.n; i++)
{
printf("res1 %p,%d\n", *(res1.pp + i), **(res1.pp + i));//二级指针遍历指针数组
}
free(res1.pp);//释放内存
}


system("pause");
}


y8350318
关注
前端学习（2452）：封装数据接口
歌谣的博客
10-21 305
request.js <template> <div class="artical-container"> <!--卡片--> <el-card class="filter-card"> <div slot="header" class="clearfix"> <!--面包屑导航--> <el-breadcrumb separator-class="el-icon-arrow-ri...
前端学习（2477）：封装数据接口
歌谣的博客
10-27 384
request.js <template> <div class="artical-container"> <!--卡片--> <el-card class="filter-card"> <div slot="header" class="clearfix"> <!--面包屑导航--> <el-breadcrumb separator-class="el-icon-arrow-right
接口的封装
最新发布
weixin_74792796的博客
12-14 569
面向对象封装： 使用类、对象和封装原则，将数据和对数据的操作封装在一起。网络请求封装： 将网络请求的操作封装成函数或类，提供简洁易用的接口。通过良好的接口封装，可以降低代码的耦合性，提高代码的可维护性和可扩展性，并促进团队合作和代码重用。服务接口封装： 将复杂的业务逻辑封装成服务接口，暴露简单的调用方法供其他组件或模块使用。集成测试： 在将接口用于更大的系统时，进行集成测试以确保接口与其他组件协同工作正常。单元测试： 对封装的接口进行单元测试，确保接口在各种情况下都能正确工作。
接口封装
07-19 277
在项目的开发过程中，我们也少不了与后台服务器进行数据的获取和交互，这一般都是通过接口完成的，那么我们如何进行合理的接口配置呢？我们可以在 src 目录下新建 services 文件夹用于存放接口文件： └── src └── services ├── http.js # 接口封装 ├── moduleA.js # A模块接口...
20171124动态数组接口封装完成
ChasingMoon的博客
11-24 285
头文件  动态数组.h #include #include struct data { int *p;//指针保存数组的起始点 int length;//保存数组的长度 int stat;//0代表无序，1代表从小到大，2代表从大到小 int reallength;//实际分配的内存长度 }; //findalldata需要返回地址和个数，所以需要返回一个结构体 struct fin
C++动态数组类的封装实例
09-04
在C++编程中，动态数组是一种非常重要的数据结构，它允许程序员在运行时根据需要动态地改变数组的大小。为了更好地管理和使用动态数组，我们可以对其进行封装，将其抽象成一个类。下面将详细介绍C++动态数组类封装...
【数据结构】动态数组
m0_50987960的博客
11-15 2856
动态数组主要方法的创建以及JVM中ArrayList的使用
Go-Golang一些基础数据结构的封装比如treebitmap等
08-14
总结，Go语言的树和位图数据结构封装为开发者提供了强大的工具，通过合理的封装和优化，可以构建出高效、可靠的软件系统。理解并熟练运用这些数据结构及其封装，对于提升Go程序的性能和可维护性至关重要。在实际编程...
PHP封装XML和JSON格式数据接口操作示例
10-17
示例中的`xmlToEncode`函数递归处理数据结构，将数组的每个键值对转换为XML格式。如果值是数组，则继续递归调用，直至数据结构完全转换为XML节点。 5. 状态码和提示信息。在接口返回数据时，除了数据本身外，通常还...
模板类实现数组类封装模板类实现数组类封装
03-01
在C++中，数组是一种数据结构，它存储同类型的多个元素。数组的大小在声明时必须是常量，并且一旦创建，其大小不能改变。然而，这样的特性有时会限制其使用，特别是在需要动态调整大小或执行更复杂操作时。 为了...
封装接口请求
qq_59076775的博客
04-24 5066
在做项目的时候,我们平常会对接口api进行一些封装。今天来教给大家一些简单的封装接口的方法。 一.request.js文件夹 通常情况下我们会在utils/request.js封装自己的api。 // 1.导入axios import axios from "axios"; // 2.创建axios副本 const _axios = axios.create({ baseURL: process.env.VUE_APP_BASE_API, }); // 3.请求拦截器 _axios.inte
接口类型数组
m1234ilu的博客
10-16 6359
使用接口进行封装以及数据传输
窦哲的专栏
07-04 3872
接口可以理解为一个比较特殊的“类”，我们可以使用接口类型的变量调用接口中定义的方法，那么我们可以使用接口对上行请求和下行消息的方法进行封装，这样就只能调用接口中定义的方法。 我们可以使用回调接口对数据进行传输，把返回的数据返回到合适的位置进行处理。上行请求类图 RequestManager类中实现IInvoke接口，接收上行的请求。同时此类也接收发送请求成功后返回的数据（方法onCallback
接口封装及调用
云计算?
10-19 2133
为了更好地让应用系统进行调用，有的时候需要对接口进行封装，把复杂的东西包起来，让应用系统接口开发者感觉越简单越好。这样你的系统才更容易被推广或应用。比如，现在的很多在线支付接口都提供了软件开发包。我们也可以通过封装来实现接口开发包，让开发人员简单开发，轻松调用。 1．接口封装 我们添加一个SSOLib类库项目，提供对应用系统接口代码的封装，从而使其他应用系统通过调用该类库，即可实现接入认证服...
接口返回json数据后台封装
热门推荐
农夫旁有山泉的博客
04-01 2万+
今天说下json数据格式，规范的格式应该是包括数据返回状态（一般就是false/true），状态码（比如200,7000，这个都是自己定义的），消息（比如“获取数据成功”/“获取数据失败”）,数据对象，以前写项目都是别人把方法写好，自己去调用，今天自己也写一个，其实很简单，老规矩直接上代码；首先定义返回实体Result，这里面重点看下里面的构造函数，用了的方法的重载package com.stev...
数据库API的封装
章鱼之家
01-26 1881
对于要使用数据库的应用来说，一般会由数据库的开发人员提供一套封装好的 API而非直接操作数据库，这样上层应用便不太需要关心如何进行数据的存取等细节问题，更好的代码的封装有利于提高其重用性、可维护性等。当然，对此问题 Hibernate[hbnt]已提供了足够的支持，它提供分页[hbpg]、缓存机制[hbch]。但若由于各种原因，不能或不想使用 hibernate的话，可自己提供一套。1        Hibernate先简单了解下 hibernate做的工作，那么自己要写的接口也是类似的。Hi
避免在 Java 接口中使用数组的 3 个理由
01-18 249
如果你发现在一个接口使用有如下定义方法： ? 1 public String[] getParameters(); 那么你应该认真反思。数组不仅仅老式，而且我们有合理的理由避免暴露它们。在这篇文章中，我将试图总结在Java API中使用数组的缺陷。首先从最出人意料的一个例子开始。 数组导致性能不佳 你可能认为使用数
接口（抽象类），数据抽象，数据封装
SL1109
06-08 898
接口 参学：http://www.runoob.com/cplusplus/cpp-interfaces.html 1.什么是接口？ 接口描述了类的行为和功能，而不需要完成类的特定实现。 C++ 接口是使用抽象类来实现的，抽象类与数据抽象的区别： 数据抽象是一个把实现细节与相关的数据分离开的概念。 如果类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类。 纯虚函数是通过在声明中使...
数据结构：静态一维数组实现栈
总结起来，栈是一种基础且实用的数据结构，静态一维数组的实现方式简单直观，但存在插入和删除效率低、空间不可扩展等问题。理解并熟练运用ADT和信息隐蔽原则，对于设计高效、可复用的算法至关重要。在学习过程中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值