C++ 二叉树模板

#include "stdafx.h"
#include <iostream>
using namespace std;

/* 结构体结点 */
template <typename T>
struct TNode{
	TNode<T>* lchild;
	TNode<T>* rchild;
	T data;
	TNode(TNode<T>* ptr = NULL){ lchild = rchild = ptr; }
	TNode(T item, TNode<T>* ptr = NULL){
		lchild = rchild = ptr;
		data = item;
	}
};

/* 二叉树类型 */
template <typename T>
class BinarryTree{
private:
	TNode<T>* root;
	int num;
public:
	BinarryTree();                                          // 无参构造函数 -- 创建一个空二叉树
	BinarryTree(const T&);                                  // 带参构造函数 -- 创建有一个根节点的二叉树
	TNode<T>* GetRoot();                                    // 获取根结点
	void SetRoot(TNode<T>*);                                // 设置根结点

	static void InsertLeftTree(TNode<T>* ,TNode<T>*);       // 插入到左子树
	static void InsertRightTree(TNode<T>*, TNode<T>*);      // 插入到右子树
	static TNode<T>* MergeTree(T,TNode<T>* l, TNode<T>* r); // 合并二叉树
	static void PreOrderTravers(TNode<T>*);                 // 先序遍历
	static void InOrderTravers(TNode<T>*);                  // 中序遍历
	static void PostOrderTravers(TNode<T>*);                // 后序遍历
};

// 插入到右子树
template <typename T>
void BinarryTree<T>::InsertRightTree(TNode<T>* parrent, TNode<T>* tree){
	if (parrent->rchild == NULL){
		parrent->rchild = tree;
	}
	else{
		TNode<T>* pr = parrent->rchild;
		parrent->rchild = tree;
		TNode<T>* t = tree;
		while (t->rchild) t = t->rchild;
		t->rchild = pr;
	}
}

// 插入到左子树
template <typename T>
void BinarryTree<T>::InsertLeftTree(TNode<T>* parrent,TNode<T>* tree){
	if (parrent->lchild == NULL){
		parrent->lchild = tree;
	}
	else{
		TNode<T>* pl = parrent->lchild;
		parrent->lchild = tree;
		TNode<T>* t = tree;
		while (t->lchild) t = t->lchild;
		t->lchild = pl;
	}
}

// 设置根结点
template <typename T>
void BinarryTree<T>::SetRoot(TNode<T>* tree){
	root = tree;
}
// 中序遍历
template <typename T>
void BinarryTree<T>::InOrderTravers(TNode<T>* tree){
	if (tree){
		InOrderTravers(tree->lchild);
		cout << tree->data << ' ';
		InOrderTravers(tree->rchild);
	}
}
// 后序遍历
template <typename T>
void BinarryTree<T>::PostOrderTravers(TNode<T>* tree){
	if (tree){
		PostOrderTravers(tree->lchild);
		PostOrderTravers(tree->rchild);
		cout << tree->data << ' ';
	}
}

// 先序遍历
template <typename T>
void BinarryTree<T>::PreOrderTravers(TNode<T>* tree){
	if (tree){
		cout << tree->data << ' ';
		PreOrderTravers(tree->lchild);
		PreOrderTravers(tree->rchild);
	}
}

// 获取根结点
template <typename T>
TNode<T>* BinarryTree<T>::GetRoot(){
	return root;
}
// 合并二叉树
template <typename T>
TNode<T>* BinarryTree<T>::MergeTree(T item,TNode<T> *lchild, TNode<T> *rchild){
	TNode<T>* tree = new TNode<T>;
	tree->data = item;
	tree->lchild = lchild;
	tree->rchild = rchild;
	return tree;
}

// 无参构造函数
template <typename T>
BinarryTree<T>::BinarryTree(){
	root = NULL;
	num = 0;
}

// 带参构造函数
template <typename T>
BinarryTree<T>::BinarryTree(const T &data){
	root = new TNode<T>;
	root->lchild = root->rchild = NULL;
	root->data = data;
	num = 1;
}




/***                            主 函 数                               ***/

int main(int argc, char *argv[]){
	BinarryTree<char> tree;
	TNode<char> *lpA = tree.MergeTree('A', NULL, NULL);
	TNode<char> *lpB = tree.MergeTree('B', NULL, NULL);
	TNode<char> *lpC = tree.MergeTree('C', lpA, lpB);
	tree.SetRoot(lpC);
	/*
	tree:结点分布
	  C
	|   |
	A   B
	*/
	cout << "PreOrder :";
	BinarryTree<char>::PreOrderTravers(tree.GetRoot()); 
	cout << endl;
	cout << "InOrder  :";
	BinarryTree<char>::InOrderTravers(tree.GetRoot()); 
	cout << endl;
	cout << "PostOrder:";
	BinarryTree<char>::PostOrderTravers(tree.GetRoot()); 
	cout << endl << endl;

	TNode<char> *lp = BinarryTree<char>::MergeTree('O',
		BinarryTree<char>::MergeTree('1', 
			BinarryTree<char>::MergeTree('2', BinarryTree<char>::MergeTree('3', NULL, NULL), BinarryTree<char>::MergeTree('4',NULL,NULL)),
			BinarryTree<char>::MergeTree('5', BinarryTree<char>::MergeTree('6', NULL, NULL), BinarryTree<char>::MergeTree('7',NULL,NULL))),
		BinarryTree<char>::MergeTree('8',NULL,NULL));
	/*
		lp 结点分布
		        O
		     |     |
		     1	   8
		  |    |
		  2    5
	        |  | |   |
		3  4 6   7

	*/
	cout << endl;
	tree.SetRoot(tree.MergeTree('*', tree.GetRoot(), lp));
	/*
		lp 和 tree 合并后的结点分布
			  *
		     |          |
	             C	        O
		   |  |     |      |
		   A  B     1	   8
			    |      |
			    2	   5
		          |   |  |   |
		       	  3   4  6   7

	预期先序遍历: * C A B O 1 2 3 4 5 6 7 8 
	预期中序遍历：A C B * 3 2 4 1 6 5 7 O 8
	预期后序遍历：A B C 3 4 2 6 7 5 1 8 O *
	*/
	cout << "PreOrder  :";
	tree.PreOrderTravers(tree.GetRoot());
	cout << endl;
	cout << "InOrder   :";
	tree.InOrderTravers(tree.GetRoot());
	cout << endl;
	cout << "PostOrder :";
	tree.PostOrderTravers(tree.GetRoot());
	cout << endl << endl;

	/**    验证插入是否有效   **/

	BinarryTree<char> atree;
	TNode<char>* tp = BinarryTree<char>::MergeTree('@', 
	/* 左 */	(BinarryTree<char>::MergeTree('%', NULL, BinarryTree<char>::MergeTree('(',NULL,NULL))), 
	/* 右 */	(BinarryTree<char>::MergeTree('&', BinarryTree<char>::MergeTree(')',NULL,NULL), NULL))
		);
	/*
		tp 结点分布:
			 @
			 |
		     |        |
		     %        &
		   |    |   |   |
	         (null) (   )  (null)
	
	预期先序遍历: @ % ( & )
	预期中序遍历：% ( @ ) &
	预期后序遍历：( % ) & @
	*/
	atree.SetRoot(tp);
	cout << "PreOrder :";
	BinarryTree<char>::PreOrderTravers(atree.GetRoot());
	cout << endl;
	cout << "InOrder  :";
	BinarryTree<char>::InOrderTravers(atree.GetRoot());
	cout << endl;
	cout << "PostOrder:";
	BinarryTree<char>::PostOrderTravers(atree.GetRoot());
	cout << endl << endl;
	/**
	lpC:
	  C
	|   |
	A   B
	插入左子树后:
		         C
			 |
		      |     |
		      @     B
		      |
		   |    |
	          %     &
		|   |  |  |
                A   (  )  (null)
	预期先序遍历:C @ % A ( & ) B
	预期中序遍历:A % ( @ ) & C B
	预期后序遍历:A ( % ) & @ B C
	*/
	BinarryTree<char> ltree;

	BinarryTree<char>::InsertLeftTree(lpC, tp);        // 将tp插入到lpC的左子树中
	ltree.SetRoot(lpC);
	cout << "After Inserted to left tree of lpC ...." << endl;
	cout << "PreOrder  :";
	BinarryTree<char>::PreOrderTravers(ltree.GetRoot());
	cout << endl;
	cout << "InOrder   :";
	BinarryTree<char>::InOrderTravers(ltree.GetRoot());
	cout << endl;
	cout << "PostOrder :";
	BinarryTree<char>::PostOrderTravers(ltree.GetRoot());
	cout << endl << endl;

	cout << "PreOrder tp:";
	BinarryTree<char>::PreOrderTravers(tp);
	cout << endl;


	cout << "PreOrder lpC:";
	BinarryTree<char>::PreOrderTravers(lpC);
	cout << endl;


	/*
		再把tp插入到lpC的右子树中去
		              C
			      |
		     |               |
	             @	             @
		     |               | 
		   |    |        |       |
	           %     &        %       &
		|   |  |  |    |   |   |   |
                A   (  )  B    A   (   )   B

	预期先序遍历: C @ % A ( & ) B @ % A ( & ) B
	预期中序遍历: A % ( @ ) & B C A % ( @ ) & B
	预期后序遍历: A ( % ) B & @ A ( % ) B & @ C
	*/

	BinarryTree<char>::InsertRightTree(lpC, tp);      // 再将tp插入到lpC的右子树中
	ltree.SetRoot(lpC);
	cout << "And, After Inserted to right tree of lpC ...." << endl;
	cout << "PreOrder  :";
	BinarryTree<char>::PreOrderTravers(ltree.GetRoot());
	cout << endl;
	cout << "InOrder   :";
	BinarryTree<char>::InOrderTravers(ltree.GetRoot());
	cout << endl;
	cout << "PostOrder :";
	BinarryTree<char>::PostOrderTravers(ltree.GetRoot());
	cout << endl << endl;
	return 0;
}