652. 寻找重复的子树

给你一棵二叉树的根节点 root ，返回所有 重复的子树 。

 

对于同一类的重复子树，你只需要返回其中任意 一棵 的根结点即可。

如果两棵树具有 相同的结构 和 相同的结点值 ，则认为二者是 重复 的。

示例 1：

输入：root = [1,2,3,4,null,2,4,null,null,4]
输出：[[2,4],[4]]

示例 2：

输入：root = [2,1,1]
输出：[[1]]

示例 3：

输入：root = [2,2,2,3,null,3,null]
输出：[[2,3],[3]]

 

提示：

• 树中的结点数在 [1, 5000] 范围内。
• -200 <= Node.val <= 200

class Solution {
public:

    //判断两棵树是否相同
    bool isSameTree(TreeNode* left, TreeNode*right)
    {
        if (nullptr == left && nullptr == right)
        {
            return true;
        }
        if ((nullptr == left && nullptr != right)|| (nullptr != left && nullptr == right))
        {
            return false;
        }
        if (left->val != right->val)
        {
            return false;
        }
        bool leftB = isSameTree(left->left, right->left);
        bool rightB = isSameTree(left->right, right->right);

        return leftB && rightB;
    }

    vector<TreeNode*>findSubtrees(TreeNode* root)
    {
        if (nullptr == root->left || nullptr == root->right)
        {
            return vector<TreeNode*>{};
        }

        vector<TreeNode*>ret;

        TreeNode* left = root->left;
        TreeNode* right = root->right;

        queue<TreeNode*>leftQue;
        queue<TreeNode*>rightQue;

        leftQue.push(left);
        while (!leftQue.empty())
        {
            TreeNode* nodeLeft = leftQue.front();
            leftQue.pop();
            if (nullptr != nodeLeft->left)
            {
                leftQue.push(nodeLeft->left);
            }
            if (nullptr != nodeLeft->right)
            {
                leftQue.push(nodeLeft->right);
            }
            rightQue.push(right);
            while (!rightQue.empty())
            {
                TreeNode* nodeRight = rightQue.front();
                rightQue.pop();
                if (isSameTree(nodeLeft, nodeRight))
                {
                    ret.push_back(nodeLeft); //子树也要
                }
                if (nullptr != nodeRight->left)
                {
                    rightQue.push(nodeRight->left);
                }
                if (nullptr != nodeRight->right)
                {
                    rightQue.push(nodeRight->right);
                }
            }
        }
        return ret;
    }

    vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) 
    {
        queue<TreeNode*>que;
        que.push(root);
        while (!que.empty())
        {
            TreeNode* node = que.front();
            que.pop();
            vector<TreeNode*> tmp = findSubtrees(node);
            retVec.insert(retVec.end(), tmp.begin(), tmp.end());
            if (nullptr != node->left)
            {
                que.push(node->left);
            }
            if (nullptr != node->right)
            {
                que.push(node->right);
            }

        }

        vector<TreeNode*> retVec2;
        vector<bool> bVec(retVec.size(), false);
        for (int i = 0; i < retVec.size(); i++)
        {
            for (int j = i + 1; j < retVec.size(); j++)
            {
                if (isSameTree(retVec[i], retVec[j]))
                {
                    bVec[j] = true;
                }
            }
        }

        for (int i = 0; i < bVec.size(); i++)
        {
            if (false == bVec[i])
            {
                retVec2.push_back(retVec[i]);
            }
        }

        return retVec2;
    }

public:
    vector<TreeNode*> retVec;
};