HNU数据结构与算法实验三-基于二叉链表的二叉树实现-2023年

【问题描述】

根据课程学习内容，补齐线性表的相关代码实现。

11
A B / / C D / / E / /
C

上述输入将构造一棵包含11个节点的二叉树，并将查询“C”是否存在。

上述输入对应生成的二叉树如下图

【输入形式】

第一行：输入二叉树总节点数n，（空节点也计算在内）

第二行：以空格分隔的节点数据（string类型），其中 / 表示该节点为空，其他数据为该节点保存的信息

第三行：拟在二叉树中查询的值

#include<iostream>
#include"string"
#include<queue>

using  namespace  std;

template<typename  E>
class  BinNode
{
private:
        BinNode*lc;
        BinNode*rc;
        E  elem;
//ÒÔÏÂΪʵÑéÒªÇó¼üÈëµÄÄÚÈÝ 
public:
        BinNode()
        {
            lc=NULL;
            rc=NULL;
        }
        BinNode(E  tmp,  BinNode*l=NULL,  BinNode*r=NULL)
        {
            lc=l;
            rc=r;
            elem=tmp;
        }
        BinNode*left()
        {
            return lc;
        }
        BinNode*right()
        {
            return rc;
        }
        void  setLeft(BinNode*l)
        {
            lc=l;
        }
        void  setRight(BinNode*r)
        {
            rc=r;
        }
        void  setValue(E  tmp)
        {
            elem=tmp;
        }
        E  getValue()
        {
            return elem;
        }
        bool  isLeaf()
        {
            if(lc==NULL&&rc==NULL) return true;
            else return false;
        }
};

template<typename  E>
class  BinTree
{
private:
        BinNode<E>*root;
        void  clear(BinNode<E>*r)//ÏÈÅжÏÊÇ·ñΪ¿Õ£¬·Ç¿Õʱ¼ÇµÃ×îºóɾ³ýr 
        {
            if(r==NULL) return;
            if(r->left()) clear(r->left());
            if(r->right()) clear(r->right());
            delete r;
        }
        void  preOrder(BinNode<E>*tmp,void(*visit)(BinNode<E>*node))
        {
            if(tmp==NULL) return;
            visit(tmp);
            preOrder(tmp->left(),visit);
            preOrder(tmp->right(),visit);
        }
        void  inOrder(  BinNode<E>*tmp,void(*visit)(BinNode<E>*node))
        {
            if(tmp==NULL) return;
            inOrder(tmp->left(),visit);
            visit(tmp);
            inOrder(tmp->right(),visit);
        }
        void  postOrder(BinNode<E>*tmp,void(*visit)(BinNode<E>*node))
        {
            if(tmp==NULL) return;
            postOrder(tmp->left(),visit);
            postOrder(tmp->right(),visit);
            visit(tmp);
        }
        void  LevelOrderTranverse(  BinNode<E>*tmp,void(*visit)(BinNode<E>*node))
        {
            if(tmp==NULL) return;
            queue<BinNode<E>*> que;
            BinNode<E>* bin;
            que.push(tmp)
            while(!que.empty())
            {
                bin=queue.front();
                visit(bin);
                que.pop();
                if(tmp->left()) que.push(tmp->left());
                if(tmp->right()) que.push(tmp->right());
            }
        }
        int  BinTreeDepth(BinNode<E>*tmp)//½¨ÒéÏÈд¼ÆËãÊ÷¸ß¶ÈµÄº¯Êý£¬Ð´³öÀ´Ö®ºóÔÙ´Ë´¦µ÷Óü´¿É 
        {
            if(BinTreeHeight(tmp)>0) return (BinTreeHeight()-1);
            else return 0;
        }
        int  BinTreeNodes(BinNode<E>*tmp)//·Ö×óÓÒÁ½Ö§Í³¼Æ£¬×îºó¼ÇµÃ¼Ó1 
        {
            if(tmp==NULL) return;
            return BinTreeNodes(tmp->left())+BinTreeNodes(tmp->right())+1;
        }
        int  BinTreeHeight(BinNode<E>*tmp)//ÏÈÅжÏÊÇ·ñΪ¿Õ£¬·Ç¿ÕʱÅжÏÊÇ·ñΪҶ½Úµã£¬²»ÊÇÒ¶½ÚµãʱÔÙ¼ÌÐøÅжϠ
        {
            if(tmp==NULL) return 0;
            if(tmp->isLeaf()) return 1;
            int lh=BinTreeHeight(tmp->left());
            int rh=BinTreeHeight(tmp->right());
            return lh>rh? 1+lh:1+rh//Ë«Ä¿ÔËËã·û£¬ÏÈÅжÏlhºÍrhµÄ´óС£¬Èôlh´óÓÚrhÔòÖ´ÐÐ1+lhµÄ²Ù×÷£¬·ñÔòÖ´ÐÐ1+rhµÄ²Ù×÷ 
        }
        int  BinTreeLeafs(BinNode<E>*tmp)//·Ö×óÓÒÁ½Ö§Åжϣ¬µ÷ÓÃÅжÏÒ¶½ÚµãµÄº¯Êý 
        {
            if(tmp==NULL) return 0;
            if(tmp->isLeaf()) return 1;
            return BinTreeLeafs(tmp->left())+BinTreeLeafs(tmp->right());
        }
        bool  find(BinNode<E>*tmp,  E  e)//·Ö×óÓÒÁ½Ö§²éÕÒ 
        {
            if(tmp==NULL) return;
            if(tmp->getValue()==e) return true;
            return find(tmp->left(),e)||find(tmp->right(),e);
        }
//ʵÑ鿼²ìÄÚÈݵ½´Ë½áÊø 
public:
        BinTree()
        {
                root=new  BinNode<E>;
        }
        ~BinTree()
        {
                clear(root);
        }
        bool  BinTreeEmpty()
        {
                if  (root  ==  NULL)
                        return  true;
                else
                        return  false;
        }
        BinNode<E>*getRoot()
        {
                return  root;
        }
        void  setRoot(BinNode<E>*r)
        {
                root  =  r;
        }
        
        void  clear()
        {
                clear(root);
                root  =  NULL;
        }
        void  preOrder(void(*visit)(BinNode<E>*node))
        {
                preOrder(root,visit);
        }
        void  inOrder(void(*visit)(BinNode<E>*node))
        {
                inOrder(root,visit);
        }
        void  postOrder(void(*visit)(BinNode<E>*node))
        {
                postOrder(root,visit);
        }
        void  LevelOrderTranverse(void(*visit)(BinNode<E>*node))
        {
                LevelOrderTranverse(root,visit);
        }
        int  BinTreeDepth()
        {
                return  BinTreeDepth(root);
        }
        int  BinTreeNodes()
        {
                return  BinTreeNodes(root);
        }
        int  BinTreeHeight()
        {
                return  BinTreeHeight(root);
        }
        int  BinTreeLeafs()
        {
                return  BinTreeLeafs(root);
        }
        bool  find(E  e)
        {
                return  find(root,  e);
        }
};