非递归层序遍历法

class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if(pRoot2 == nullptr || pRoot1 == nullptr)
        {
            return false;
        }
        queue<TreeNode*> que;             //使用层序遍历
        TreeNode *p1 = pRoot1;
        int sum = 0;
        que.push(p1);
        while(!que.empty())
        {
            p1 = que.front();
            que.pop();
            if(p1->val == pRoot2->val)   //所有相等的都有可能是起点
            {
                sum+=Subtree(p1, pRoot2);
            }
            if(p1->left != nullptr)
            {
                que.push(p1->left);
            }
            if(p1->right != nullptr)
            {
                que.push(p1->right);
            }
        }
        return sum ? true : false;
    }
    int Subtree(TreeNode* pRoot1, TreeNode* pRoot2)  //相同返回1
    { 
        TreeNode *p1 = nullptr,*p2 = nullptr;
        queue<TreeNode*> que1,que2;
        que1.push(pRoot1);
        que2.push(pRoot2);
        while(!que1.empty() && !que2.empty())
        {
            p1 = que1.front();
            p2 = que2.front();

            if(p1->val != p2->val)
            {
                break;
            }
            que1.pop();
            que2.pop();
            if(p2->left != nullptr)  
            {
                que2.push(p2->left);
                if(p1->left != nullptr)
                    que1.push(p1->left);
            }
            if(p2->right != nullptr)
            {
                que2.push(p2->right);
                if(p1->right != nullptr)
                    que1.push(p1->right);
            }
        }
        return que2.empty() ? 1 : 0;
    }
};