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

原创已于 2025-09-08 01:48:59 修改 · 397 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #数据结构

于 2025-09-08 01:31:08 首次发布

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

题目链接：Leetcode
文章讲解：代码随想录
视频讲解：bilibili

解题思路

有了前面验证二叉搜索树的基础，这题做起来相对比较容易。由于二叉搜索树的特殊性质最小差值会出现在节点与左子树的最右节点和节点与右子树的最左节点之间，而我们验证二叉搜索树的过程有遍历到这两个特殊位置，因此只需增加最小差值记录就可通过测试。

解法1（迭代）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int getMinimumDifference(TreeNode* root) {
        if(root==NULL)  return 0;
        if(root->left==NULL && root->right==NULL)   return root->val;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        stack<TreeNode*> st;
        int result = INT_MAX;
        while(cur!=NULL || !st.empty()){
            if(cur!=NULL){
                st.push(cur);
                cur = cur->left;
            } else{
                cur = st.top();
                st.pop();
                if(pre!=NULL)
                    result = min(result, abs(cur->val - pre->val));
                pre = cur;
                cur = cur->right;
            }
        }
        return result;
    }
};

时间复杂度： $O (n)$
空间复杂度： $O (1)$

解法2（递归）

此处的索引更新逻辑较为简单，可以进行代码的简化。

class Solution {
public:
    int result = INT_MAX;
    TreeNode* pre = NULL;
    void traversal(TreeNode* cur){
        if(cur==NULL)  return ;
        traversal(cur->left);
        if(pre!=NULL)
            result = min(result, abs(cur->val - pre->val));
        pre = cur;
        traversal(cur->right);
    }
    int getMinimumDifference(TreeNode* root) {
        if(root==NULL)  return 0;
        if(root->left==NULL && root->right==NULL)   return root->val;
        traversal(root);
        return result;
    }
};

时间复杂度： $O (n)$
空间复杂度： $O (1)$

解法3

还有更暴力的解法（）

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& nums){
        if(cur==NULL)   return ;
        traversal(cur->left, nums);
        nums.push_back(cur->val);
        traversal(cur->right, nums);
        return ;
    }
    int getMinimumDifference(TreeNode* root) {
        if(root==NULL)  return 0;
        if(root->left==NULL && root->right==NULL)   return root->val;
        vector<int> nums;
        traversal(root, nums);
        int result = nums[1] - nums[0];
        int length = nums.size();
        for(int i=2; i<length; i++)
            result = min(result, nums[i]-nums[i-1]);
        return result;
    }
};

时间复杂度： $O (n)$
空间复杂度： $O (n)$

501.二叉搜索树中的众数

题目链接：Leetcode
文章讲解：代码随想录
视频讲解：bilibili

解题思路

初始的想法是按照一般的二叉树进行遍历，使用map进行频率的统计，再转换成vector进行频率排序，再将结果输出。

解法1

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void traversal(TreeNode* node, unordered_map<int, int>& map){
        if(node==NULL)  return ;
        map[node->val]++;
        traversal(node->left, map);
        traversal(node->right, map);
        return ;
    }
    bool static cmp(const pair<int, int>& a, const pair<int, int>& b){
        return a.second > b.second;
    }
    vector<int> findMode(TreeNode* root) {
        vector<int> result;
        if(root==NULL)  return result;
        unordered_map<int, int> map;
        traversal(root, map);
        vector<pair<int, int>> vec(map.begin(), map.end());
        sort(vec.begin(), vec.end(), cmp);
        result.push_back(vec[0].first);
        int length = vec.size();
        for(int i=1; i<length; i++)
            if(vec[i].second==vec[0].second)
                result.push_back(vec[i].first);
        return result;
    }
};

时间复杂度： $O (n)$
空间复杂度： $O (n)$

解法2（递归）

采用验证二叉搜索树的解法去处理，中序遍历对于BST本是顺序遍历数值，再存储前一个节点用于比较是否为同一数值以计算频率，一但不同则频率更新为1。这里比较巧妙的是对于结果数组的处理，一旦最大频率maxFreq更新就清空数组重新加值。

class Solution {
public:
    vector<int> result;
    TreeNode* pre = NULL;
    int maxFreq = 0;
    int cnt = 1;
    void searchBST(TreeNode* cur){
        if(cur==NULL)   return ;

        searchBST(cur->left);
        
        if(pre!=NULL && cur->val==pre->val)
            cnt++;
        else
            cnt = 1;
        if(cnt==maxFreq)
            result.push_back(cur->val);
        else if(cnt > maxFreq){
            result.clear();
            maxFreq = cnt;
            result.push_back(cur->val);
        }
        pre = cur;

        searchBST(cur->right);

        return ;
    }
    vector<int> findMode(TreeNode* root) {
        searchBST(root);
        return result;
    }
};

时间复杂度： $O (l o g n)$
空间复杂度： $O (1)$

解法3（迭代法）

类似递归的思路，只是转变成了迭代形式。

class Solution {
public:
    vector<int> findMode(TreeNode* root) {
        vector<int> result;
        if(root==NULL)  return result;
        TreeNode* pre = NULL;
        TreeNode* cur = root;
        int maxFreq = 0;
        int cnt = 1;
        stack<TreeNode*> st;
        while(cur!=NULL || !st.empty()){
            if(cur!=NULL){
                st.push(cur);
                cur = cur->left;
            } else{
                cur = st.top();
                st.pop();
                if(pre!=NULL && cur->val==pre->val)
                    cnt++;
                else
                    cnt = 1;
                if(cnt==maxFreq)
                    result.push_back(cur->val);
                else if(cnt > maxFreq){
                    result.clear();
                    maxFreq = cnt;
                    result.push_back(cur->val);
                }
                pre = cur;
                cur = cur->right;
            }
        }
        return result;
    }
};

时间复杂度： $O (n)$
空间复杂度： $O (n)$

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

题目链接：Leetcode
文章讲解：代码随想录
视频讲解：bilibili

解题思路

这道理理解起来有些难度，从自底向上的角度进行考虑，利用后序遍历，如果找到了目标节点则逐层返回，并在left和right均不为NULL时返回当前节点，即当前节点为公共祖先节点，且由于是自底向上因此是最近的公共祖先。这一需要回溯的操作不好用迭代实现，这里没有给出。

解法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root==NULL)  return NULL;
        if(root==q || root==p)  return root;
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right= lowestCommonAncestor(root->right, p, q);
        if(left!=NULL && right!=NULL)   return root;    // 找到了公共祖先节点
        else if(left==NULL && right!=NULL)   return right;
        else if(left!=NULL && right==NULL)   return left;
        else    return NULL;
    }
};