二叉树的进一步学习

一，创建一颗二叉树

	BinTree()
		:Root(NULL)
	{}

	void _BinTree(T* str, size_t size, const T& invalid)
	{
		size_t index = 0;
		Root = _Create(str, size, index, invalid);
	}
	BinTree(BinTree& bt)
	{
		Root=CopyBinTree(bt.Root);
	}

	BinTree<T>& operator=(const BinTree<T>& bt)
	{
		if (bt == this)
			return this;
		if (Root)
		{
			Destroy(this->Root);
			Root = BinTree(bt);
		}
	}

二，二叉树的拷贝构造函数

BinTree(BinTree& bt)
	{
		Root=CopyBinTree(bt.Root);
	}
pNode CopyBinTree(pNode t)
	{
		pNode pNewNode = NULL;
		if (t)
		{
			//复制根节点
			pNewNode = new Node(t->_data);
			//复制根节点的左子树
			if (t->_pleft)
				pNewNode->_pleft = CopyBinTree(t->_pleft);
			//复制根节点的右子树
			if (t->_pright)
				pNewNode->_pright = CopyBinTree(t->_pright);
		}
		return pNewNode;
	}

三，赋值运算符的重载

	BinTree<T>& operator=(const BinTree<T>& bt)
	{
		if (bt == this)
			return this;
		if (Root)
		{
			Destroy(this->Root);
			Root = BinTree(bt);
		}
	}
void Destroy(pNode root)
	{
		if (root)
		{
			Destroy(root->_pleft);
			Destroy(root->_pright);
			delete root;
		}
	}

四，前序，中序，后序遍历

void PreOrder()
	{
		_PreOrder(Root);
	}
	void InOrder()
	{
		_InOrder(Root);
	}
	void PostOrder()
	{
		_PostOrder(Root);
	}
	void _PreOrder(pNode root)
	{
		if (root)
		{
			cout << root->_data << " ";
			_PreOrder(root->_pleft);
			_PreOrder(root->_pright);
		}
	}
	void _InOrder(pNode root)
	{
		if (root)
		{
			_InOrder(root->_pleft);
			cout << root->_data << " ";
			_InOrder(root->_pright);
		}
	}
	void _PostOrder(pNode root)
	{
		if (root)
		{
			_PostOrder(root->_pleft);
			_PostOrder(root->_pright);
			cout << root->_data << " ";
		}
	}

五，层序遍历

void levelOrder()//层序遍历
	{
		if (NULL == Root)
			return;

			queue<pNode> Q;
			Q.push(Root);
			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 _Depth(Node* root)//二叉树的深度
	{
		if (root == NULL)
			return 0;

		size_t left = _Depth(root->_pleft);
		size_t right = _Depth(root->_pright);
		return left > right ? left + 1 : right + 1;
	}

七，二叉树中节点的个数

size_t _Size(Node* root)//二叉树的结点个数
	{
		if (root == NULL)
			return 0;

		return _Size(root->_left) + _Size(root->_right) + 1;
	}

八，总代码

#include<string.h>
#include<assert.h>
#include<queue>
#include<iostream>
using namespace std;
template<class T>
struct BinTreeNode
{
	BinTreeNode(T& data)
	:_pleft(NULL),
	_pright(NULL)
	, _data(data)
	{}
	BinTreeNode<T>* _pleft;
	BinTreeNode<T>* _pright;
	T _data;
};

template<class T>
class BinTree
{
public:
	typedef struct BinTreeNode<T> Node;
	typedef Node* pNode;

	BinTree()
		:Root(NULL)
	{}

	void _BinTree(T* str, size_t size, const T& invalid)
	{
		size_t index = 0;
		Root = _Create(str, size, index, invalid);
	}
	BinTree(BinTree& bt)
	{
		Root=CopyBinTree(bt.Root);
	}

	BinTree<T>& operator=(const BinTree<T>& bt)
	{
		if (bt == this)
			return this;
		if (Root)
		{
			Destroy(this->Root);
			Root = BinTree(bt);
		}
	}

	~BinTree()
	{
		Destroy(Root);
	}
	void PreOrder()
	{
		_PreOrder(Root);
	}
	void InOrder()
	{
		_InOrder(Root);
	}
	void PostOrder()
	{
		_PostOrder(Root);
	}

	void levelOrder()//层序遍历
	{
		if (NULL == Root)
			return;

			queue<pNode> Q;
			Q.push(Root);
			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 _Depth(Node* root)//二叉树的深度
	{
		if (root == NULL)
			return 0;

		size_t left = _Depth(root->_pleft);
		size_t right = _Depth(root->_pright);
		return left > right ? left + 1 : right + 1;
	}
	size_t _Size(Node* root)//二叉树的结点个数
	{
		if (root == NULL)
			return 0;

		return _Size(root->_left) + _Size(root->_right) + 1;
	}
protected:
	Node* _Create(T* a, size_t size, size_t& index, const T& invalid)
	{
		assert(a);
		Node* root = NULL;
		while (index < size && a[index] != invalid)
		{
			root = new Node(a[index]);
			root->_pleft = _Create(a, size, ++index, invalid);
			root->_pright = _Create(a, size, ++index, invalid);
		}
		return root;
	}
	pNode CopyBinTree(pNode t)
	{
		pNode pNewNode = NULL;
		if (t)
		{
			//复制根节点
			pNewNode = new Node(t->_data);
			//复制根节点的左子树
			if (t->_pleft)
				pNewNode->_pleft = CopyBinTree(t->_pleft);
			//复制根节点的右子树
			if (t->_pright)
				pNewNode->_pright = CopyBinTree(t->_pright);
		}
		return pNewNode;
	}
	void Destroy(pNode root)
	{
		if (root)
		{
			Destroy(root->_pleft);
			Destroy(root->_pright);
			delete root;
		}
	}
	void _PreOrder(pNode root)
	{
		if (root)
		{
			cout << root->_data << " ";
			_PreOrder(root->_pleft);
			_PreOrder(root->_pright);
		}
	}
	void _InOrder(pNode root)
	{
		if (root)
		{
			_InOrder(root->_pleft);
			cout << root->_data << " ";
			_InOrder(root->_pright);
		}
	}
	void _PostOrder(pNode root)
	{
		if (root)
		{
			_PostOrder(root->_pleft);
			_PostOrder(root->_pright);
			cout << root->_data << " ";
		}
	}

private:
	pNode Root;
};

int main(void)
{
	char* str = "ABD###CE##F";
	BinTree<char> Tree;
	Tree._BinTree(str, strlen(str),'#');
	BinTree<char> Tree1(Tree);


	return 0;
}