二叉树

最新推荐文章于 2022-04-01 18:04:39 发布
最新推荐文章于 2022-04-01 18:04:39 发布
阅读量1.2k 收藏
点赞数
分类专栏： 算法设计实现 文章标签： class insert delete null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jptaozhantaozhan/article/details/7027118
版权 
/* CLASS_BEGIN *****************************************************
   类名：TBinaryMap
   功能：二叉树,支持 增、 删、改、查、及查 < 查询值的第一个节点
    实现:	Snight Q:51171107
   CLASS_END  ******************************************************/
#ifndef H_TBinaryMap_H
#define H_TBinaryMap_H

typedef	int						BOOL;

 #ifndef TRUE
 	#define TRUE (1)
 #endif
 
 #ifndef FALSE
 	#define FALSE (1)
 #endif


 template <class TKey, class TValue>
 class TreeNode
 {
 public:
 	TKey	m_oKey;
 	TValue	m_oValue;
 };
 
 template <class TKey,class TVale>
 class TBinaryMap
 {
 public:
 	TBinaryMap(void) 
 	: m_iVolume(10)
 	, m_iObjCnt(0)
 	{
 		m_poObjArray = new TreeNode<TKey, TVale>[m_iVolume];
 		memset(m_poObjArray, 0 , sizeof(TreeNode<TKey, TVale>)*m_iVolume);
 	}
 	~TBinaryMap(void)
 	{
 		m_iVolume = 0;
 		m_iObjCnt = 0;
 		delete [] m_poObjArray;
 		m_poObjArray = NULL;
 	}
 
 	// []操作符重载
 	TVale& operator [] (int aiIndex) 
 	{ return m_poObjArray[aiIndex].m_oValue; } 
 
 	// 值查找
 	BOOL Find(TKey aoKey, TVale& aoValue,int& aiPos)
 	{ return  find(aoKey, aoValue, m_iObjCnt, 0, aiPos); }
 
 	// 范围查找
 	int LeftNearby(TKey aoKey, TVale& aoValueNearby) 
 	{ return leftNearby(aoKey, aoValueNearby, m_iObjCnt, 0);}
 
 	// 插入
 	int Insert(TKey aoKey, TVale& aoValue)
 	{ return insert (aoKey, aoValue); }
 
 	// 删除
 	BOOL Erase(TKey aoKey)
 	{ return erase(aoKey);}
 
 	// 大小
 	int Size(void)
 	{ return m_iObjCnt ;}
 
 	// 容积
 	int Volume(void)
 	{ return m_iVolume ;}
 
 private:
 	int insert(TKey aoKey, TVale& aoValue)
 	{
 		// 扩充容积
 		if (m_iObjCnt >= (m_iVolume-1))
 		{
 			// 容积扩张两倍
 			m_iVolume *= 2;
 			TreeNode<TKey, TVale>* lpTempTreeNode = m_poObjArray;
 			m_poObjArray = new TreeNode<TKey, TVale>[m_iVolume];
 			memset(m_poObjArray, 0 , sizeof(TreeNode<TKey, TVale>)*m_iVolume);
 			memcpy(m_poObjArray, lpTempTreeNode, sizeof(TreeNode<TKey, TVale>)*m_iObjCnt);
 		}
 
 		// 尚无数据呢
 		if (0 == m_iObjCnt)
 		{
 			m_poObjArray[0].m_oKey = aoKey;
 			m_poObjArray[0].m_oValue = aoValue;
 			++m_iObjCnt;
 			return 0;
 		}
 
 		int liPos =  leftNearbyNoValue(aoKey, m_iObjCnt, 0);
  		
 		// 替换
 		if (m_poObjArray[liPos].m_oKey == aoKey)
  		{
 			m_poObjArray[liPos].m_oValue = aoValue;
 			return liPos;
  		}
 
 		if(liPos < m_iVolume)
 		{
 			// 首部
 			if (-1 == liPos)
 			{
 				TreeNode<TKey, TVale>* lpoObjArrayTemp = new TreeNode<TKey, TVale>[m_iObjCnt];
 				memcpy(lpoObjArrayTemp, m_poObjArray, sizeof(TreeNode<TKey, TVale>)*m_iObjCnt);
 				memcpy(m_poObjArray+1, lpoObjArrayTemp,  sizeof(TreeNode<TKey, TVale>)*m_iObjCnt);
 				m_poObjArray[0].m_oKey = aoKey;
 				m_poObjArray[0].m_oValue = aoValue;
 				delete []lpoObjArrayTemp;
 				++m_iObjCnt;
 			}
 			// 尾部
 			else if ((m_iObjCnt-1) == liPos) 
 			{
 				m_poObjArray[m_iObjCnt].m_oKey = aoKey;
 				m_poObjArray[m_iObjCnt].m_oValue = aoValue;
 				liPos = m_iObjCnt;
 				++m_iObjCnt;
 			}
 			// 腹地
 			else
 			{
 				int liTailObj =  m_iObjCnt- liPos-1;
 				TreeNode<TKey, TVale>* lpoObjArrayTemp = new TreeNode<TKey, TVale>[liTailObj];
 				memcpy(lpoObjArrayTemp, m_poObjArray+liPos+1, sizeof(TreeNode<TKey, TVale>)*liTailObj);
 				memcpy(m_poObjArray+liPos+2, lpoObjArrayTemp, sizeof(TreeNode<TKey, TVale>)*liTailObj);
 				m_poObjArray[liPos+1].m_oKey = aoKey;
 				m_poObjArray[liPos+1].m_oValue = aoValue;
 				delete [] lpoObjArrayTemp;
 				++m_iObjCnt;
 			}
 		}
 		return liPos;
 	}
 
 	BOOL erase(TKey aoKey)
 	{
 		TVale loValue;
 		int liPos = 0;
 		// 如果有节点
 		if (find(aoKey, loValue, m_iObjCnt,0, liPos))
 		{
 			if ((liPos >= 0 ) && (liPos < m_iObjCnt))
 			{
 				memcpy(m_poObjArray+liPos, m_poObjArray+(liPos+1), (m_iObjCnt - liPos - 1)* sizeof(TreeNode<TKey, TVale>));
 				m_iObjCnt--;
 				return TRUE;
 			}
 		}
 		return FALSE;
 	}
 
 	// 查找指定节点
 	BOOL find(TKey aoKey, TVale& aoValue,  int aiObjCnt, int aiBegPos, int& aiPos)
 	{
 		// 最后一个节点
 		if ((1 >= aiObjCnt)&&(aiBegPos >= 0))
 		{
 			TreeNode<TKey, TVale> loNode = m_poObjArray[aiBegPos];
 			// 查找到目标 或者查找到了最接近的值
 			if (loNode.m_oKey == aoKey)
 			{
 				aiPos = aiBegPos;
 				aoValue	 = loNode.m_oValue; 
 				return TRUE;
 			}
 			return FALSE;
 		}
 		//中间位置
 		int liMidPos = 0;
 		// 奇数节点
 		if (0 < (aiObjCnt%2))
 		{
 			liMidPos = (aiObjCnt/2) + aiBegPos;
 
 			if ((0 > liMidPos)||(m_iObjCnt  <= liMidPos))  
 				return FALSE;
 
 			// 中间节点
 			TreeNode<TKey, TVale> loMidNode =  m_poObjArray[liMidPos];
 
 			// 查找到目标 或者查找到了最接近的值
 			if (loMidNode.m_oKey == aoKey)
 			{
 				aiPos = liMidPos;
 				aoValue	 = loMidNode.m_oValue; 
 				return TRUE;
 			}
 			// 右向查找
 			else if(loMidNode.m_oKey < aoKey)
 				return find(aoKey, aoValue, (aiObjCnt/2), liMidPos+1, aiPos);
 			// 左向查找
 			else
 				return find(aoKey, aoValue, (aiObjCnt/2)  ,aiBegPos, aiPos);
 		}
 		// 偶数节点
 		else
 		{
 			// 计算出中间位置
 			liMidPos = (aiObjCnt/2) - 1 + aiBegPos;
 
 			if ((0 > liMidPos)||(m_iObjCnt  <= liMidPos)) 
 				return FALSE;
 
 			// 中间节点
 			TreeNode<TKey, TVale> loMidNode =  m_poObjArray[liMidPos];
 
 			// 查找到目标 或者查找到了最接近的值
 			if (loMidNode.m_oKey == aoKey)
 			{
 				aiPos = liMidPos;
 				aoValue	=	loMidNode.m_oValue; 
 				return TRUE;
 			}
 			// 右向查找 
 			else if(loMidNode.m_oKey < aoKey)
 				return find(aoKey, aoValue, (aiObjCnt/2), liMidPos+1, aiPos);
 			// 左向查找
 			else
 				return find(aoKey, aoValue, (aiObjCnt/2)-1  ,aiBegPos, aiPos);	
 		}
 		return FALSE;
 	}
 
 
 	// 找到 >= aoKey 的节点
 	int leftNearby(TKey aoKey, TVale& aoValue, int aiObjCnt, int aiBegPos)
 	{
 		// 最后一个节点
 		if ((1 >= aiObjCnt)&&(aiBegPos >= 0))
 		{
 			TreeNode<TKey, TVale> loNode = m_poObjArray[aiBegPos];
  			if (aoKey < loNode.m_oKey)
  			{
 				if (aiBegPos > 0)
 				{
 					loNode = m_poObjArray[aiBegPos-1];
 					aoValue	 = loNode.m_oValue; 
 					return (aiBegPos-1);
 				}
 				else
 				{
 					aoValue	 = loNode.m_oValue; 
 					return -1;
 				}
  			}
 			aoValue	 = loNode.m_oValue; 
 			return aiBegPos;
 		}
 		//中间位置
 		int liMidPos = 0;
 		// 奇数节点
 		if (0 < (aiObjCnt%2))
 		{
 			liMidPos = (aiObjCnt/2) + aiBegPos;
 
 			if ((0 > liMidPos)||(m_iObjCnt  <= liMidPos))  
 				return -2;
 
 			// 中间节点
 			TreeNode<TKey, TVale> loMidNode =  m_poObjArray[liMidPos];
 
 			// 查找到目标 或者查找到了最接近的值
 			if (loMidNode.m_oKey == aoKey)
 			{
 				aoValue	 = loMidNode.m_oValue; 
 				return liMidPos;
 			}
 			// 右向查找
 			else if(loMidNode.m_oKey < aoKey)
 				return leftNearby(aoKey, aoValue, (aiObjCnt/2), liMidPos+1);
 			// 左向查找
 			else
 				return leftNearby(aoKey, aoValue, (aiObjCnt/2)  ,aiBegPos);
 		}
 		// 偶数节点
 		else
 		{
 			// 计算出中间位置
 			liMidPos = (aiObjCnt/2) - 1 + aiBegPos;
 
 			if ((0 > liMidPos)||(m_iObjCnt  <= liMidPos)) 
 				return -2;
 
 			// 中间节点
 			TreeNode<TKey, TVale> loMidNode =  m_poObjArray[liMidPos];
 
 			// 查找到目标 或者查找到了最接近的值
 			if (loMidNode.m_oKey == aoKey)
 			{
 				aoValue	=	loMidNode.m_oValue; 
 				return liMidPos;
 			}
 			// 右向查找 
 			else if(loMidNode.m_oKey < aoKey)
 				return leftNearby(aoKey, aoValue, (aiObjCnt/2), liMidPos+1);
 			// 左向查找
 			else
 				return leftNearby(aoKey, aoValue, (aiObjCnt/2)-1  ,aiBegPos);	
 		}
 		return -2;
 	}
 
 	// 找到 >= aoKey 的节点
 	int leftNearbyNoValue(TKey aoKey, int aiObjCnt, int aiBegPos)
 	{
 		// 最后一个节点
 		if ((1 >= aiObjCnt)&&(aiBegPos >= 0))
 		{
 			TreeNode<TKey, TVale> loNode = m_poObjArray[aiBegPos];
 			if (aoKey < loNode.m_oKey)
 			{
 				if (aiBegPos > 0)
 					return (aiBegPos-1);
 				else
 					return -1;
 			}
 			return aiBegPos;
 		}
 		//中间位置
 		int liMidPos = 0;
 		// 奇数节点
 		if (0 < (aiObjCnt%2))
 		{
 			liMidPos = (aiObjCnt/2) + aiBegPos;
 
 			if ((0 > liMidPos)||(m_iObjCnt  <= liMidPos))  
 				return -2;
 
 			// 中间节点
 			TreeNode<TKey, TVale> loMidNode =  m_poObjArray[liMidPos];
 
 			// 查找到目标 或者查找到了最接近的值
 			if (loMidNode.m_oKey == aoKey)
 				return liMidPos;
 			// 右向查找
 			else if(loMidNode.m_oKey < aoKey)
 				return leftNearbyNoValue(aoKey, (aiObjCnt/2), liMidPos+1);
 			// 左向查找
 			else
 				return leftNearbyNoValue(aoKey, (aiObjCnt/2)  ,aiBegPos);
 		}
 		// 偶数节点
 		else
 		{
 			// 计算出中间位置
 			liMidPos = (aiObjCnt/2) - 1 + aiBegPos;
 
 			if ((0 > liMidPos)||(m_iObjCnt  <= liMidPos)) 
 				return -2;
 
 			// 中间节点
 			TreeNode<TKey, TVale> loMidNode =  m_poObjArray[liMidPos];
 
 			// 查找到目标 或者查找到了最接近的值
 			if (loMidNode.m_oKey == aoKey)
 				return liMidPos;
 
 			// 右向查找 
 			else if(loMidNode.m_oKey < aoKey)
 				return leftNearbyNoValue(aoKey, (aiObjCnt/2), liMidPos+1);
 			// 左向查找
 			else
 				return leftNearbyNoValue(aoKey, (aiObjCnt/2)-1  ,aiBegPos);	
 		}
 		return -2;
 	}
 
 private:
 	TreeNode<TKey, TVale>*		m_poObjArray;	//	对象列表
 	int							m_iVolume;		//	容积
 	int							m_iObjCnt;		//  对象个数
 };
#endif//H_TBinaryMap_H


 

Snight
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Binary Bit Map:使用C语言致力于单色图像的项目。-开源
05-27
使用C语言致力于单色图像的项目。 desc：有许多图像格式，但是我发现它们中的许多在黑白情况下都表现得特别好。 某些格式（例如PBM，XBM和WBMP）仅支持这两种颜色，而其他常见的格式（例如BMP和PNG）比全彩色图像更有效地存储它们。 我确实有用于制作其他颜色的代码，但是黑色和白色是我的最爱，我的项目将展示它们的美丽！
pytorchOCR之DBnet
BADBADBADBOY的博客
01-29 1995
pytorchOCR之DBnet 论文 官方代码
图片二值化
未来~超越自己
11-27 2214
新一版的需求中，加入了图片二值化的处理，踩过坑，受过累，做一个标记，积累积累。。。 一、Android实现 /** * 该函数实现对图像进行二值化处理 */ public static Bitmap gray2Binary(Bitmap graymap) { //得到图形的宽度和长度 int width
DBNet实战：详解DBNet训练与测试（pytorch）
AI浩
04-01 1万+
论文连接：https://arxiv.org/pdf/1911.08947.pdf github链接：github.com 网络结构 首先，图像输入特征提取主干，提取特征； 其次，特征金字塔上采样到相同的尺寸，并进行特征级联得到特征F； 然后，特征F用于预测概率图（probability map P）和阈值图(threshold map T) 最后，通过P和F计算近似二值图（approximate binary map B） 在训练期间对P，T，B进行监督训练，P和B是用的相同的监督信号(label)。
DBNet详解
u010901792的专栏
01-18 1万+
文章目录创新点算法的整体架构自适应阈值（Adaptive threshhold）二值化标准二值化可微二值(differentiable Binarization)直观展示可形变卷积（Deformable convolution）标签的生成PSENet标签生成DBNet标签生成损失函数后处理代码阅读数据预处理入口AugmentDetectionData（数据增强类）RandomCropData（数据裁剪类）MakeICDARData（数据重新组织类）MakeSegDetectionData(生成概率图和对应m
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
二叉树 基础
03-08
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
平衡二叉树
03-03
平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，
线索二叉树
04-10
通过前序序列创建线索二叉树 1:中序遍历 2:查找节点前驱后继 3:插入节点 4:删除节点 0:退出
二叉树建立遍历
01-03
二叉树是一种重要的数据结构，它由节点组成，每个节点有两个子节点，分别称为左子节点和右子节点。在计算机科学中，二叉树被广泛应用于搜索、排序、表达式解析等多种场景。本主题主要关注的是二叉树的建立以及它的...
二叉树代码
04-29
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
二叉树深度_二叉树查询_二叉树深度_
10-01
二叉树是一种在计算机科学中广泛应用的数据结构，它由节点（也称为结点）组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的深度是指从根节点到最远叶节点的最长路径上边的数目，即树的最大层数...
有值二叉树
04-15
根据给定的信息，“有值二叉树”这一概念在IT领域通常是指一种特殊的二叉树结构，其中每个节点都包含具体的数值或者数据信息。在计算机科学中，二叉树是一种非常重要的数据结构，广泛应用于算法设计、数据组织与管理...
2021SC@SDUSC-Zxing（六）：解码关键类详解-BinaryBitmap
weixin_45883443的博客
10-27 1613
介绍维护二值图像的类
二叉图（高级数据结构）
风凌残度的博客
10-19 5059
二叉图 高级数据结构
数据结构二叉树实验头文件
12-10
在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 一棵深度为k，且有2^k-1个结点的...
二叉树操作算法详解
"二叉树相关的C语言实现代码，包括初始化、创建、遍历等基本操作" 二叉树是一种在计算机科学中广泛使用的数据结构，它由节点（或称为结点）组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值