输入两棵二叉树A，B，判断B是不是A的子结构(c++实现)

#include <iostream>
#include <cstdio>
#include <stdio.h>
#include <string>
#include <queue>
#include <stack>
using namespace std;

class Node{
public :
    char data;
    struct Node *lchild,*rchild;
};

class BiTree{
public:
    Node * root;//头结点
    int height=;//树的高度
    BiTree() {root=NULL;}
    //层序创建二叉树
    void create_level(string &s)
    {
       int p=;
       root=new Node();

       Node *t,*i,*j;
       queue<Node*> qTree;//定义一个队列，存储节点
       while(true)
       {
           if(p==s.size())break;
           if(p==)//当头结点未创建
           {
               t=new Node();
               t->data=s[p];
               qTree.push(t);//头结点进队
               root=t;
               p++;
           }
           else
           {
               t=qTree.front();//该节点出队
               if(p==s.size())break;//树的构建完毕
               if(s[p]=='#')//不存在左节点
               {
                  t->lchild=NULL;
                  p++;
               }
               else//存在左节点
               {
                   i=new Node();
                   i->data=s[p];
                   t->lchild=i;//左节点进队
                   qTree.push(i);
                   p++;
               }

               if(p==s.size())break;
               if(s[p]=='#')//不存在右节点
               {
                  t->rchild=NULL;
                  p++;
               }
               else//存在右节点
               {
                   j=new Node();
                   j->data=s[p];
                   t->rchild=j;
                   qTree.push(j);
                   p++;
               }

               qTree.pop();//节点左右节点已创建，该节点出队
           }
       }

    }
};

class Solution
{
    bool isSubtree(Node* pRootA,Node* pRootB)
    {
        /*以下if语句不能调换，如果调换返回结果都为false
         *比如： A树：123 B树：123
         *     在遍历两树的节点2时，递归进入下一次，两树的节点2的左节点都为NULL，进入递归
         *     此时pRootA=NULL、pRootB=NULL，如果pRootA==NULL放在前面，返回false
        */
        if(pRootB==NULL) return true;
        if(pRootA==NULL) return false;
        if(pRootA->data==pRootB->data)
        {
            //如果树A树B节点值相等，继续递归遍历他们的左右节点是否相等
            return isSubtree(pRootA->lchild,pRootB->lchild)&& isSubtree(pRootA->rchild,pRootB->rchild);
        }
        else return false;
    }
public:
    bool HasSubtree(Node* pRootA,Node* pRootB)
    {
        if(pRootA==NULL||pRootB==NULL)return false;
        //从树A的该节点开始遍历看是否与B节点的根值是否相同 || 比较树A的该节点的左节点与树B的根节点 || 比较树A的该节点的右节点与树B的根节点
        return isSubtree(pRootA,pRootB)||HasSubtree(pRootA->lchild,pRootB)||HasSubtree(pRootA->rchild,pRootB);
    }
};

int main()
{
    BiTree a,b;
    string s1,s2;
    s1="88792####47";
    a.create_level(s1);
    s2="";
    b.create_level(s2);
    Solution s;
    bool bo=s.HasSubtree(a.root,b.root);
    cout<<bo<<endl;

    return ;
}