深入探索二叉树的堂兄弟节点(Leetcode)

引言

        二叉树作为计算机科学中的基石，它的问题多种多样，有时候也会出现一些非常有趣的题目，如LeetCode上的两道关于二叉树的堂兄弟节点问题。这两个问题虽然不多，但却提供了深入理解二叉树结构和遍历算法的良机。作为一个编程的初学者，我想通过这次探索，与大家一同学习和进步。

特别鸣谢

        我要特别感谢灵茶山艾府大佬，他在昨天的每日一题的题解中为提供了宝贵的思路和启示。灵神的题解链接：灵茶山艾府的题解。

解题思路回顾与创新

993. 二叉树的堂兄弟节点

        我采用了层序遍历的方法来判断二叉树中的两个节点是否为堂兄弟节点，即它们是否在同一层级但有不同的父节点。灵神2641题的思路。

2641. 二叉树的堂兄弟节点 II

        对于这个问题，灵茶山艾府大佬提供了一个基于BFS算法进行两次扫描的解法。如果我的解法让你感到困惑，强烈推荐查看灵神的题解以获得更深入的理解。

        在我的尝试中，我采用了一种不同的方法，通过深度优先搜索（DFS）来处理这个问题。我首先遍历整棵树，累计每个节点的值，然后再次遍历树，根据累计的值更新每个节点的值。

代码实现与解析

（2641. 二叉树的堂兄弟节点 II）

class Solution {
public:
    int ans[100010] = {0}; // 存储每层节点值的累加和
    int s = 0; // 当前的深度
    int tmpbro = 0; // 用于临时存储兄弟节点的值，以便进行值的更新

    // 主函数，进行值的替换
    TreeNode* replaceValueInTree(TreeNode* root) {
        res(root); // 第一次DFS，累计每个节点的值
        ress(root); // 第二次DFS，根据累计值更新节点
        return root;
    }

    // 第一次DFS遍历：累计每层节点的值
    void res(TreeNode* root) {
        if(root) ans[s] += root->val;
        if(root->left) {
            s++;
            res(root->left);
            s--;
        }
        if(root->right) {
            s++;
            res(root->right);
            s--;
        }
    }

    // 第二次DFS遍历：更新节点值
    void ress(TreeNode* root) {
        if(!root) return;
        root->val = ans[s] - root->val - tmpbro; // 更新节点值
        int tmpbro2 = 0;
        if(root->left) {
            s++;
            tmpbro = root->right ? root->right->val : 0; // 更新临时兄弟节点的值
            tmpbro2 = root->left->val; // 保存左子节点的值
            ress(root->left);
            s--;
        }
        if(root->right) {
            s++;
            tmpbro = root->left ? tmpbro2 : 0; // 使用左子节点的值更新临时兄弟节点的值
            ress(root->right);
            s--;
        }
    }
};

(993. 二叉树的堂兄弟节点)

class Solution {
public:
    bool isCousins(TreeNode* root, int x, int y) {
        // 使用队列q来进行层序遍历，初始时包含根节点
        vector<TreeNode*> q = {root};
        // 当队列不为空时，继续遍历
        while (!q.empty()) {
            vector<TreeNode*> nxt; // 用于存储下一层的节点
            bool foundX = false, foundY = false; // 分别标记是否找到x和y
            // 遍历当前层的每个节点
            for (auto node : q) {
                if (node) {
                    // 将当前节点的子节点添加到下一层节点列表中
                    nxt.push_back(node->left);
                    nxt.push_back(node->right);
                }
            }
            int n = nxt.size(); // 下一层节点的数量
            int xIndex = -1, yIndex = -1; // x和y在下一层节点列表中的索引，初始为-1表示未找到
            // 遍历下一层的所有节点，查找x和y
            for (int i = 0; i < n; i++) {
                if (nxt[i]) {
                    if (nxt[i]->val == x) xIndex = i; // 找到x，记录索引
                    if (nxt[i]->val == y) yIndex = i; // 找到y，记录索引
                }
            }
            // 如果x和y都被找到
            if (xIndex != -1 && yIndex != -1) {
                // 检查它们是否有不同的父节点：通过比较它们索引除以2的结果
                // 如果结果不同，则它们不是同一个父节点的子节点，因此是堂兄弟节点
                if ((xIndex / 2 != yIndex / 2)) return true;
            }
            // 如果在这一层只找到x或y，则它们不在同一层，不可能是堂兄弟节点
            if (xIndex != -1 || yIndex != -1) return false;
            // 准备下一次迭代，使用下一层的节点继续遍历
            q = move(nxt);
        }
        // 如果遍历完整棵树后都没有同时找到x和y，或者它们不满足堂兄弟节点的条件，则返回false
        return false;
    }
};

时间复杂度分析

• 993题：时间复杂度O(N)，空间复杂度O(N)。
• 2641题：时间复杂度O(N)，空间复杂度取决于递归的深度，最坏情况下为O(N)。