滴水二叉树实现详细注释

最新推荐文章于 2023-04-24 21:42:45 发布

wow.

最新推荐文章于 2023-04-24 21:42:45 发布

阅读量214

点赞数 1

分类专栏：逆向基础文章标签： c++

本文链接：https://blog.csdn.net/weixin_42408832/article/details/116466137

版权

逆向基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

#include "stdafx.h"
#include "windows.h"

#define SUCCESS           			  1 // 执行成功	
#define ERRORR			 -1 // 执行失败	


//基础怪物模板
class Monster {

public:
	int Id;  //怪物编号
	char Name[20];//名字
	int Level;//等级
	
public:
	Monster() {};//构造 ,默认怪物
	Monster(int Id, char* Name, int Level);   //怪物参数

	bool Monster::operator<(const Monster& p) {
		return  this->Id < p.Id ? true : false;
	}
	bool Monster::operator>(const Monster& p) {
		return  this->Id > p.Id ? true : false;
	}
	bool Monster::operator==(const Monster& p) {
		return   this->Id == p.Id ? true : false;
	}



};


Monster::Monster(int Id, char* Name, int Level) {
	this->Id = Id;
	memcpy(&this->Name, Name, strlen(Name)+1);
	this->Level=Level;
}


template<class T>
class TreeNode {
public:
	T element; //节点数据
	TreeNode<T>* pLeft; //左树指针
	TreeNode<T>* pRight;//右树指针
	TreeNode<T>* pParent;//父节点指针

	TreeNode(T& ele) {
		//初始化
		memset(&element, 0, sizeof(TreeNode));
		memcpy(&element, &ele, sizeof(T));
		pLeft = pRight = NULL;
			
	}
	/*
	bool operator<(const TreeNode<T>& p) {
		return  this->element<p->element  ? true : false;
	}
	bool operator>(const TreeNode<T>& p) {
		return this->element>p->element ? true : false;
	}
	bool operator==(const TreeNode<T>& p) {
		return this->element == p->element ? true : false;
	}*/
};

template<class T>
class BsortTree {
public:
	BsortTree();
	~BsortTree();
public:
	void InOrderTraverse(TreeNode<T>* pNode); //中序遍历
	void PreOrderTraverse(TreeNode<T>* pNode);//前序遍历
	void PostOrderTraverse(TreeNode<T>* pNode);//后序遍历
	TreeNode<T>* GetRoot();//返回根节点
	int GetDepth(TreeNode<T>* Node);// 返回当前节点高度
	bool IsEmpty();//判断树是否为空
	DWORD Insert(T element);//新增节点
	void Delete(T element);//删除节点
	
private:
	void Init();//初始化一些数值
	void clear(TreeNode<T>* pNode);//删除所有节点
	DWORD InsertNode(TreeNode<T>* pNode, T element);
	TreeNode<T>* DeleteNode(T element, TreeNode<T>* pNode);
	TreeNode<T>* GetMinNode(TreeNode<T>* pNode);//获取以pNode为根的最小节点，注：删除NODE下，寻找PNODE右树的最小节点顶到NODE节点上。再删除原最小节点
	TreeNode<T>* GetMaxNode(TreeNode<T>* pNode);//获取以pNode为根的最大节点
private:
	TreeNode<T>* pRootNode; //根节点指针
	int size;//树中元素总数

};

template<class T>
TreeNode<T>* BsortTree<T>::GetMinNode(TreeNode<T>* pNode) {
	TreeNode<T>* pMin = NULL;
	if (pNode!=NULL) {
		int data = pNode->element;//说一下，这里为什么不用T类型，因为T代表整个类型大小，但是我们只需要NODE头4个字节的数据,这里有一点不通用，节点的头四个字节数据类型被限制了。
		if (data>=pNode->element) {
			pMin = (TreeNode<T>*)pNode->element;//把下一个比较小的节点存起来
		}
		GetMinNode(pNode->pLeft); //这里为什么用pNode->pLeft呢，因为根据左树节点比根树节点小。
		return pMin;
	}
}

template<class T>
TreeNode<T>* BsortTree<T>::DeleteNode(T element, TreeNode<T>* pNode) {
	if (pRootNode == NULL) {
		return NULL;
	}
	else if (element == pNode->element)
		{
		if (pNode->pLeft != NULL && pNode->pRight == NULL) 
		{//左子树
			TreeNode<T>* pPt = pNode->pParent;//拿到当前节点的父节点
			pPt->pLeft = pNode->pLeft;
			delete pNode;
		}
		else if (pNode->pLeft = NULL && pNode->pRight != NULL) 
		{//右子树
			TreeNode<T>* pPt = pNode->pParent;//拿到当前节点的父节点
			pPt->pRight = pNode->pRight;
			delete pNode;
		}
		else if (pNode->pLeft == NULL&&pNode->pRight == NULL) 
		{//左右树均为空
			TreeNode<T>* p;
			p = pNode->pParent;
			if (p->pLeft != NULL&&p->pRight == NULL) {//这里实际意义就是看当前节点在父节点的左边还是右边
				delete p->pLeft;
				p->pLeft = NULL;
			}
			if (p->pLeft == NULL&&p->pRight != NULL) {
				delete p->pRight;
				p->pRight = NULL;
			}
			//
			delete p->pRight;
			p->pRight = NULL;     //这两行就是代表子节点一样，且不为空，删除哪个都一样。
		}
		else if (pNode->pLeft != NULL&&pNode->pRight != NULL) {//左右子树均不为空
			TreeNode<T>* pCurrent = pNode->pRight;
			TreeNode<T>* pMin = GetMinNode(pNode->pRight);//GetMinNode是一个递归函数，返回NODE子树里的最小节点
			pNode->element = (int)pMin;//把最小的节点元素抬到Pnode节点这里来
			DeleteNode(pNode->element, pCurrent);//此时此刻，Pnode已经替换为最小节点的元素了，
												 //那么只需要删除pCurrent（pNode->pRight）下的子树最小节点就可以了，这里用的递归。

			}
	}
		else if (element > pNode->element) 
		{//Element 大于Pnode的E。那么就往Pnode右树开始找
			DeleteNode(element, pNode->pRight);

		}
		else
		{
			DeleteNode(element, pNode->pLeft);
		}
		return NULL;
	

}


template<class T>
void BsortTree<T>::Delete(T element) {
	DeleteNode(T element, TreeNode<T>* pNode);
}






template<class T>
DWORD BsortTree<T>::InsertNode(TreeNode<T>* pNode, T element) {
	//建立一个节点，把元素存进去
	TreeNode<T>* pElement = new TreeNode<T>(element);
	//如果元素等于当前节点就直接返回
	if (pNode->element==element  ) {
		return SUCCESS;
	}
	//如果pnode节点的左子节点为null且element<pnode节点
	if (pNode->pLeft == NULL && pNode->element>element  ) {
		pNode->pLeft = pElement;
		size++;
		return SUCCESS;
	}
	//如果pnode节点的右子节点为null且element>pnode节点
	if (pNode->pRight == NULL&&pNode->element<element  ) {
		pNode->pRight = pElement;
		size++;
		return SUCCESS;
	}
	//pnode左节点不为空且element<pnode节点----------此处为递归
	if (pNode->element>element) {

		InsertNode(pNode->pLeft, element);
	}
	else {
		InsertNode(pNode->pRight, element);
	}
}


template<class T>
DWORD BsortTree<T>::Insert(T element) {
	if (!pRootNode) {//如果根节点为空
		pRootNode = new TreeNode<T>(element);
		size++;
		return SUCCESS;
	}
	return InsertNode(pRootNode, element);


}
template<class T>
bool BsortTree<T>::IsEmpty() {
	return size == 0 ? true : false;
}

template<class T>
BsortTree<T>::~BsortTree() {
	//循环删除节点元素
	clear(pRootNode);
	

}

template<class T>
void BsortTree<T>::clear(TreeNode<T>* pNode) {
	if (pNode != NULL) {
		clear(pNode->pLeft);
		clear(pNode->pRight);
		delete pNode;
		pNode = NULL;
	}

}

template<class T>
BsortTree<T>::BsortTree() {
	Init();
}


template<class T>// 返回当前节点高度,Node
int BsortTree<T>::GetDepth(TreeNode<T>* Node) {
	if (Node == NUll) {
		return 0;
	}
	else
	{
		int Left = GetDepth(Node->pLeft);
		int Right = GetDepth(Node->pRight);
		return (Left > Right) ? (Left + 1) : (Right + 1);
	}

}


//获取根节点
template<class T>
 TreeNode<T>* BsortTree<T>::GetRoot() {
	return pRootNode;
}





//中序遍历
template<class T>
void BsortTree<T>::InOrderTraverse(TreeNode<T>* pNode) {



	if (pNode == NULL)
	{
		return;
	}
	else
	{
		InOrderTraverse(pNode->pLeft);
		printf("%d\n", pNode->element);
		InOrderTraverse(pNode->pRight);
	}

}

//前序遍历
template<class T>//前序遍历
void BsortTree<T>::PreOrderTraverse(TreeNode<T>* pNode) {
	if (pNode != NULL) {
		printf("%d\n", pNode->element);
		PreOrderTraverse(pNode->pLeft);
		PreOrderTraverse(pNode->pRight);
	}
}

//后序遍历
template<class T>
void BsortTree<T>::PostOrderTraverse(TreeNode<T>* pNode) {
	if (pNode != NULL) {
		PostOrderTraverse(pNode->pLeft);
		PostOrderTraverse(pNode->pRight);
		printf("%d\n", pNode->element);
	}

}
	




template<class T>
void BsortTree<T>::Init() {

	
	Monster m1(1, "混世魔王",50);
	Monster m2(2, "金斯尔", 100);
	Monster m3(3, "游离", 74);
	Monster m4(4, "尔康", 56);
	Monster m5(5, "二讹", 88);
	Monster m6(6, "传奇", 999);
	TreeNode<Monster>* n1 = new TreeNode<Monster>(m1);
	TreeNode<Monster>* n2 = new TreeNode<Monster>(m2);
	TreeNode<Monster>* n3 = new TreeNode<Monster>(m3);
	TreeNode<Monster>* n4 = new TreeNode<Monster>(m4);
	TreeNode<Monster>* n5 = new TreeNode<Monster>(m5);
	TreeNode<Monster>* n6 = new TreeNode<Monster>(m6);

	pRootNode = n3;
	n3->pLeft = n2;
	n3->pRight = n1;
	n1->pLeft = n4;
	n1->pRight = n5;
	//n5->pRight = n6;
	//size = 6;
	
	/*
	 3
  2     1
      4    5
	          6
	
	
	*/

}

int main()
{
	
	
	BsortTree<Monster>* p = new BsortTree<Monster>();
	p->InOrderTraverse(p->GetRoot());
	Monster m6(6, "传奇", 999);
	p->Insert(m6);
	printf("\n");
	p->InOrderTraverse(p->GetRoot());
	getchar();
	return 0;
}

wow.

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
滴水二叉树实现详细注释

#include "stdafx.h"#include "windows.h"#define SUCCESS 1 // 执行成功 #define ERRORR -1 // 执行失败 //基础怪物模板class Monster {public: int Id; //怪物编号 char Name[20];//名字 int Level;//等级 public: Monster() {};//构造 ,默认怪物 Monster(int Id, c
复制链接

扫一扫