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;
}