【C语言&数据结构】另一棵树的子树：递归思维的双重奏

bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    if(p == NULL && q == NULL)
        return true;
    if(p == NULL || q == NULL)
        return false;
    if(p->val != q->val)
        return false;   
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}

这个函数采用经典的递归模式：

双空：相同
单空：不同
值不等：不同
递归比较左右子树

方法一：值匹配优化

复制代码

bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot) {
    if(root == NULL)  // subRoot不为空，root为空肯定不匹配
        return false;
    
    // 值相等时进行完整树比较
    if(root->val == subRoot->val && isSameTree(root, subRoot))
        return true;
    
    // 在左右子树中继续寻找
    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}

方法二：直接比较

复制代码

bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot) {
    if(root == NULL)  // 题目保证subRoot不为空
        return false;
    
    // 直接比较当前树
    if(isSameTree(root, subRoot))
        return true;
    else
    {
        // 在左右子树中继续寻找
        return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
    }
}

算法深度解析

方法一的优势

智能剪枝策略：

复制代码

if(root->val == subRoot->val && isSameTree(root, subRoot))

先比较节点值，值不相等直接跳过完整树比较
减少不必要的递归调用
在实际应用中性能更好

方法二的特点

逻辑直接：

无论值是否相等，都进行完整树比较
代码更简洁直观
在某些情况下可能更易理解

示例分析

示例1：`root = [3,4,5,1,2]`, `subRoot = [4,1,2]`

text

复制代码

root:     3      subRoot:   4
         / \               / \
        4   5             1   2
       / \
      1   2

执行过程（方法一）：

根节点3：值3≠4，跳过完整比较
递归左子树4：值4=4，进行完整比较
- 节点4=4，继续
- 左子树1=1，继续
- 右子树2=2，继续
- 所有节点匹配，返回true

递归调用树分析

方法一的递归结构

text

复制代码

isSubtree(3,4)
├── 3≠4 → 跳过完整比较
├── isSubtree(4,4) ✓
│   ├── 4=4 → 完整比较
│   │   ├── isSameTree(4,4) ✓
│   │   └── 返回true
└── isSubtree(5,4) ✗

性能对比

场景	方法一	方法二
根节点值匹配	立即进行完整比较	立即进行完整比较
根节点值不匹配	跳过完整比较	仍然进行完整比较
最坏情况	O(n×m)	O(n×m)
平均情况	优于方法二	标准实现

算法复杂度分析

时间复杂度：O(n×m)

n：root的节点数
m：subRoot的节点数
最坏情况：对root的每个节点都进行完整的子树比较

空间复杂度：O(h)

h：root树的高度
递归调用栈的深度

关键洞察

1. 递归的组合艺术

这个问题展示了如何将简单递归函数（isSameTree）组合成复杂递归函数（isSubtree）

2. 剪枝优化思想

方法一的优化体现了重要的算法设计原则：尽早发现不匹配，避免不必要的计算

3. 问题分解策略

将复杂问题分解为：

遍历主树（isSubtree）
比较子树（isSameTree）

边界情况处理

空树处理

复制代码

if(root == NULL)
    return false;

题目明确subRoot不为空
root为空肯定不包含子树

相同树的情况

当subRoot与root完全相同时，应该返回true，这包含在算法中。

扩展思考

1. 多子树查找

如果要求找到所有匹配的子树，如何修改算法？

2. 近似匹配

如果允许少量节点值不同，如何实现近似子树匹配？

3. 大规模优化

对于非常大的树，可以考虑：

使用哈希值快速排除不匹配的子树
并行搜索左右子树

实际应用场景

1. 代码查重

检测代码片段是否包含抄袭
抽象语法树的子树匹配

2. 生物信息学

DNA序列的模式匹配
蛋白质结构树的相似性分析

3. 文件系统

目录结构的相似性检测
重复文件查找

常见错误与陷阱

错误1：忽略空指针检查

复制代码

// 错误：可能访问空指针
bool wrongSubtree(struct TreeNode* root, struct TreeNode* subRoot) {
    if(isSameTree(root, subRoot))
        return true;
    return wrongSubtree(root->left, subRoot) || wrongSubtree(root->right, subRoot);
    // 如果root为NULL，root->left会崩溃
}

错误2：错误的逻辑关系

复制代码

// 错误：使用&&而不是||
bool wrongLogic(struct TreeNode* root, struct TreeNode* subRoot) {
    if(root == NULL) return false;
    if(isSameTree(root, subRoot)) return true;
    return wrongLogic(root->left, subRoot) && wrongLogic(root->right, subRoot);
    // 必须左右子树有一个匹配即可，不是必须都匹配
}

总结

通过分析子树的两种判断方法，我们学到了：

递归的层次思维：将大问题分解为相同的小问题
算法组合技巧：复用已有函数构建复杂功能
性能优化意识：通过条件判断减少不必要的计算
边界情况处理：正确处理空指针和特殊输入

方法一 vs 方法二：

方法一：性能更优，实际应用推荐
方法二：逻辑更直白，教学演示适用

这个问题的精妙之处在于它展示了递归思维的普适性------相同的递归模式可以解决看似不同但本质相似的问题。掌握这种思维，就能在算法的世界里游刃有余。

记住：在递归的世界里，复杂只是简单的重复，困难只是基础的组合！