LeetCode 965：单值二叉树的判断与实现

1. 问题理解与需求分析

今天我们来解决LeetCode第965题——判断单值二叉树（Univalued Binary Tree）。这个问题看似简单，但能很好地考察我们对二叉树遍历和递归思想的理解。

什么是单值二叉树？
单值二叉树是指树中所有节点值都相同的二叉树。换句话说，从根节点到每个叶子节点，整棵树的所有节点值都必须相等。这个概念在实际应用中可能出现在数据一致性检查、配置验证等场景。

问题输入输出

• 输入：二叉树的根节点指针
• 输出：布尔值（true表示是单值二叉树，false表示不是）

示例分析
示例1中的树[1,1,1,1,1,null,1]所有非空节点值都是1，所以返回true。而示例2中的树[2,2,2,5,2]有一个节点值为5，与其他节点值不同，因此返回false。

2. 解题思路与算法设计

2.1 基础思路

最直观的想法是：我们需要检查树中每个节点的值是否都相同。这自然引出了遍历整棵树的需求。二叉树的遍历方式主要有三种：

• 前序遍历（根-左-右）
• 中序遍历（左-根-右）
• 后序遍历（左-右-根）

对于这个问题，遍历顺序其实并不重要，因为我们只需要确保所有节点值相同即可。

2.2 递归DFS方案

我们选择深度优先搜索（DFS）的递归实现，原因如下：

1. 代码简洁直观
2. 二叉树本身就是递归定义的数据结构
3. 递归能自然地表达"检查整棵树"这个需求

具体算法步骤：

1. 记录根节点的值作为目标值
2. 从根节点开始递归检查每个节点：
   • 如果节点为空，返回true（空树视为满足条件）
   • 如果节点值不等于目标值，返回false
   • 递归检查左右子树

2.3 时间复杂度分析

该算法需要访问树中的每个节点一次，因此时间复杂度为O(n)，其中n是树中节点数量。空间复杂度取决于递归调用栈的深度，最坏情况下（树退化为链表）为O(n)，平均情况下为O(log n)。

3. 代码实现与解析

3.1 数据结构定义

首先我们看题目给出的二叉树节点定义：

c复制struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

这是一个标准的二叉树节点结构，包含：

• val：节点存储的整数值
• left：指向左子节点的指针
• right：指向右子节点的指针

3.2 辅助DFS函数

c复制bool dfs(struct TreeNode* root, int target) {
    if (!root) return true;              // 空节点不影响单值性
    if (root->val != target) return false; // 发现不同值立即返回
    return dfs(root->left, target) && dfs(root->right, target); // 递归检查子树
}

这个辅助函数实现了核心逻辑：

1. 边界条件处理：空节点直接返回true
2. 值检查：当前节点值不等于目标值时返回false
3. 递归检查：只有当左右子树都满足条件时才返回true

注意：这里使用短路求值（&&操作符的特性），一旦左子树返回false就不会再检查右子树，提高了效率。

3.3 主函数实现

c复制bool isUnivalTree(struct TreeNode* root) {
    if (!root) return true;  // 处理空树情况
    return dfs(root, root->val); // 以根节点值为目标开始检查
}

主函数做了两件事：

1. 处理空树的特殊情况（虽然题目约束节点数≥1，但良好的习惯是处理边界情况）
2. 调用DFS函数，传入根节点和根节点值作为初始目标值

4. 测试用例与验证

为了确保代码正确性，我们应该设计多种测试用例：

4.1 基础测试

c复制// 示例1
[1,1,1,1,1,null,1] → true
// 示例2
[2,2,2,5,2] → false

4.2 边界测试

c复制// 单节点树
[1] → true
// 左斜树
[1,1,null,1,null,1] → true
// 右斜树
[1,null,1,null,1,null,1] → true
// 包含不同值的树
[1,1,2] → false

4.3 特殊测试

c复制// 空树
[] → true（虽然题目约束节点数≥1）
// 大值测试
[99999,99999,99999] → true
// 混合值测试
[1,1,1,2,1] → false

5. 优化与变种思考

5.1 迭代解法

虽然递归解法简洁，但了解迭代解法也很重要。我们可以使用栈来实现DFS：

c复制bool isUnivalTree(struct TreeNode* root) {
    if (!root) return true;
    int target = root->val;
    struct TreeNode* stack[100];
    int top = -1;
    stack[++top] = root;
    
    while (top >= 0) {
        struct TreeNode* node = stack[top--];
        if (node->val != target) return false;
        if (node->right) stack[++top] = node->right;
        if (node->left) stack[++top] = node->left;
    }
    return true;
}

这种解法避免了递归带来的栈溢出风险，适合处理深度很大的树。

5.2 广度优先搜索(BFS)解法

我们也可以用队列实现BFS：

c复制bool isUnivalTree(struct TreeNode* root) {
    if (!root) return true;
    int target = root->val;
    struct TreeNode* queue[100];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        if (node->val != target) return false;
        if (node->left) queue[rear++] = node->left;
        if (node->right) queue[rear++] = node->right;
    }
    return true;
}

BFS按层遍历，适合处理宽度较大的树。

5.3 并行检查优化

在递归解法中，我们可以添加提前终止的优化：

c复制bool dfs(struct TreeNode* root, int target) {
    if (!root) return true;
    if (root->val != target) return false;
    // 如果左子树已经失败，不再检查右子树
    if (!dfs(root->left, target)) return false;
    return dfs(root->right, target);
}

这种优化在发现不一致时能尽早返回，减少不必要的计算。

6. 常见错误与调试技巧

6.1 空指针问题

新手常犯的错误是忘记检查空指针：

c复制// 错误示例
bool dfs(struct TreeNode* root, int target) {
    if (root->val != target) return false; // 可能访问空指针
    // ...
}

正确做法：总是先检查指针是否为NULL。

6.2 目标值选择

另一个常见错误是使用固定值而非根节点值作为目标：

c复制// 错误示例
bool isUnivalTree(struct TreeNode* root) {
    return dfs(root, 0); // 错误：使用了固定值0
}

正确做法：应该使用root->val作为初始目标值。

6.3 递归终止条件

不正确的终止条件会导致无限递归或错误结果：

c复制// 错误示例
bool dfs(struct TreeNode* root, int target) {
    if (!root->left && !root->right) return true; // 仅叶子节点返回true
    // ...
}

正确做法：应该在遇到NULL节点时返回true，遇到值不匹配时返回false。

6.4 调试技巧

1. 打印遍历路径：在递归函数中添加printf，输出当前节点值
2. 可视化小树：手工绘制简单树结构，模拟程序执行
3. 使用调试器：设置断点，观察递归调用栈
4. 单元测试：为各种边界情况编写测试用例

7. 实际应用与扩展

7.1 实际应用场景

单值二叉树检查可以应用于：

• 配置文件验证（确保所有配置项使用相同模式）
• 数据一致性检查（如分布式系统中的数据副本）
• 图像处理中的区域一致性检测

7.2 问题变种

1. 统计单值子树数量：计算树中有多少子树是单值的
2. 最大单值子树：找出最大的单值子树（节点数最多）
3. 近似单值树：允许最多k个节点值不同
4. 多值检查：检查所有节点值是否属于某个特定集合

7.3 性能优化进阶

对于大规模树，可以考虑：

1. 并行遍历：使用多线程同时检查不同子树
2. 迭代深化DFS：结合深度限制和迭代加深
3. 记忆化技术：缓存子树检查结果（如果树会多次检查）

我在实际编码中发现，递归解法在大多数情况下已经足够高效。对于特别深的树（深度>1000），迭代解法更为安全。在LeetCode的测试用例中，递归解法通常运行时间在0-4ms之间，内存消耗在6-7MB左右。