【C语言&数据结构】相同的树：深入理解二叉树的结构与值比较

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
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 isSameTree(struct TreeNode* p, struct TreeNode* q) {
    if(p && q)  // 两个节点都不为空
    {
        if(p->val == q->val)  // 值相等
        {
            return isSameTree(p->left, q->left) 
                && isSameTree(p->right, q->right);
        }
        else  // 值不相等
        {
            return false;
        }
    }
    else  // 至少有一个节点为空
    {
        if(p == NULL && q == NULL)  // 都为空
            return true;
        return false;  // 一个空一个非空
    }
}

代码对比分析

方法一的优势

逻辑清晰：四个条件依次判断，层次分明
提前返回：遇到不匹配立即返回，提高效率
易于理解：每个条件都有明确的语义

方法二的特点

嵌套结构：通过if-else嵌套组织逻辑
代码紧凑：减少了重复的条件判断
思维路径：先处理双非空，再处理空节点情况

算法执行流程

示例1：`p = [1,2,3]`, `q = [1,2,3]`

text

复制代码

p:    1    q:    1
     / \       / \
    2   3     2   3

执行过程：

根节点：1 == 1，继续
左子树：2 == 2，继续
右子树：3 == 3，继续
所有叶子节点：NULL == NULL
返回true

示例2：`p = [1,2]`, `q = [1,null,2]`

text

复制代码

p:    1    q:    1
     /           \
    2             2

执行过程：

根节点：1 == 1，继续
左子树：p有左节点2，q左节点为NULL → 立即返回false

算法复杂度分析

时间复杂度：O(n)

n为节点数较少的那棵树的节点数
最坏情况需要比较所有节点
最好情况在根节点就发现不匹配

空间复杂度：O(h)

h为树的高度
递归调用栈的深度
最坏情况为O(n)，当树退化为链表时

递归思维模式总结

二叉树递归的通用模板

复制代码

bool treeFunction(struct TreeNode* root1, struct TreeNode* root2) {
    // 1. 处理空节点情况
    if (root1 == NULL && root2 == NULL) return true;
    if (root1 == NULL || root2 == NULL) return false;
    
    // 2. 处理当前节点
    if (!condition) return false;
    
    // 3. 递归处理子树
    return treeFunction(left1, left2) 
        && treeFunction(right1, right2);
}

与其他二叉树问题的对比

问题	比较模式	递归关系
相同的树	同步比较	p左vsq左 + p右vsq右
对称二叉树	镜像比较	左左vs右右 + 左右vs右左
子树检查	嵌套比较	当前树匹配或左子树匹配或右子树匹配

实际应用场景

1. 版本控制系统

比较文件目录结构是否相同
检测代码变更

2. 数据库索引

比较B+树结构的一致性
数据完整性验证

3. 编译器设计

抽象语法树(AST)比较
代码优化前后的等价性验证

扩展思考

迭代解法

除了递归，我们还可以使用栈或队列进行迭代比较：

复制代码

// 使用队列进行层次遍历比较
bool isSameTreeIterative(struct TreeNode* p, struct TreeNode* q) {
    // 使用队列同时遍历两棵树
    // 实现细节略...
}

大规模树优化

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

并行比较左右子树
使用哈希值快速排除不匹配的子树
记忆化已比较的子树对

常见错误与陷阱

错误1：忽略结构比较

复制代码

// 错误：只比较值，不比较结构
bool wrongCompare(struct TreeNode* p, struct TreeNode* q) {
    if(p->val != q->val) return false;
    return wrongCompare(p->left, q->left) 
        && wrongCompare(p->right, q->right);
    // 缺少空指针检查！
}

错误2：错误的比较顺序

复制代码

// 错误：先递归后判断
bool wrongOrder(struct TreeNode* p, struct TreeNode* q) {
    bool leftSame = isSameTree(p->left, q->left);  // 可能访问空指针！
    bool rightSame = isSameTree(p->right, q->right);
    
    if(p == NULL && q == NULL) return true;
    if(p == NULL || q == NULL) return false;
    if(p->val != q->val) return false;
    
    return leftSame && rightSame;
}

总结

判断两棵树是否相同是一个经典的递归问题，它教会我们：

双重比较思维：既要比较值，也要比较结构
递归基准情况：正确处理空节点的各种组合
提前终止优化：发现不匹配立即返回，避免不必要的计算
清晰的逻辑分层：按照空节点→值比较→递归比较的顺序组织代码

通过这个问题，我们不仅掌握了二叉树比较的技巧，更重要的是培养了处理递归问题的系统思维。记住：好的递归代码就像数学证明一样，优雅而严谨！

编程箴言：在递归的世界里，简单就是美，清晰就是力量。掌握递归，就掌握了解决树问题的金钥匙。