代码随想录 10.12 || 二叉树 LeetCode 530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先

530.二叉搜索树的最小绝对差

        给你一个二叉搜索树的根节点 root，返回树中任意不同节点值之间的最小值。差值是一个正数，其数值等于两值之差的绝对值。在二叉搜索树中，根节点左子树的值均小于根节点，根节点右子树的值均大于根节点，节点间的最小差值有两种情况：其一，根节点 - 左节点；其二，右节点 - 根节点。因此，我们利用双指针法，标记上一个指针和当前指针，以中序（左中右）遍历二叉树，从小到大依次遍历左节点、根节点和右节点，计算它们之间的差值。

class Solution {
    TreeNode* pre = nullptr;
    int result = INT_MAX;

    void traversal(TreeNode* cur) {
        if (cur == nullptr) return ;

        traversal(cur->left);
        if (pre != nullptr) {
            result = min(result, cur->val - pre -> val);
        }
        pre = cur;
        traversal(cur->right);

        return ;
    }
    
public:
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

        上述为递归法 + 双指针的代码实现，定义 pre 指针，用于保存上一个指针，cur 指针，用于标记当前指针，在递归的过程中记录节点间的差值，保存最小值。除递归法之外，还可以使用栈 + 双指针解决该问题。

class Solution {
public:
    int getMinimumDifference(TreeNode* root) {
        stack<TreeNode*> st;

        TreeNode* pre = nullptr;
        TreeNode* cur = root;
        int result = INT_MAX;

        while (cur != nullptr || !st.empty()) {
            if (cur != nullptr) {
                st.push(cur);
                cur = cur->left;
            } else {
                cur = st.top();
                st.pop();
                if (pre != nullptr) {
                    result = min(result, cur->val - pre->val);
                }
                pre = cur;
                cur = cur->right;
            }
        }
        return result;
    }
};

        另一种解题思路，二叉搜索树是有序的，利用中序遍历，将每个节点的值存入数组，会得到一个升序数组，这样计算相邻两个元素之间的值即可。

class Solution {
    vector<int> vec;

    void traversal(TreeNode* node) {
        if (node == nullptr) return ;
        traversal(node->left);
        vec.push_back(node->val);
        traversal(node->right);
        return ;
    }
    
public:
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        int result = INT_MAX;
        for (int i = 0; i < vec.size() - 1; i++) {
            int gap = vec[i + 1] - vec[i];
            if (gap < result) result = gap;
        }
        return result;
    }
};

501.二叉搜索树中的众数

        给你一个含重复值的二叉搜索树（BST）的根节点 root，找出并返回 BST 中的所有众数（即出现频率最高的元素）。如果树中有不止一个众数，可以按任意顺序返回。

        假定 BST 满足如下定义：

•         节点左子树中所含节点的值小于等于当前节点的值；
•         节点右子树中所含节点的值大于等于当前节点的值；
•         左子树和右子树都是二叉搜索树。

        统计一棵二叉树中，数字出现的频率，第一想法就是哈希表。利用 unordered_map 记录二叉树中数值出现的频率，然后对得到的数组排序，取出现频率最高的数字返回即可。

class Solution {
private:
    void searchBST(TreeNode* node, unordered_map<int, int> &map) {
        if (node == nullptr) return ;

        map[node->val]++;
        searchBST(node->left, map);
        searchBST(node->right, map);

        return ;
    }

    bool static cmp(const pair<int, int> &a, const pair<int, int> &b) {
        return a.second > b.second;
    }

public:
    vector<int> findMode(TreeNode* root) {
        vector<int> result;
        if (root == nullptr) return result;

        unordered_map<int, int> map;
        searchBST(root, map);

        vector<pair<int, int>> vec(map.begin(), map.end());
        sort(vec.begin(), vec.end(), cmp);

        result.push_back(vec[0].first);

        for (int i = 1; i < vec.size(); i++) {
            if (vec[i].second == vec[0].second) result.push_back(vec[i].first);
            else break;
        }
        return result;
    }
};

        思路清晰，无需多言，上述代码是针对二叉树的通解。但是，题中给出的是二叉搜索树，我们是否可以利用二叉搜索树的性质，解决这个问题？因为二叉搜索树是有序的，所以相同数字一定出现在一块儿，我们利用双指针记录当前节点和前一个节点的信息，统计数字的出现频率，将出现最多的数字加入进结果集，然后返回即可。

class Solution {
private:
    vector<int> result;
    TreeNode* pre = nullptr;
    int count = 0, maxCount = 0;

    void traversal(TreeNode* cur) {
        if (cur == nullptr) return ;

        traversal(cur->left);

        if (pre == nullptr) {
            count = 1;
        } else if (pre->val == cur->val) {
            count++;
        } else {
            count = 1;
        }

        pre = cur;

        if (count > maxCount) {
            result.clear();
            result.push_back(cur->val);
            maxCount = count;
        } else if (count == maxCount) {
            result.push_back(cur->val);
        }

        traversal(cur->right);

        return ;
    }

public:
    vector<int> findMode(TreeNode* root) {
        traversal(root);
        return result;
    }
};

        这里需要注意的是，根据题意，给定的二叉树中可能存在多个众数，我们需要返回的是一个众数的集合，而并非单个数字。因此当 count 和 maxCount 相等时，向结果集中加入当前节点的值，如果 count 大于 maxCount，说明有一个出现频率更高的数字，此时我们把结果集清空，将新的数字加入即可。

236.二叉树的最近公共祖先

        给定一个二叉树，找到该树中两个指定节点的最近公共祖先。分析题目，首先需要遍历二叉树找到符合条件的节点，然后向上找它们的公共祖先。从底向上，后序遍历方式，左右中。我们确定使用递归方法，下一步需要确定递归的参数、返回值类型、终止条件和递归逻辑。递归的参数，二叉树的根节点和目标节点 q 和 q；递归的返回值类型，公共祖先节点；递归的终止条件，当前节点为 nullptr 时 或 找到 p 或 找到 q 时。

        递归逻辑，定义 n1de 和 n2de 用于保存左子树和右子树的信息，如果 n1de 和 n2de 同时不为 nullptr，说明符合条件的两个目标节点在同一层，这时最近的公共祖先即为当前节点，如果 n1de 或 n2de 任意一个节点为 nullptr，说明不为空的那个节点即为公共祖先节点；如果都为空，则说明没找到，此时之间返回 nullptr 即可。

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == p || root == q || root == nullptr) return root;

        TreeNode* n1de = lowestCommonAncestor(root->left, p, q);
        TreeNode* n2de = lowestCommonAncestor(root->right, p, q);

        if (n1de == nullptr && n2de == nullptr) return nullptr;
        else if (n1de != nullptr && n2de != nullptr) return root;
        else if (n1de != nullptr && n2de == nullptr) return n1de;
        else if (n1de == nullptr && n2de != nullptr) return n2de;
        else return nullptr;
    }
};