二叉树基本操作

摘要：本文主要介绍了二叉树的基本操作的实现并且进行了测试。

SqBinaryTree.h

#ifndef _BINARYTREE_
#define _BINARYTREE_
#include<iostream>
using namespace std;

//首先定义二叉树结点类模板
template<class ElemType>
struct BinTreeNode
{
    //数据成员
    ElemType data;
    BinTreeNode<ElemType> *leftChild;  //左指针
    BinTreeNode<ElemType> *rightChild;  //右指针
    //构造函数模板
    BinTreeNode();  //无参构造函数
    BinTreeNode(const ElemType &val,BinTreeNode<ElemType> *lchild=NULL, BinTreeNode<ElemType> *rchild = NULL);
};

//----------------------------------------------------------------------------------------------------------------------------------------

template<class ElemType>
class BinaryTree {
protected:
    BinTreeNode<ElemType> *root;
    //辅助函数
    //创建二叉树
    void CreateBinTree(BinTreeNode<ElemType> *&r,ElemType pre[],ElemType in[],
        int preLeft,int preRight,int inLeft,int inRight);
    //显示二叉树
    void DisplayBTHelp(BinTreeNode<ElemType> *r,int Level);
    //销毁二叉树
    void DestroyHelp(BinTreeNode<ElemType> * &r);
    //先序、中序、后序遍历二叉树
    void PreOrderHelp(BinTreeNode<ElemType> *r,void(*visit)(ElemType &))const;
    void InOrderHelp(BinTreeNode<ElemType> *r, void(*visit)(ElemType &))const;
    void PostOrderHelp(BinTreeNode<ElemType> *r, void(*visit)(ElemType &))const;
    //计算结点个数和树高
    int NodeCountHelp(const BinTreeNode<ElemType> *r)const;
    int HeightHelp(const BinTreeNode<ElemType> *r)const;
    //复制二叉树
    BinTreeNode<ElemType> *CopyTreeHelp(BinTreeNode<ElemType> *r);

public:
    //通过有参构造直接创建一棵二叉树
    BinaryTree(ElemType pre[],ElemType in[],int n);
    //析构函数
    ~BinaryTree();
    //分层显示二叉树
    void DisplayBT();
    //获取二叉树的根
    BinTreeNode<ElemType> *GetRoot();
    //判断二叉树是否为空
    bool Empty();
    //遍历二叉树
    void PreOrder(void(*visit)(ElemType &));
    void InOrder(void(*visit)(ElemType &));
    void PostOrder(void(*visit)(ElemType &));
    //计算结点个数
    int NodeCount()const;
    //计算树高
    int Height()const;
    //复制构造函数和赋值运算符重载
    BinaryTree(const BinaryTree<ElemType> &copy);
    BinaryTree<ElemType> &operator=(const BinaryTree<ElemType> &copy);

};

#endif // !_BINARYTREE_

SqBinaryTree.cpp

#include "SqBinaryTree.h"

/******************二叉树结点类模板的实现***********************/

template<class ElemType>
BinTreeNode<ElemType>::BinTreeNode() {
//构造一个叶子结点
    leftChild = rightChild = NULL;
}

template<class ElemType>
BinTreeNode<ElemType>::BinTreeNode(const ElemType &val, BinTreeNode<ElemType> *lchild, BinTreeNode<ElemType> *rchild) {
    data = val;
    leftChild = lchild;
    rightChild = rchild;
}

/*******************二叉树类辅助函数的实现*********************/

template<class ElemType>
void BinaryTree<ElemType>::CreateBinTree(BinTreeNode<ElemType> *&r, ElemType pre[], ElemType in[],
    int preLeft, int preRight, int inLeft, int inRight) {
    if (preLeft>preRight || inLeft>inRight) {
        r = NULL;
    }
    else {
        r = new BinTreeNode<ElemType>(pre[preLeft]);  //生成根结点
        int mid = inLeft;
        while (in[mid]!=pre[preLeft]) {
            mid++;
        }
        CreateBinTree(r->leftChild,pre,in,preLeft+1,preLeft+mid-inLeft,inLeft,mid-1);
        CreateBinTree(r->rightChild,pre,in,preLeft+mid-inLeft+1,preRight,mid+1,inRight);
    }
}

template<class ElemType>
void BinaryTree<ElemType>::DisplayBTHelp(BinTreeNode<ElemType> *r, int Level) {
    if (r!=NULL)
    {
        DisplayBTHelp(r->leftChild,Level+1);
        cout << endl;
        for (int i = 0; i < Level - 1;i++) {
            cout << "    ";
        }
        cout << r->data;
        DisplayBTHelp(r->rightChild,Level+1);
    }
}

template<class ElemType>
void BinaryTree<ElemType>::DestroyHelp(BinTreeNode<ElemType> * &r) {
    if (r!=NULL) {
        DestroyHelp(r->leftChild);
        DestroyHelp(r->rightChild);
        delete r;
        r = NULL;  //保险起见，防止野指针
    }
}

template<class ElemType>
void BinaryTree<ElemType>::PreOrderHelp(BinTreeNode<ElemType> *r,
    void(*visit)(ElemType &))const {
    if(r!=NULL){
        (*visit)(r->data);
        PreOrderHelp(r->leftChild, visit);
        PreOrderHelp(r->rightChild, visit);
    }
}

template<class ElemType>
void BinaryTree<ElemType>::InOrderHelp(BinTreeNode<ElemType> *r,
    void(*visit)(ElemType &))const {
    if (r != NULL) {
        InOrderHelp(r->leftChild, visit);
        (*visit)(r->data);
        InOrderHelp(r->rightChild, visit);
    }
}

template<class ElemType>
void BinaryTree<ElemType>::PostOrderHelp(BinTreeNode<ElemType> *r,
    void(*visit)(ElemType &))const {
    if (r != NULL) {
        PostOrderHelp(r->leftChild, visit);
        PostOrderHelp(r->rightChild, visit);
        (*visit)(r->data);
    }
}

template<class ElemType>
int BinaryTree<ElemType>::NodeCountHelp(const BinTreeNode<ElemType> *r)const {
    if (r==NULL) {
        return 0;
    }
    else {
        return NodeCountHelp(r->leftChild) + NodeCountHelp(r->rightChild) + 1;
    }
}

template<class ElemType>
int BinaryTree<ElemType>::HeightHelp(const BinTreeNode<ElemType> *r)const {
    if (r==NULL) {
        return 0;
    }
    else {
        int lHeight, rHeight;
        lHeight = HeightHelp(r->leftChild);
        rHeight = HeightHelp(r->rightChild);
        return (lHeight>rHeight?lHeight:rHeight) + 1;
    }
}

template<class ElemType>
BinTreeNode<ElemType> *BinaryTree<ElemType>::CopyTreeHelp(BinTreeNode<ElemType> *r) {
    if (r == NULL) {
        return NULL;
    }
    else {
        BinTreeNode<ElemType> *lChild = CopyTreeHelp(r->leftChild);
        BinTreeNode<ElemType> *rChild = CopyTreeHelp(r->rightChild);
        BinTreeNode<ElemType> *rt = new BinTreeNode<ElemType>(r->data, lChild, rChild);

        return rt;
    }
}


/******************二叉树类函数的实现***************************/

template<class ElemType>
BinaryTree<ElemType>::BinaryTree(ElemType pre[], ElemType in[], int n) {
    CreateBinTree(root,pre,in,0,n-1,0,n-1);
}

template<class ElemType>
BinaryTree<ElemType>::~BinaryTree(){
    DestroyHelp(root);
    cout << "析构函数调用" << endl;
}

template<class ElemType>
void BinaryTree<ElemType>::DisplayBT() {
    DisplayBTHelp(root,1);
    cout << endl;
}

template<class ElemType>
BinTreeNode<ElemType> *BinaryTree<ElemType>::GetRoot() {
    return root;
}

template<class ElemType>
bool BinaryTree<ElemType>::Empty() {
    return root == NULL;
}

template<class ElemType>
void BinaryTree<ElemType>::PreOrder(void(*visit)(ElemType &)) {
    PreOrderHelp(root,visit);
}

template<class ElemType>
void BinaryTree<ElemType>::InOrder(void(*visit)(ElemType &)) {
    InOrderHelp(root, visit);
}

template<class ElemType>
void BinaryTree<ElemType>::PostOrder(void(*visit)(ElemType &)) {
    PostOrderHelp(root, visit);
}

template<class ElemType>
int BinaryTree<ElemType>::NodeCount()const {
    return NodeCountHelp(root);
}

template<class ElemType>
int BinaryTree<ElemType>::Height()const {
    return HeightHelp(root);
}

template<class ElemType>
BinaryTree<ElemType>::BinaryTree(const BinaryTree<ElemType> &copy) {
    root = CopyTreeHelp(copy.root);
}

template<class ElemType>
BinaryTree<ElemType> &BinaryTree<ElemType>::operator=(const BinaryTree<ElemType> &copy) {
    if (&copy!=this) {
        DestroyHelp(root);
        root = CopyTreeHelp(copy.root);
    }
    return *this;
}

main.cpp

#include<iostream>
#include"SqBinaryTree.cpp"

using namespace std;

void show(char &a) {
    cout << a << "  ";
}

void test() {
    char pre[] = "ABCDEFGHI";
    char in[] = "DCBAGFHEI";
    int n = 9;
    BinaryTree<char> Tree(pre,in,n);
    //Tree.GetRoot();
    //cout << Tree.GetRoot()->data<<endl;
    //Tree.DisplayBT();
    cout << Tree.Empty() << endl;
    void (*visit) (char &);
    visit = show;
    Tree.PreOrder(visit);
    cout << endl;
    Tree.InOrder(visit);
    cout << endl;
    Tree.PostOrder(visit);
    cout << endl;
    cout << Tree.NodeCount() << endl;
    cout << Tree.Height() << endl;
    BinaryTree<char> T(Tree);
    T.DisplayBT();
    BinaryTree<char> T1 = T;
    T1.DisplayBT();
}

int main() {
    
    test();
    system("pause");
    return 0;
}