数据结构二叉树的所有基本功能实现。(C++版）

本人刚学数据结构，对树的基本功能网上找不到C++代码

便自己写了一份，贴出方便大家进行测试和学习。

大部分功能未测试，如有错误或者BUG，请高手们指教一下，谢谢。

结点声明：

BinTreeNode.h

 template<typename ElemType>
 struct BinTreeNode
 {
     ElemType data;                     //数据元素
     BinTreeNode<ElemType> *leftChild;  //指向左孩子的指针
     BinTreeNode<ElemType> *rightChild; //指向右孩子的指针
     BinTreeNode<ElemType> *pre;        //指向双亲的指针

     //函数构造
     BinTreeNode();
     BinTreeNode(const ElemType &val,
         BinTreeNode<ElemType> *lChild=NULL,
         BinTreeNode<ElemType> *rChild=NULL);
     BinTreeNode<ElemType> &operator =(const BinTreeNode<ElemType> &copy);
 };

 template<typename ElemType>
 BinTreeNode<ElemType>::BinTreeNode()
 {
     leftChild=rightChild=pre=NULL;
 }

 template<typename ElemType>
 BinTreeNode<ElemType>::BinTreeNode(const ElemType &val,
                         BinTreeNode<ElemType> *lChild,
                         BinTreeNode<ElemType> *rChild)
 {
     data=val;
     leftChild=lChild;
     rightChild=rChild;
     pre=NULL;
 }

 template<typename ElemType>
 BinTreeNode<ElemType> &BinTreeNode<ElemType>::operator =(const BinTreeNode<ElemType> &copy)
 {
     data=copy.data;
     leftChild=copy.leftChild;
     rightChild=copy.leftChild;
     pre=copy.pre;
 }

BinTreeNode.h

类声明：

BinaryTree.h

 #include"BinTreeNode.h"
 template<typename ElemType>
 class BinaryTree
 {
 protected:
     //数据成员
     BinTreeNode<ElemType> *root;
     //辅助函数
     void CreateBTreeHelp(BinTreeNode<ElemType> *&r,ElemType pre[],ElemType in[],int,int,int,int);//构造树
     BinTreeNode<ElemType> *CopyTreeHelp(const BinTreeNode<ElemType> *r);//复制二叉树
     void DestroyHelp(BinTreeNode<ElemType> *&r);//销毁r为根的二叉树
     //先，中，后序遍历
     void PreOrderHelp (const BinTreeNode<ElemType> *r,void (*visit) (const ElemType &))const;
     void InOrderHelp  (const BinTreeNode<ElemType> *r,void (*visit) (const ElemType &))const;
     void PostOrderHelp(const BinTreeNode<ElemType> *r,void (*visit) (const ElemType &))const;

     int HeightHelp(const BinTreeNode<ElemType> *r) const;//返回树的高度
     int NodeCountHelp(const BinTreeNode<ElemType> *r)const;//返回树的节点个数

 public:
     BinaryTree(){root=NULL}//无参构造
     BinaryTree(const ElemType &e);//建立以e元素为根的二叉树
     BinaryTree(BinTreeNode<ElemType> *r);//建立以r为根的二叉树
     virtual ~BinaryTree();//有指针用虚虚构
     BinaryTree<ElemType> &CreateBTree(ElemType pre[],ElemType in[],int n); //构造树
     BinTreeNode<ElemType> *GetRoot() const;//返回根
     bool Empty()const;
     bool GetElem(const BinTreeNode<ElemType> *cur,ElemType &e);//用e结点返回cur元素值
     bool SetTlem(const BinTreeNode<ElemType> *cur,const ElemType &e);//e赋值给cur
     //先，中，后序遍历
     void PreOrder(void (*visit) (const ElemType &))const;
     void InOrder(void (*visit) (const ElemType &))const;
     void PostOrder(void (*visit) (const ElemType &))const;
     //层次遍历
     void LevelOrder(void (*visit) (const ElemType &))const;
     int NodeCount()const;
     BinTreeNode<ElemType> *LeftChild(const BinTreeNode<ElemType> *cur)const;//返回cur左孩子
     BinTreeNode<ElemType> *RightChild(const BinTreeNode<ElemType> *cur)const;//返回cur右孩子
     BinTreeNode<ElemType> *Parent(const BinTreeNode<ElemType> *cur)const;//返回cur双亲
     void InsertLeftChild(BinTreeNode<ElemType> *cur,const ElemType &e);//插入左孩子
     void InsertRightChild(BinTreeNode<ElemType> *cur,const ElemType &e);//插入右孩子
     void DeleteLeftChild(BinTreeNode<ElemType> *cur);//删除左子树
     void DeleteRightChild(BinTreeNode<ElemType> *cur);//删除右子树
     int Height()const;//求二叉树高
     BinaryTree(const BinaryTree<ElemType> &copy);//复制构造函数
     BinaryTree<ElemType> &operator =(const BinaryTree<ElemType> &copy);//重载赋值运算符
 };
 #include"CreateBTree.h"
 #include"Destroy,copy,operator.h"
 #include"height.h"
 #include"NodeCount.h"
 #include"return,set.h"
 #include"Traversal.h"

BinaryTree.h

成员函数：

CreateBTree.h

 template<typename ElemType>
 void BinaryTree<ElemType>::CreateBTreeHelp(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++;
         CreateBTreeHelp(r->leftChild,pre,in,preLeft+,preLeft+mid-inLeft,inLeft,mid-);
         CreateBTreeHelp(r->rightChild,pre,in,preLeft+mid-inLeft+,preRight,mid+,inRight);
     }
 }

 template<typename ElemType>
 //构造树
 BinaryTree<ElemType>& BinaryTree<ElemType>::CreateBTree(ElemType pre[],ElemType in[],int n)
 {
     BinTreeNode<ElemType> *r;   //根
     CreateBTreeHelp(r,pre,in,,n-,,n-);
     //return BinaryTree<ElemType>(r);//Error:不应该返回局部变量的地址
     *this = BinaryTree<ElemType>(r);
     return *this;
 }

CreateBTree.h

Destroy,copy,operator.h

 //Destroy
 template<typename ElemType>
 void BinaryTree<ElemType>::DestroyHelp(BinTreeNode<ElemType> *&r)
 {
     if(r!=NULL)
     {
         DestroyHelp(r->leftChild);
         DestroyHelp(r->rightChild);
         delete r;
         r=NULL;
     }
 }
 template<typename ElemType>
 //删除左子树
 void BinaryTree<ElemType>::DeleteLeftChild(BinTreeNode<ElemType> *cur)
 {
     DestroyHelp(cur->leftChild);
 }
 template<typename ElemType>
 //删除右子树
 void BinaryTree<ElemType>::DeleteRightChild(BinTreeNode<ElemType> *cur)
 {
     DestroyHelp(cur->rightChild);
 }
 //虚构
 template<typename ElemType>
 BinaryTree<ElemType>::~BinaryTree()
 {
     DestroyHelp(root);
 }

 //Copy
 template<typename ElemType>
 BinTreeNode<ElemType> *BinaryTree<ElemType>::CopyTreeHelp(const BinTreeNode<ElemType> *r)
 {
     BinTreeNode<ElemType> *cur;
     if(r==NULL)   cur=NULL;
     else
     {
         BinTreeNode<ElemType> *lChild=CopyTreeHelp(r->leftChild);//复制左子树
         BinTreeNode<ElemType> *rChild=CopyTreeHelp(r->rightChild);//复制右子树
         cur=new BinTreeNode<ElemType>(r->data,lChild,rChild);
         //复制根节点
     }
     return cur;
 }
 template<typename ElemType>
 BinaryTree<ElemType>::BinaryTree(const BinaryTree<ElemType> &copy)
 {
     root=CopyTreeHelp(copy.root)
 }

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

Destroy,copy,operator.h

height.h

 template<typename ElemType>
 int BinaryTree<ElemType>::HeightHelp(const BinTreeNode<ElemType> *r) const
 {
     if(r==NULL)  return ;
     else
     {
         int lHeight,rHeight,height;
         lHeight=HeightHelp(r->leftChild);
         rHeight=HeightHelp(r->rightChild);
         height-=lHeight>rHeight?lHeight:rHeight;//深度为左右子树最大值加1;
         return height;
     }

 }

height.h

NodeCount.h

 template<class ElemType>
 int BinaryTree<ElemType>::NodeCountHelp(const BinTreeNode<ElemType> *r) const
 {
     int count;
     if (r == NULL)
         count=;
     else
     {
         count = NodeCountHelp(r->leftChild) + NodeCountHelp(r->rightChild) + ;
         //左孩子加右孩子结点数再加根节点。
     }
     return count;
 }
 template<class ElemType>
 int BinaryTree<ElemType>::NodeCount() const
 {
     return NodeCountHelp(root);
 }

NodeCount.h

return,set.h

template<typename ElemType>
//返回根
BinTreeNode<ElemType> *BinaryTree<ElemType>::GetRoot() const
{
    return root;
}

template<typename ElemType>
//用e结点返回cur元素值
bool BinaryTree<ElemType>::GetElem(const BinTreeNode<ElemType> *cur, ElemType &e)
{
    if(cur)
    {
        e = cur->data;
        return true
    }
    else
        return false;
}

template<typename ElemType>
//e赋值给cur
bool BinaryTree<ElemType>::SetTlem(const BinTreeNode<ElemType> *cur, const ElemType &e)
{
    if(cur)
    {
        cur->data = e;
        return true;
    }
    else
        return false;
}

template<typename ElemType>
//返回cur左孩子
BinTreeNode<ElemType> *BinaryTree<ElemType>::LeftChild(const BinTreeNode<ElemType> *cur)const
{
    if(cur->leftChild)
        return cur->leftChild;
    else
        return NULL;
}

template<typename ElemType>
//返回cur右孩子
BinTreeNode<ElemType> *BinaryTree<ElemType>::RightChild(const BinTreeNode<ElemType> *cur)const
{
    if(cur->RightChild)
        return cur->RightChild;
    else
        return NULL;
}

template<typename ElemType>
//插入左孩子
void BinaryTree<ElemType>::InsertLeftChild(BinTreeNode<ElemType> *cur,const ElemType &e)//插入左孩子
{
    if(!(cur->leftChild))
        cur->leftChild = new BinTreeNode<ElemType>(e);
    else throw "左孩子已存在!插入失败.";
}

template<typename ElemType>
//插入右孩子
void BinaryTree<ElemType>::InsertRightChild(BinTreeNode<ElemType> *cur,const ElemType &e)//插入右孩子
{
    if(!(cur->rightChild))
        cur->rightChild = new BinTreeNode<ElemType>(e);
    else throw "右孩子已存在!插入失败.";
}

template<typename ElemType>
//返回cur的双亲
BinTreeNode<ElemType> *BinaryTree<ElemType>::Parent(const BinTreeNode<ElemType> *cur)const
{
    if(cur->pre != NULL)
        return cur->pre;
    else
        return NULL;
}

template<typename ElemType>
//建立以r为根的二叉树
BinaryTree<ElemType>::BinaryTree(BinTreeNode<ElemType> *r)
{
    root = r;
}

template<typename ElemType>
//建立以e元素为根的二叉树
BinaryTree<ElemType>::BinaryTree(const ElemType &e)//建立以e元素为根的二叉树
{
    root = new BinTreeNode(e);
}

template<typename ElemType>
//判断树空
bool BinaryTree<ElemType>::Empty() const
{
    return root == NULL;
}

return,set.h

Traversal.h

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

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

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

 using namespace std;
 template<typename ElemType>
 void print(const ElemType &e )
 {
     cout<<e<<" ";
 }
 #include<queue>
 template<typename ElemType>
 void BinaryTree<ElemType>::LevelOrder(void (*visit) (const ElemType &))const
 {    //队列实现
     visit=print;
     queue<BinTreeNode<ElemType> *> q;
     BinTreeNode<ElemType> *t=GetRoot();
     if(t!=NULL) q.push(t);                //根非空，入队
     while(!q.empty())                //队不空
     {
         t=q.front();
         q.pop();                    //出队
         (*visit)(t->data);
         if(t->leftChild)
             q.push(t->leftChild);  //遍历左孩子
         if(t->rightChild)
             q.push(t->rightChild); //遍历右孩子
     }

 }

 /*
 //非递归先序遍历
 #include<stack>
 using namespace std;
 template<typename ElemType>
 void NonRecurPreOrder(const BinaryTree<ElemType> &bt,
                                         void (*visit) (const ElemType &))const
 {
     BinTreeNode<ElemType> *cur=bt.GetRoot();//当前结点
     stack<ElemType> s;
     while(cur)//cur不空
     {
         (*visit)(cur->data);//访问cur元素
         if(cur->leftChild)      //左孩子不空
         {    if(cur->rightChild) //右孩子也不空
                 s.push(cur);    //入栈（若右孩子空无须入栈）
         }
         else
         {
             if(cur->rightChild)  //左孩子空，右孩子不空（不入栈）
                 cur=cur->rightChild;
             else if(!s.empty())         //左右孩子都空，栈不空
                 {
                     cur=s.top();       //取出栈，退返。
                     s.pop();           //出栈
                 }
                 else //栈空
                     cur=NULL;//结束循环
         }
     }
 }
 */
 /*
 //非递归中序遍历
 template<typename ElemType>
 BinTreeNode<ElemType> *GoFarLeft(BinTreeNode<ElemType> *r,
                                  stack<ElemType> &s)
 {
     if(r==NULL)             //结点空
         return NULL;
     BinTreeNode<ElemType> *cur=r;
     while(cur->leftChild)    //往左走
     {
         s.push();            //左孩子进栈
         cur=cur->leftChild;
     }
     return cur;
 }

 template<typename ElemType>
 void NonRecurInOrder(const BinaryTree<ElemType> &bt,
                                         void (*visit) (const ElemType &))const
 {
     BinTreeNode<ElemType> *cur=bt.GetRoot();   //cur指向根节点
     stack<ElemType> s;
     cur=GoFarLeft(cur,s);                     //走到最底层
     while(cur)
     {
         (*visit)(cur->data);
         if(cur->rightChild)       //右孩子不空
             cur=GoFarLeft(cur->rightChild,s);  //遍历右孩子
         else if(!s.empty())       //右孩子空，取栈
         {    cur=s.top();    s.pop();}
             else                  //栈空
                 cur=NULL;
     }
 }
 */

 template<typename ElemType>
 void BinaryTree<ElemType>::PreOrder(void (*visit) (const ElemType &))const
 {
     PreOrderHelp(root,visit);
 }
 template<typename ElemType>
 void BinaryTree<ElemType>::InOrder(void (*visit) (const ElemType &))const
 {
     InOrderHelp(root,visit);
 }
 template<typename ElemType>
 void BinaryTree<ElemType>::PostOrder(void (*visit) (const ElemType &))const
 {
     PostOrderHelp(root,visit);
 }

Traversal.h

主函数：

 #include<iostream>
 #include"BinaryTree.h"
 using namespace std;
 BinaryTree<char>;
 int main()
 {
     char s1[], s2[];
     cin >> s1 >> s2;
     int n = strlen(s1);
     if(n != strlen(s2))
         cout << "ERROR\n";
     BinTreeNode<char> *root = NULL;
     BinaryTree<char> T(root);
     T.CreateBTree(s1, s2, n);
     T.LevelOrder(print<char>);
     cout<<endl;
     T.PreOrder(print<char>);
     cout<<endl;
     T.InOrder(print<char>);
     cout<<endl;
     T.PostOrder(print<char>);
     cout<<endl;
 }

main

运行结果如下：