20171124动态数组接口封装完成

最新推荐文章于 2023-03-18 16:57:08 发布
最新推荐文章于 2023-03-18 16:57:08 发布
阅读量285 收藏
点赞数
分类专栏： C语言学习 文章标签： C

头文件  动态数组.h

#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);//增加一个数组
void printfall(struct data *pdata);//打印数据
void deleteone(struct data *pdata, int num);//删除第一个找到的数据
void deleteall(struct data *pdata, int num);//删除所有能找到的数据
int *finddata(struct data *pdata, int num);//返回第一个找到数据的地址
//int **findalldata(struct data *pdata, int num);//返回一片内存，包含所有的元素
struct findres findalldata(struct data *pdata, int num);//返回一个结构体，里面包含查找的数据地址和个数
void change(struct data *pdata, int oldnum, int newnum);//修改
void sort(struct data *pdata, int obj);//obj=0,从小到大，否则从大到小
void insert(struct data *pdata, int num, int insertnum, int headback);//插入，headback=1前插，否则后插

源文件    动态数组.c 

#include"动态数组.h"

void init(struct data *pdata)//使用之前初始化
{
	pdata->p = NULL;//意味着还没初始化
	pdata->length = 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;
		int 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个元素
		pdata->length = n;
		pdata->reallength = n;
		for (int i = 0; i < n; i++)
		{
			pdata->p[i] = pnum[i];//拷贝数组
		}
	}
	else
	{
		if (pdata->length + n <= pdata->reallength)
		{
			for (int i = 0; i < n; i++)
			{
				pdata->p[pdata->length + i] = pnum[i];
			}
			pdata->length += n;
		}
		else
		{
			pdata->p = (int*)realloc(pdata->p, (pdata->length + n) * sizeof(int));
			for (int i = 0; i < n; i++)
			{
				pdata->p[pdata->length + i] = pnum[i];
			}
			pdata->length += n;
			pdata->reallength += n;
		}
	}
}

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

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

		for (int i = 0; i < pdata->length - 1; i++)
		{
			for (int j = 0; j < pdata->length - i - 1; j++)
			{
				if (pdata->p[j] > pdata->p[j + 1])// j >j+1  
				{
					int temp = pdata->p[j]; //交换数据
					pdata->p[j] = pdata->p[j + 1];
					pdata->p[j + 1] = temp;
				}
			}
		}
		pdata->stat = 1;//代表从小到大
	}
	else
	{
		for (int i = 0; i < pdata->length - 1; i++)
		{
			for (int j = 0; j < pdata->length - i - 1; j++)//冒泡没循环一次，沉底一个极值
			{
				if (pdata->p[j] < pdata->p[j + 1])// j <j+1  
				{
					//int temp = pdata->p[j]; //交换数据
					//pdata->p[j] = pdata->p[j + 1];
					//pdata->p[j + 1] = temp;
					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 = 0; i < pdata->length; i++)//顺序循环
		{
			printf("查找第%d次\n", i);
			if (num == pdata->p[i])//判定是否相等
			{
				printf("找到%d\n", pdata->p[i]);
				return  &pdata->p[i];//返回一个地址
				break;//跳出循环
			}
		}
		return NULL;
	}
	else if (pdata->stat == 1)//从小到大，用二分查找法
	{

		int shang = 0;
		int xia = pdata->length - 1;
		while (shang <= xia)
		{


			int zhong = (shang + xia) / 2;
			printf("%d,%d,%d\n", shang, zhong, xia);
			if (pdata->p[zhong] == num)
			{
				return &pdata->p[zhong];
			}
			else if (num > pdata->p[zhong])
			{
				shang = zhong + 1;
			}
			else if (num < pdata->p[zhong])
			{
				xia = zhong - 1;
			}
		}
		return NULL;
	}
	else//从大到小，用二分查找法
	{

		int shang = 0;
		int xia = pdata->length - 1;
		while (shang <= xia)
		{


			int zhong = (shang + xia) / 2;
			printf("%d,%d,%d\n", shang, zhong, xia);
			if (pdata->p[zhong] == num)
			{
				return &pdata->p[zhong];
			}
			else if (num < pdata->p[zhong])
			{
				shang = zhong + 1;
			}
			else if (num > pdata->p[zhong])
			{
				xia = zhong - 1;
			}
		}
		return NULL;
	}
}

int *find(int *p, int num, int n)//从一个地址开始，n个范围内查找
{
	for (int i = 0; i < n; i++)
	{
		if (p[i] == num)
		{
			return p + i;//返回地址
			break;
		}
	}
	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 - 1); p != NULL; p = find(p + 1, num, (pdata->length - 1) - (p - pdata->p)))
	{
		i++;
	}
	printf("i=%d\n", i);
	res1.n = i;//长度
	int **pint = (int*)malloc(sizeof(int*) * i);//指针数组
	res1.pp = pint;
	for (int *p = find(pdata->p, num, pdata->length - 1), j = 0; p != NULL; p = find(p + 1, num, (pdata->length - 1) - (p - pdata->p)), j++)
	{
		pint[j] = p;
		printf("\n%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("没有找到，修改失败");
		return;
	}
	else
	{
		*p = newnum;//修改数据
	}
}

//插入数据
void insert(struct data *pdata, int num, int insertnum, int headback)//插入，headback=0前插，=1后插
{
	int *p = finddata(pdata, num);
	if (p == NULL)
	{
		printf("没有找到数据");
		return NULL;//没有找到
	}
	else//找到，分为前插和后插
	{
		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++;
			}
			else//需要分配
			{
				pdata->p = (int*)realloc(pdata->p, (pdata->length + 1) * sizeof(int));
				pdata->reallength++;//实际长度+1
				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++;
			}
		}
		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++;
			}
			else//需要分配
			{
				pdata->p = (int*)realloc(pdata->p, (pdata->length + 1) * sizeof(int));
				pdata->reallength++;//实际长度+1
				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++;
			}
		}
	}
}

//删除第一个找到的数据
void deleteone(struct data *pdata, int num)//删除依赖于查找
{
	int *p = finddata(pdata, num);//查找数据
	if (p == NULL)
	{
		return NULL;//没有找到
	}
	else
	{
		int curr = p - pdata->p;//curr当前要删除的下标
								/*printf("%d,%p", *p, p);
								printf("%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;
	}
}

//删除全部
void deleteall(struct data *pdata, int num)
{
	for (int *p = finddata(pdata, num); p != NULL; p = finddata(pdata, num))
	{
		int curr = p - pdata->p;//curr当前要删除的下标
		for (int i = curr; i < pdata->length - 1; i++)
		{
			pdata->p[i] = pdata->p[i + 1];
		}
		pdata->length -= 1;
	}
}

调用测试  main.c 

#include<stdio.h>
#include<stdlib.h>
#include"动态数组.h"

void main1()
{
	int a[10] = { 1,22,3,4,15,6,37,8,19,0 };
	struct data data1;
	init(&data1);
	/*addobject(&data1, 10);
	addobject(&data1, 11);
	addobject(&data1, 12);

	reinit(&data1);
	addobjects(&data1,a,10);
	printfall(&data1);
	printf("\n\n");*/



	addobjects(&data1, a, 10);
	/*{
	int *pfind = finddata(&data1, 6);
	if (pfind != NULL)
	{
	printf("%d,%p\n", *pfind, pfind);
	}
	else
	{
	printf("没有找到");
	}
	}*/
	//printf("\n\n");
	sort(&data1, 0);//从小到大
					//printfall(&data1);
					//块语句
	{
		int *pfind = finddata(&data1, 6);
		if (pfind != NULL)
		{
			printf("%d,%p\n", *pfind, pfind);
		}
		else
		{
			printf("没有找到");
		}
	}


	getchar();
}

void main2()
{
	int a[10] = { 1,22,3,4,15,6,37,8,19,0 };
	struct data data1;
	init(&data1);
	addobjects(&data1, a, 10);

	{
		int *pfind = finddata(&data1, 6);
		if (pfind != NULL)
		{
			//printf("%d,%p\n", *pfind, pfind);
		}
		else
		{
			printf("没有找到");
		}
	}

	getchar();
}

void main3()
{
	int a[10] = { 1,22,15,4,15,6,37,15,19,0 };
	struct data data1;
	init(&data1);
	addobjects(&data1, a, 10);
	printfall(&data1);
	printf("\n\n\n");

	struct findres resn = findalldata(&data1, 15);//查找
	for (int i = 0; i < resn.n; i++)
	{
		printf("\nresn %p,%d\n", *(resn.pp + i), **(resn.pp + i));//二级指针遍历指针数组
	}
	free(resn.pp);//释放内存
	printfall(&data1);

	getchar();
}

void main4()
{
	int a[10] = { 1,22,15,4,15,6,37,15,19,23 };
	struct data data1;
	init(&data1);
	addobjects(&data1, a, 10);
	printfall(&data1);
	printf("\n\n\n");

	int *p = finddata(&data1, 6);
	printf("%d\n", *p);

	getchar();
}

void main()
{
	int a[10] = { 1,22,15,4,15,6,37,15,19,23 };
	struct data data1;
	init(&data1);
	addobjects(&data1, a, 10);
	printfall(&data1);
	printf("\n\n\n");
	//测试插入
	insert(&data1, 6, 1988, 1);//前插

	insert(&data1, 6, 1988, 0);//后插

	printfall(&data1);

	getchar();
}



-----------------------------测试与调用-------------------------------------
#include<stdio.h>
#include<stdlib.h>
#include"动态数组.h"
#pragma comment(lib,"数组lib.lib")//引用lib，先要把lib文件放入数组库测试的目录下

void main1()
{
	struct data data1;//第一种调用方式
	int a[10] = { 5,2,65,874,2,12,486,2,215,2 };
	init(&data1);
	addobjects(&data1, a, 10);
	printfall(&data1);
	printf("\n\n");

	//change(&data1, 5, 1001);
	//deleteall(&data1, 2);
	insert(&data1, 2, 99999, 0);
	printfall(&data1);

	getchar();
}

void main()
{
	struct data *pdata = (struct data*)malloc(sizeof(struct data));//第二种调用方式
	int a[10] = { 5,2,65,874,2,12,486,2,215,2 };
	init(pdata);
	addobjects(pdata, a, 10);
	printfall(pdata);
	printf("\n\n");

	//change(&data1, 5, 1001);
	//deleteall(&data1, 2);
	insert(pdata, 2, 99999, 0);
	printfall(pdata);

	getchar();
}

最后在属性里改为lib,生成lib文件,完成封装,其他文件调用的时候要把lib文件和头文件复制到目标文件夹下面

ChasingMoon
关注
专栏目录
ArrayList 动态数组
a931394057的博客
11-13 436
动态数组 ArrayList
sv队列和动态数组的区别_systemVerilog知识点汇总
weixin_32407987的博客
12-31 1697
nterfaceVerilog语言使用端口名字连接各个模块；systemVerilog中使用“.*”可以自动匹配具有相同名字的线网和端口，自动连接的名字必须具有相同的端口位宽，连接的端口类型必须兼容；也可以使用“.name”进行连接，.name必须满足端口名字和位宽一直；Verilog传统连接的缺点：通信协议接口在多个模块中使用，在多个模块中都要声明相应的端口，同时不匹配的声明会导致编译错误，设计...
数据结构数组接口和封装
y8350318的专栏
03-11 494
/********************************************************* *文件名： 动态数组.h *创建者：ycj *创建时间：2015-3-10 *文件说明：动态数组的增加，删除，查找，修改,排序,插入的声明 **********************************************************/ #
C++学习之动态数组类的封装
神奕的专栏
07-29 9381
动态数组（Dynamic Array）是指动态分配的、可以根据需求动态增长占用内存的数组。为了实现一个动态数组类的封装，我们需要考虑几个问题：new/delete的使用、内存分配策略、类的四大函数（构造函数、拷贝构造函数、拷贝赋值运算符、析构函数）、运算符的重载。涉及到的知识点很多，鉴于本人水平有限，在这里只做简单的介绍。 一、内存分配策略 当用new为一个动态数组申请一块内存时，数组中的元素
java对数组封装_java中的数组 和 封装
weixin_35315373的博客
02-13 374
packagecom.aaa.zxf;/*** 一、 普通java项目 导入测试类的方法。* ideal 中 java 项目中导入测试类的方法 手动写入* import org.junit.Test** alt + ent 导入Junit 的工具包 。*/importorg.junit.Test;importjava.io.Serializable;/*** ...
java数组封装,二次封装JAVA数组
weixin_36264801的博客
03-09 481
一、前言JAVA数组缺点：一旦定义了数组，数组的长度不可以更改。功能少，他没有提供多样的增删改查操作，例如在JavaScript上的push()、pop()、unshift()、shift()等这些接口，但是它能存放任何的数据类型。由于Java数组有点笨重，操作数组的时候有点不方便，我们不得不自己封装自己数组，当然现在有很多工具类例如ArrayList，它就可以完全代替数组。下面我们将演示如何对数...
java中的数组 和 封装
weixin_30877493的博客
09-17 519
package com.aaa.zxf; /** * 一、 普通java项目 导入测试类的方法。 * ideal 中 java 项目中导入测试类的方法 手动写入 * import org.junit.Test * * alt + ent 导入Junit 的工具包 。 */ import org.junit.Test...
【数据结构】动态数组的实现
最新发布
qq_48479056的博客
03-18 881
动态数组的实现
Java动态数组ArrayList
fengyuzhengfan的专栏
09-04 7802
List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于Vector 类，除了此类是不同步的。） 每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。
数组类的封装（代码实现） ——c++
qq_51399192的博客
02-08 698
数组类的封装（代码实现），使用接口来访问数组的元素
动态字符串数组封装的类
11-14
总结起来，动态字符串数组封装的类是一个高效、灵活的数据结构，用于存储和操作字符串序列，提供了丰富的接口供程序员使用。在实际开发中，这样的类能够简化内存管理，提高代码的可读性和可维护性。
vc2008 动态数组
11-28
`std::vector`是一个动态数组的封装，提供了更安全、更方便的接口，包括自动管理内存、自动调整大小等功能。使用`std::vector<int> val(10)`可以创建一个大小为10的`vector`，并且它提供了许多便利的方法，如`push_...
php操作mysql查询并返回数组封装函数源码
06-01
在标签中，"php查询"指的是PHP的MySQL查询功能，"返回数组"是指查询结果以数组形式返回，"封装"是编程中将复杂操作简化为单一接口的技术，"函数源码"则是指实现这些功能的PHP代码。 `db.class.php`很可能包含了上述...
c++语言动态数组,C++动态数组类的封装实例
weixin_28968629的博客
05-21 640
C++中的动态数组(Dynamic Array)是指动态分配的、可以根据需求动态增长占用内存的数组。为了实现一个动态数组类的封装，我们需要考虑几个问题：new/delete的使用、内存分配策略、类的四大函数(构造函数、拷贝构造函数、拷贝赋值运算符、析构函数)、运算符的重载。涉及到的知识点很多，对此本文只做简单的介绍。一、内存分配策略当用new为一个动态数组申请一块内存时，数组中的元素是连续存储的，...
Unity 【Content Size Fitter】- 聊天气泡自动适配Text文本框大小
当代野生程序猿
02-25 5768
通常在展示人物对话的时候文本的长度是不定的，因此会需要动态的调整对话内容文本框的背景图片的大小，这里以如下这种气泡框的对话为例： 实现该需求涉及到的内容包括Content Size Fitter组件的使用、2D Sprite工具包的使用。 Content Size Fitter组件用于Text文本框，如图所示，我们将Horzontal Fit设为Preferred Size，当我们调整Text文本框中的内容时，其大小会自动进行调整。 注意Rect Transform中Pivot轴心点的设置
新唐NUC972 Linux（一）：USB烧写linux出厂镜像
小破孩的博客
02-20 3384
USB烧写出厂镜像 文章目录USB烧写出厂镜像前言一、硬件连接二、安装驱动三、烧写linux程序四、运行程序 前言 今天开始进军linux，学了那么久单片机，也摸得七七八八，至少点个灯还是会的。本人之所以买酷客的linux开发板主要是便宜，资料也算齐全，虽然没有原子那么好，不过也够了，找那么多借口，其实就是qiong。今天先从USB烧录官方提供的linux相关程序到芯片开始吧。 一、硬件连接 1、连接电源线 2、RS232转USB，需要安装CH340驱动，用于在电脑串口超级终端中查看调试信息。 3、U
WeChall CTF Writeup（一）
weixin_43211186的博客
02-25 1503
以下题目标题组成： [Score] [Title] [Author] 文章目录0x01 1 Training: Get Sourced by Gizmore0x02 1 Training: Stegano I by Gizmore0x03 1 Training: Crypto - Caesar I by Gizmore0x04 1 Training: WWW-Robots by Gizmore0x05 1 Training: ASCII by Gizmore 0x01 1 Training: Get Sou
C语言每日一练——第126天：佩奇借书问题
热门推荐
Edison's 小宇宙
02-25 2万+
史上最强借书方案问题讲解（代码详解+思路分析+动图演示+特性总结）
CS5261与CS5265功能应用|CS5261替代RTD2171|CS5265替代RTD2172
qq1659747718的博客
02-25 1284
CS5261可以完全替代兼容停产RTD2171,CS5265可以完全替代兼容RTD2172，芯片单价低，整体方案设计简单，整体BOM成本较RTD2171、RTD2172低。
数据结构实现：成绩表操作与动态数组
"数据结构实验代码 - 基础...通过完成这个实验，初级程序员能够掌握基本的结构体定义、动态内存管理、数组操作以及顺序表的实现。此外，他们还能了解到如何设计和实现简单的数据结构操作，并理解其在实际问题中的应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值