【c++】简单实现二叉树

#include<iostream>
#include<queue>
using namespace std;
template<class T>
struct BinTreeNode//二叉树的节点
{
	BinTreeNode(const T& data)
	:_pLeft(NULL)
	, _pRight(NULL)
	, _data(data)
	{}
	BinTreeNode<T>* _pLeft;//左孩子
	BinTreeNode<T>* _pRight;//右孩子
	T _data;//数据域
};
	template<class T>

	class BinTree
	{
		typedef BinTreeNode<T> *pNode;
		typedef BinTreeNode<T> Node;
	public:
		BinTree()
			:_pRoot(NULL)
		{}
		BinTree(const T* array, size_t size, T invalid)
		{
			size_t index = 0;
			_CreateBinTree(_pRoot, array, size, index, invalid);


		}
		void PreOrder()//前序遍历
		{
			cout << "PreOrder:" << endl;
			_PreOrder(_pRoot);
			cout << endl;
		}

	
		
		void InOrder()//中序遍历
		{
			cout << "InOrder:" << endl;
			_InOrder(_pRoot);
			cout << endl;
		}
		void PostOrder()//后序遍历
		{
			cout << "PostOrder:" << endl;
			_PostOrder(_pRoot);
			cout << endl;
		}
		
		void LevelOrder()//层序遍历
		{
			cout << "LevelOrder:" << endl;
			_LevelOrder(_pRoot);
			cout << endl;
		}
		
		size_t Size()//节点个数
		{
			return _Size(_pRoot);
		}
		
		size_t GetLeafCount()//叶节点个数
		{
			
			return _GetLeafCount(_pRoot);
			
		}
		size_t Height()//树的高度
		{
			return _Height(_pRoot);
		}
		
		size_t GetKLefCount(size_t K)//第k层节点个数
		{
			return _GetKLefCount(_pRoot, K);
		}
		
		pNode Find(const T &data)//查找函数
		{
			return _Find(_pRoot, data);
		}
		
		pNode Parent(pNode pnode)//双亲节点

		{
			return _Parent(_pRoot, pnode);
		}
		
		pNode LeftChild(pNode pnode)//左孩子节点
		{
			return (NULL == pnode) ? NULL : pnode->_pLeft;
		}
		pNode RightChild(pNode pnode)//右孩子节点
		{
			return (NULL == pnode) ? NULL : pnode->_pRight;
		}
	BinTree(const BinTree<T> & bt)//拷贝构造函数
	{
		_pRoot = _CopyBinTree(bt);
	}
	
	BinTree<T>& operator=(const BinTree<T>& bt)//赋值运算符重载

	{
		if (this != &bt)
		{
			_DestroyBinTree(_pRoot);
			_pRoot = _CopyBinTree(bt, _pRoot);
			return *this;
		}
	}
	
	
	~BinTree()
	{
		_DestroyBinTree(_pRoot);
	}

private:
	void _CreateBinTree(pNode &pRoot, const T *array, size_t size, size_t &index, const T&  invalid)//建立树
	{
		if (index<size&&'#'!= array[index])
		{
			pRoot = new Node(array[index]);
			
			_CreateBinTree(pRoot->_pLeft, array, size, ++index, invalid);
			_CreateBinTree(pRoot->_pRight, array, size, ++index, invalid);
		
		}
	}

	void _DestroyBinTree(pNode& pRoot)//销毁树
	{
		if (pRoot)
		{
			_DestroyBinTree(pRoot->_pLeft);
			_DestroyBinTree(pRoot->_pRight);
			delete pRoot;
			pRoot = NULL;
		}
	}
	void _PreOrder(pNode pRoot)
	{
		if (pRoot)
		{
			cout << pRoot->_data << " ";
			_PreOrder(pRoot->_pLeft);
			_PreOrder(pRoot->_pRight);

		}
	}
	void  _InOrder(pNode pRoot)
	{
		if (pRoot)
		{
			_InOrder(pRoot->_pLeft);
			cout << pRoot->_data << " ";
			_InOrder(pRoot->_pRight);

		}
	}
	void _PostOrder(pNode pRoot)
	{
		if (pRoot)
		{
			_PostOrder(pRoot->_pLeft);
			_PostOrder(pRoot->_pRight);
			cout << pRoot->_data << " ";
		}

	}
	void _LevelOrder(pNode Root)
	{
		if (NULL == _pRoot)
		{
			return;

		}
		queue<pNode> q;
		q.push(_pRoot);
		while (!q.empty())
		{
			pNode pCur = q.front();
			cout << pCur->_data << " ";
			if (pCur->_pLeft)
			{
				q.push(pCur->_pLeft);
			}
			if (pCur->_pRight)
			{
				q.push(pCur->_pRight);
			}
			q.pop();
		}
	}
	size_t _GetKLefCount(pNode pRoot, size_t K)
	{
		if (NULL == _pRoot || K < 1)
			return 0;
		if (1 == K)
			return 1;
		return _GetKLefCount(_pRoot->_pLeft, K - 1) + _GetKLefCount(_pRoot->_pRight, K - 1);
	}
	size_t _Size(pNode pRoot)
	{
		if (NULL == pRoot)
			return 0;
		return (_Size(pRoot->_pLeft) + _Size(pRoot->_pRight) + 1);
	}
	size_t _GetLeafCount(pNode pRoot)
	{
		if (NULL == pRoot)
		{
			return 0;
		}
		if (NULL == pRoot->_pLeft&& NULL == pRoot->_pRight)
		{
			return 1;
		}
		return _GetLeafCount(pRoot->_pLeft) + _GetLeafCount(pRoot->_pRight);
	}
	size_t _Height(pNode pRoot)
 	{
 		if (NULL == pRoot)
		{
			return 0;
		}
		if (NULL == pRoot->_pLeft&&NULL == pRoot->_pRight)
		{
 			return 1;
		}
		else
		{
			size_t LeftHeight = _Height(pRoot->_pLeft);
			size_t RightHeight = _Height(pRoot->_pRight);
			return LeftHeight >= RightHeight ? LeftHeight+1 : RightHeight+1;
		}
		
		

	}
	pNode _Find(pNode pRoot, const T& data)
	{
		if (NULL == pRoot)
			return NULL;
		if (pRoot->_data == data)
			return pRoot;
		pNode pRet;
		if ( pRet = _Find(pRoot->_pLeft,data))

			return pRet;

		else
			return _Find(pRoot->_pRight,data);
	}
	pNode _Parent(pNode pRoot, pNode pnode)
	{
		if (NULL == pnode || NULL == pRoot || pnode == pRoot)
			return NULL;
		if (pRoot->_pLeft == pnode || pRoot->_pRight == pnode)
			return pRoot;
		pNode parent = NULL;
		if (parent == _Parent(pRoot->_pLeft, pnode))
			return parent;
		return _Parent(pRoot->_pRight, pnode);
	}
	pNode _CopyBinTree(pNode pRoot)
	{
		pNode pNewRoot = NULL;
		if (pRoot)
		{
			pNewRoot = new pNode(pRoot->_data);
			if (pRoot->pLeft)
			{
				pNewRoot->pLeft = _CopyBinTree(pRoot->_pRight);

			}

		}
		return pNewRoot;
	}
	
private:
	pNode _pRoot;

};

void FunTest()
{
	char* pStr = "ABD###CE##F";
	BinTree<char> bt(pStr, strlen(pStr), '#');
	bt.PreOrder();
	bt.InOrder();
	bt.LevelOrder();
	bt.PostOrder();
	cout << "节点的个数" << endl;
	cout << bt.Size() << endl;
	cout << "第2层叶子节点个数" << endl;
	cout << bt.GetKLefCount(2) << endl;
	cout << "叶子节点个数" << endl;
	cout << bt.GetLeafCount() << endl;
	cout << "树的高度" << endl;
	cout << bt.Height()<< endl;
	BinTreeNode<char> *p = bt.Find('C');
	cout << "找到节点，输出节点数据：" << endl;
   	cout << p->_data << endl;
	cout << "输出左孩子" << endl;
	cout << bt.LeftChild(p)->_data << endl;
	cout << "输出右孩子" << endl;
	cout << bt.RightChild(p)->_data << endl;
	cout << "输出双亲" << endl;
	cout << bt.Parent(p)->_data << endl;
	
}
int main()
{
	FunTest();
	system("pause");
	return 0;
}

运行结果如下：