本文实现的二叉树功能包含:
// 拷贝构造函数
// 重载 operator=
// 创建二叉树(5种创建方法)
// 递归遍历 (先序,中序,后序)
//
//接下来的文章将实现:非递归遍历二叉树,创建二叉树(先中序,中后序)
// 二叉树的结点个数,深度,查找结点,查找双亲等
附一张二叉树结构图
二叉树模板类的定义
//只给出了public方法
template<class Type>
class BinaryTree
{
protected:
typedef struct BtNode//二叉树结点
{
Type data;
BtNode* leftchild;
BtNode* rightchild;
};
public:
BinaryTree();
BinaryTree(const Type &x);
BinaryTree(const BinaryTree &tree); //拷贝构造函数
BinaryTree & operator=(BinaryTree &obj);//重载operator方法
~BinaryTree();
public:
void MakeTree(const Type *&str);//内部包含5种创建方法
void PreOrder() const; //先序遍历(递归)
void InOrder() const; //中序遍历 (递归)
void PastOrder()const; //后序遍历 (递归)
private:
BtNode* root;
Type RefValue;//叶子结点标志
};
代码实现
#include<iostream>
#include<assert.h>
#include<stdlib.h>
using namespace std;
template<class Type>
class BinaryTree
{
protected:
typedef struct BtNode
{
Type data;
BtNode* leftchild;
BtNode* rightchild;
};
typedef BtNode* PBtree;
public:
BinaryTree():root(NULL),RefValue(NULL){}
BinaryTree(const Type &x):root(NULL),RefValue(x){}
BinaryTree(const BinaryTree &tree)
{
root = Copy(tree.root);
}
BinaryTree & operator=(BinaryTree &obj)
{
if(this != &obj)
{
root = Copy(obj.root);
}
return *this;
}
~BinaryTree(){}
public:
void MakeTree(const Type *&str)
{
if(NULL == str)
{
root = NULL;
}
else
{//5种创建二叉树的方法:中间三种方法终端输入
root = Create(str);
//Create1(root);
//root = Create2();
//Create3(&root);
//root = Create4(&str);
}
}
void PreOrder()const
{
cout <<endl<< "先序遍历(递归) : ";
PreOrder(root);
cout << endl;
}
void InOrder()const
{
cout << "中序遍历(递归) : ";
InOrder(root);
cout << endl;
}
void PastOrder()const
{
cout << "后序遍历(递归) : ";
PastOrder(root);
cout << endl;
}
private:
static BtNode* Buynode()
{
BtNode *s = (BtNode*)malloc(sizeof(BtNode));
assert(s != NULL);
memset(s,0,sizeof(BtNode));
return s;
}
static void Freenode(BtNode *p)
{
free(p);
}
BtNode *Create(const Type *&str)
{
if(*str == RefValue)return NULL;
else
{
BtNode *s = Buynode();
s->data = *str;
s->leftchild = Create(++str);
s->rightchild = Create(++str);
return s;
}
}
void Create1(BtNode *&p)
{
Type x;
cin>>x;
if(x == RefValue) p = NULL;
else
{
p = Buynode();
p->data = x;
Create1(p->leftchild);
Create1(p->rightchild);
}
}
BtNode *Create2()
{
Type x;
BtNode *s=NULL;
cin>>x;
if(x != RefValue)
{
s = Buynode();
s->data = x;
s->leftchild = Create2();
s->rightchild= Create2();
}
return s;
}
void Create3(BtNode **p)
{
Type x;
cin>>x;
if(x == RefValue) p=NULL;
else
{
*p= Buynode();
(*p)->data = x;
//Create3(&(*p)->leftchild); //两种写法都可以
Create3(&(**p).leftchild);
Create3(&(**p).rightchild);
}
}
BtNode *Create4(const Type **str)
{
BtNode *s = NULL;
if(**str != RefValue)
{
s = Buynode();
s->data = **str;
s->leftchild = Create4(&++*str);
s->rightchild= Create4(&++*str);
}
return s;
}
static void PreOrder(BtNode *p)
{
if(NULL != p)
{
cout<<p->data<<" ";
PreOrder(p->leftchild);
PreOrder(p->rightchild);
}
}
static void InOrder(BtNode *p)
{
if(NULL != p)
{
InOrder(p->leftchild);
cout<<p->data<<" ";
InOrder(p->rightchild);
}
}
static void PastOrder(BtNode *p)
{
if(NULL != p)
{
PastOrder(p->leftchild);
PastOrder(p->rightchild);
cout<<p->data<<" ";
}
}
static BtNode *Copy(const BtNode *p)
{
BtNode *newroot;
if(NULL == p)return NULL;
else
{
newroot = Buynode();
newroot->data = p->data;
newroot->leftchild = Copy(p->leftchild);
newroot->rightchild = Copy(p->rightchild);
return newroot;
}
}
private:
BtNode* root;
Type RefValue;
};
int main()
{
BinaryTree<char> mytree('#');
char *str="ABC##DE##F##G#H##";
mytree.MakeTree(str);
mytree.PreOrder();
mytree.InOrder();
mytree.PastOrder();
BinaryTree<char> youtree(mytree);//拷贝构造
youtree.PreOrder();
youtree.InOrder();
youtree.PastOrder();
BinaryTree<char> histree;
histree=mytree; //赋值语句(重载operator=方法)
histree.PreOrder();
histree.InOrder();
histree.PastOrder();
return 0;
}