实验三二叉树的物理实现

#include<iostream>
#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)
    {
        elem = tmp;
        lc = l;
        rc = r;
    }
    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;
    }
};

#include <stdio.h>
#include"BinNode.h"
#include"string"
#include<queue>
template<typename E>
class BinTree
{
private:
    E *in;
    E *post;
    int size;
    BinNode<E>*root;
public:
    BinTree(int n)
    {
        root=NULL;
        size=n;
        in=new E[size];
        post=new E[size];
        for(int i=0;i<n;i++)cin>>post[i];
        for(int i=0;i<n;i++)cin>>in[i];
    }
    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(BinNode<E>*r)
    {

        if (r == NULL)
            return;
        if (r->left())
        {
            clear(r->left());
        }
        if (r->right())
        {
            clear(r->right());
        }
        delete r;
        r = NULL;
    }
    void clear()
    {
        clear(root);
        root = NULL;
    }
    void preorder(BinNode<E>* rt)
    {
        if(rt!=NULL)
        {
            cout<<rt->element()<<" ";
            preorder(rt->left());
            preorder(rt->right());
        }
    }
 void Inorder(BinNode<E>* rt)
    {
        if(rt)
        {
            Inorder(rt->left());
            cout<<rt->element()<<" ";
            Inorder(rt->right());
        }
    }
    void postorder(BinNode<E>* rt)
    {
        if(rt)
        {
            postorder(rt->left());
            postorder(rt->right());
            cout<<rt->element()<<" ";
        }
    }
    void LevelOrderTraverse(BinNode<E>*root)
    {
        queue<BinNode<E>*> q;
        if(root)
            q.push(root);
        BinNode<E>* b;
        while(!q.empty())
        {
            b=q.front();
            cout<<b->getValue()<<' ';
            q.pop();
            if(b->left())
                q.push(b->left());
            if(b->right())
                q.push(b->right());
        }
    }
    int BinTreeDepth(BinNode<E>*tmp)
    {
        if (tmp == NULL)
            return 0;
        int ld = 0;
        int rd = 0;
        if (tmp->left() != NULL)
            ld = BinTreeDepth(tmp->left());
        if (tmp->right() != NULL)
            rd = BinTreeDepth(tmp->right());
        if (ld >= rd)
            return ld + 1;
        else
            return rd + 1;
    }
    int BinTreeNodes(BinNode<E>*tmp)
    {
        if (tmp == NULL)
            return 0;
        queue<BinNode<E>*>que;
        que.push(tmp);
        BinNode<E>* curr;
        int sum = 0;
        while (que.empty() != true)
        {
            curr = que.front();
            if (curr->left() != NULL)
            {
                que.push(curr->left());
            }
            if (curr->right() != NULL)
            {
                que.push(curr->right());
            }
            que.pop();
            sum++;
        }
        return sum;
    }
    int BinTreeHeight(BinNode<E>*tmp)
    {
        if (tmp == NULL)
            return 0;
        return BinTreeDepth(tmp) - 1;
    }
    int BinTreeLeafs(BinNode<E>*tmp)
    {
        if (tmp == NULL)
            return 0;
        queue<BinNode<E>*>que;
        que.push(tmp);
        BinNode<E>* curr;
        int sum = 0;
        while (que.empty() != true)
        {
            curr = que.front();
            if (curr->left() != NULL)
            {
                que.push(curr->left());
            }
            if (curr->right() != NULL)
            {
                que.push(curr->right());
            }
            if (curr->right() == NULL&&curr->left() == NULL)
                sum++;
            que.pop();
        }
        return sum;
    }
    bool find(BinNode<E>*tmp, E e)
    {
        if (tmp == NULL)
            return false;
        queue<BinNode<E>*>que;
        que.push(tmp);
        BinNode<E>* curr;
        while (que.empty() != true)
        {
            curr = que.front();
            if (curr->left() != NULL)
            {
                que.push(curr->left());
            }
            if (curr->right() != NULL)
            {
                que.push(curr->right());
            }
            if (curr->getValue() == e)
                return true;
            que.pop();
        }
        return false;
    }
    BinNode<E>*create(int postL,int postR,int inL,int inR)
    {
        if(postL>postR)return NULL;
        BinNode<E>*r = new BinNode<E>;
        r->setValue(post[postR]);
        int k;
        for(k = inL; k <= inR; k++)
        {
            if(in[k] == post[postR]) break;
        }
        int numLeft = k - inL;
        r->setLeft ( create(postL, postL + numLeft - 1, inL, k - 1));
        r->setRight( create(postL + numLeft, postR - 1, k + 1, inR));
        return r;
    }
};

#include"BinTree.h"
#include<iostream>
using namespace std;
int main()
{
    int n;
    cin>>n;
    BinTree<int>bt(n);
    BinNode<int>*r =bt.create(0,n-1,0,n-1);
    bt.LevelOrderTraverse(r);
    return 0;
}