C++实现二叉树之二叉链表

#include "stdafx.h"
#include <iostream>
#include <deque>

using namespace std;

template<typename T>
struct TreeNode{
T data;                         //结点中的元素
TreeNode<T> *Lchild, *Rchild;     //结点的左、右孩子结点指针
//可选择参数的默认构造函数
//TreeNode<T>(T nodeValue, TreeNode<T> *rightNode = NULL, TreeNode<T> * leftNode = NULL) : data(nodeValue), Rchild(rightNode), Lchild(leftNode){}
};

template<typename T>
class BinaryTree{
public:
//BinaryTree(){ }
BinaryTree(){ root = CreatBT(root); }     //初始化一颗二叉树，root指向根结点
~BinaryTree(){ Destory(root); }
TreeNode<T>* CreatBT(TreeNode<T> *rt);   //创建二叉树
TreeNode<T>* GetRoot(){ return root; };  //取指向二叉树根结点的指针
void PreOrder(TreeNode<T> *rt);          //前序遍历
void MidOrder(TreeNode<T> *rt);          //中序遍历
void PostOrder(TreeNode<T> *rt);         //后序遍历
void LevelOrder();                       //层序遍历
void Destory(TreeNode<T> *rt);           //销毁二叉树
int Num_Node(TreeNode<T> *rt);          //统计二叉树结点数
int Depth(TreeNode<T> *rt);             //二叉树深度
private:
TreeNode<T> *root;            //指向根结点的头指针，需要通过公共成员函数来调用
};

template<typename T>
TreeNode<T>* BinaryTree<T>::CreatBT(TreeNode<T> *rt){ //构造二叉树，参数是一个指向结点的指针
T nodeValue;
cout << "输入结点值：";
cin >> nodeValue;
if (nodeValue == -1)
rt = NULL;
else{
rt = new TreeNode <T>;                       //创建一个树结点
rt->data = nodeValue;
rt->Lchild = CreatBT(rt->Lchild);            //递归构造左子树
rt->Rchild = CreatBT(rt->Rchild);            //递归构造右子树
}
return rt;
}

template<typename T>
void BinaryTree<T>::PreOrder(TreeNode<T> *rt){        //前序遍历
TreeNode<T> *p = rt;
if (p == NULL)
return;
else{
cout << p->data << " ";                 //访问根结点p的数据域
PreOrder(p->Lchild);                    //前序递归遍历p的左子树
PreOrder(p->Rchild);                    //前序递归遍历p的右子树
}
}

template<typename T>
void BinaryTree<T>::MidOrder(TreeNode<T> *rt){
TreeNode<T> *p = rt;
if (p == NULL)
return;
else{
MidOrder(p->Lchild);                   //中序递归遍历p的左子树
cout << p->data << " ";                //访问根结点p的数据域
MidOrder(p->Rchild);                   //中序递归遍历p的右子树
}
}

template<typename T>
void BinaryTree<T>::PostOrder(TreeNode<T> *rt){
TreeNode<T> *p = rt;
if (p == NULL)
return;
else{
PostOrder(p->Lchild);                  //后序递归遍历p的左子树
PostOrder(p->Rchild);                  //后序递归遍历p的右子树
cout << p->data << " ";                //访问根结点p的数据域
}
}

template<typename T>
void BinaryTree<T>::LevelOrder(){              //层序遍历，借助一个deque容器
if (root == NULL)
return;
deque<TreeNode<T>* > que;
que.push_back(root);                       //队尾入队
while (que.size()>0){
TreeNode<T>* p = que.front();          //取队首元素
cout << p->data << " ";
que.pop_front();                       //删除队首元素，返回void
if (p->Lchild != NULL)                 //判读该队首元素是否存在左右孩子结点，
que.push_back(p->Lchild);
if (p->Rchild != NULL)
que.push_back(p->Rchild);
}
}

template<typename T>
void BinaryTree<T>::Destory(TreeNode<T> *rt){    //销毁二叉树
if (rt != NULL){
Destory(rt->Lchild);                     //销毁rt的左子树
Destory(rt->Rchild);                     //销毁rt的右子树
delete rt;                               //销毁rt结点
cout << "已销毁！" << endl;
}
}

template<typename T>
int BinaryTree<T>::Num_Node(TreeNode<T> *rt){
if (rt == NULL)
return 0;
else{
return (1 + Num_Node(rt->Lchild) + Num_Node(rt->Rchild));
}
}

template<typename T>
int BinaryTree<T>::Depth(TreeNode<T> *rt){
if (rt == NULL)
return 0;
int h_left = Depth(rt->Lchild);
int h_right = Depth(rt->Rchild);
if (h_left > h_right)
return (h_left + 1);
else
return (h_right + 1);
}

int _tmain(int argc, _TCHAR* argv[])
{
BinaryTree<int> A;   //A初始化为空二叉树
TreeNode<int> *rootNode = A.GetRoot();    //取指向二叉树根结点的指针
cout << "前序遍历：";
A.PreOrder(rootNode);
cout << endl;
cout << "中序遍历：";
A.MidOrder(rootNode);
cout << endl;
cout << "后序遍历：";
A.PostOrder(rootNode);
cout << endl;
cout << "层序遍历：";
A.LevelOrder();
cout << endl;
cout << "二叉树结点个数：" << A.Num_Node(rootNode) << endl;
cout << "二叉树的深度：" << A.Depth(rootNode) << endl;
return 0;
}