判断一个二叉树A是否有一个二叉树B作为子树 cpp回答

递归版本

#include <iostream>    // 包含输入输出流库

// 定义树节点结构体
struct TreeNode {
    int val;            // 节点值
    TreeNode* left;     // 左子节点指针
    TreeNode* right;    // 右子节点指针
    // 构造函数，初始化节点值及左右子节点
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

class Solution {
public:
    // 判断B是否是A的子结构
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        // 如果A为空或B为空，返回false（空树不是任何树的子结构）
        if (A == nullptr || B == nullptr) return false;
        
        // 递归判断：
        // 1. B是否是以A为根的子结构
        // 2. B是否是A的左子树的子结构
        // 3. B是否是A的右子树的子结构
        return isSubStructureCore(A, B) || isSubStructure(A->left, B) || isSubStructure(A->right, B);
    }

private:
    // 判断以R为根的树是否包含以S为根的树
    bool isSubStructureCore(TreeNode* R, TreeNode* S) {
        // 如果S为空，说明S已经匹配完，返回true
        if (S == nullptr) return true;
        
        // 如果R为空但S不为空，说明不匹配，返回false
        if (R == nullptr) return false;
        
        // 如果当前节点值不相等，不匹配，返回false
        if (R->val != S->val) return false;
        
        // 递归判断左右子树是否匹配
        return isSubStructureCore(R->left, S->left) && isSubStructureCore(R->right, S->right);
    }
};

int main() {
    // 创建示例树A
    TreeNode* A = new TreeNode(3);
    A->left = new TreeNode(4);
    A->right = new TreeNode(5);
    A->left->left = new TreeNode(1);
    A->left->right = new TreeNode(2);

    // 创建示例树B
    TreeNode* B = new TreeNode(4);
    B->left = new TreeNode(1);
    B->right = new TreeNode(2);

    Solution solution;
    // 检查B是否是A的子结构
    bool result = solution.isSubStructure(A, B);

    // 输出结果
    std::cout << (result ? "B is a substructure of A" : "B is not a substructure of A") << std::endl;

    // 清理内存（略，实际使用中应进行内存释放）
    return 0;
}

非递归版本

#include <iostream>    // 包含输入输出流库
#include <stack>       // 包含栈库

// 定义树节点结构体
struct TreeNode {
    int val;            // 节点值
    TreeNode* left;     // 左子节点指针
    TreeNode* right;    // 右子节点指针
    // 构造函数，初始化节点值及左右子节点
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

class Solution {
public:
    // 判断B是否是A的子结构
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        if (A == nullptr || B == nullptr) return false;
        
        // 使用栈进行非递归遍历，开始时将根节点A压入栈中
        std::stack<TreeNode*> stack;
        stack.push(A);
        
        // 遍历栈直到为空
        while (!stack.empty()) {
            // 弹出栈顶节点
            TreeNode* node = stack.top();
            stack.pop();
            
            // 判断从当前节点开始是否包含B作为子结构
            if (isSubStructureCore(node, B)) return true;
            
            // 如果当前节点的左子节点不为空，将其压入栈中
            if (node->left != nullptr) stack.push(node->left);
            // 如果当前节点的右子节点不为空，将其压入栈中
            if (node->right != nullptr) stack.push(node->right);
        }
        
        // 遍历完所有节点后仍未找到B的子结构，返回false
        return false;
    }

private:
    // 判断以R为根的树是否包含以S为根的树（非递归实现）
    bool isSubStructureCore(TreeNode* R, TreeNode* S) {
        if (S == nullptr) return true;   // S为空说明S已经匹配完，返回true
        if (R == nullptr) return false;  // R为空但S不为空，说明不匹配，返回false
        
        std::stack<std::pair<TreeNode*, TreeNode*>> stack;
        stack.push({R, S});
        
        while (!stack.empty()) {
            auto [nodeR, nodeS] = stack.top();
            stack.pop();
            
            // 如果当前节点值不相等，返回false
            if (nodeR == nullptr || nodeR->val != nodeS->val) return false;
            
            // 如果S的右子节点不为空，将节点对 (nodeR->right, nodeS->right) 压入栈中
            if (nodeS->right != nullptr) stack.push({nodeR->right, nodeS->right});
            // 如果S的左子节点不为空，将节点对 (nodeR->left, nodeS->left) 压入栈中
            if (nodeS->left != nullptr) stack.push({nodeR->left, nodeS->left});
        }
        
        // 如果遍历完后所有节点对都匹配成功，返回true
        return true;
    }
};

int main() {
    // 创建示例树A
    TreeNode* A = new TreeNode(3);
    A->left = new TreeNode(4);
    A->right = new TreeNode(5);
    A->left->left = new TreeNode(1);
    A->left->right = new TreeNode(2);

    // 创建示例树B
    TreeNode* B = new TreeNode(4);
    B->left = new TreeNode(1);
    B->right = new TreeNode(2);

    Solution solution;
    // 检查B是否是A的子结构
    bool result = solution.isSubStructure(A, B);

    // 输出结果
    std::cout << (result ? "B is a substructure of A" : "B is not a substructure of A") << std::endl;

    // 清理内存（略，实际使用中应进行内存释放）
    return 0;
}