数据结构学习第十五课(无序树)

无序树

#pragma once
#include<string.h>
template <typename T>
class MyTree
{
	//内部类
	struct Node
	{
		T data;//数据
		Node* parent;//指向当前节点的父结点
		Node* brother;//指向当前节点的兄弟节点
		Node* child;//指向当前节点的子节点
	};
	Node* pRoot;//指向根结点
public:
	MyTree();
	~MyTree();
	/*
	插入节点到树中
	insertData:新节点数据
	findData:新节点成为findData节点的子节点或者兄弟节点
	isBrother:为真 新节点成为findData节点的兄弟节点
	为假 新节点成为findData节点的子节点
	*/
	bool insertNode(const T& findData,
		const T& insertData, bool isBrother = true);
	//创建新节点并返回
	Node* createNode(const T& data)
	{
		Node* newNode = new Node;
		memset(newNode, 0, sizeof(Node));
		newNode->data = data;
		return newNode;
	}
	//从树中查找数据为findData的节点,找到返回节点地址
	Node* findNode(const T& findData);
	//修改
	Node* modifyNode(const T& findData, const T& modifyData);
	//删除
	bool deleteNode(const T& deleteData);
private:
	///从root树中查找数据为findData的节
	//找到返回节点地址
	Node* _findNode(Node* root, const T& dindData);
	//删除
	bool _deleteNode(const T& deleteData);
};

template<typename T>
inline MyTree<T>::MyTree()
{
	pRoot = NULL;
}

template<typename T>
inline MyTree<T>::~MyTree()
{

}

template<typename T>
inline bool MyTree<T>::insertNode(const T& findData, const T& insertData, bool isBrother)
{
	//1 创建新节点
	Node* newNode = createNode(insertData);
	//2 如果原本树为空
	if (NULL == pRoot)
	{
		pRoot = newNode;
		return true;
	}
	
	//3 如果原本树不为空
	Node* pInsert = _findNode(pRoot, findData);
	Node* pCurrent;
	if (pInsert)//能找到插入的节点
	{
		if (isBrother)//成为兄弟
		{
			//找到findData节点的最小兄弟
			pCurrent = pInsert;
			while (pCurrent->brother)
			{
				pCurrent = pCurrent->brother;
			}
			//插入
			pCurrent->brother = newNode;
			newNode->parent = pCurrent->parent;
		}
		else//成为孩子
		{
			//找到findData节点的最小孩子
			pCurrent = pInsert;
			while (pCurrent->child)
			{
				pCurrent = pCurrent->child;
			}
			//插入
			pCurrent->child = newNode;
			newNode->parent = pCurrent;
		}
	}
	else//找不到插入的节点
	{
		pCurrent = pRoot;
		if (isBrother)//成为兄弟
		{
			//找到findData节点的最小兄弟
			while (pCurrent->brother)
			{
				pCurrent = pCurrent->brother;
			}
			//插入
			pCurrent->brother = newNode;
			newNode->parent = pCurrent->parent;
		}
		else//成为孩子
		{
			//找到findData节点的最小孩子
			while (pCurrent->child)
			{
				pCurrent = pCurrent->child;
			}
			//插入
			pCurrent->child = newNode;
			newNode->parent = pCurrent;
		}
	}
	return true;
}

template<typename T>
typename MyTree<T>::Node* MyTree<T>::findNode(const T& findData)
{
	return _findNode(pRoot,findData);
}

template<typename T>
typename MyTree<T>::Node* MyTree<T>::modifyNode(const T& findData, const T& modifyData)
{
	Node* modifyNode = _findNode(pRoot, findData);
	if (NULL == modifyNode)
	{
		return NULL;
	}
	modifyNode->data = modifyData;
	return modifyNode;
}



//返回内部类加typename 和类名域
template<typename T>
typename MyTree<T>::Node* MyTree<T>::_findNode(Node* root, const T& findData)
{
	//1防御性编程
	if (NULL == root)
	{
		return NULL;
	}
	//2 循环查找
	Node* pCurrent = root;//当前层
	Node* pTemp = NULL;//当前层的当前节点
	while (pCurrent)
	{
		pTemp = pCurrent;
		while (pTemp)
		{
			if (findData == pTemp->data)
			{
				return pTemp;
			}
			pTemp = pTemp->brother;//往右
		}
		pCurrent = pCurrent->child;//往下
	}

	return NULL;
}

template<typename T>
bool MyTree<T>::_deleteNode(const T& deleteData)
{
	return false;
}
template<typename T>
bool MyTree<T>::deleteNode(const T& deleteData)
{
	//1 找到要删除的节点
	Node* delNode=_findNode(pRoot, deleteData);
	return false;
}