代码随想录算法训练营第21天| Leetcode 530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先

最新推荐文章于 2024-05-21 23:16:53 发布

Camellia__Wang

最新推荐文章于 2024-05-21 23:16:53 发布

阅读量918

点赞数 21

分类专栏：代码随想录文章标签：算法 leetcode 数据结构 c++

本文链接：https://blog.csdn.net/Camellia__Wang/article/details/135959871

版权

代码随想录专栏收录该内容

53 篇文章 0 订阅

订阅专栏

目录

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

Leetcode 501.二叉搜索树中的众数

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

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

题目链接：Leetcode 530.二叉搜索树的最小绝对差

题目描述：给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。

思路：由于是二叉搜索树，而二叉搜索树的中序遍历是一个有序的数组，因此很容易想到的第一种方法：先将二叉搜索树转化成有序数组，再遍历数组统计最小差值。

代码如下：（利用二叉搜索树中序遍历性质）

class Solution {
public:
    vector<int> vec;
    void traversal(TreeNode* root) {
        if (root == nullptr)
            return;
        traversal(root->left);
        vec.push_back(root->val);
        traversal(root->right);
    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        if (vec.size() < 2)//由于题目保证数据大于等于2，因此这段代码可以不加
            return 0;
        int result = INT_MAX;
        for (int i = 1; i < vec.size(); i++) {
            result = min(result, vec[i] - vec[i - 1]);
        }
        return result;
    }
};

我们发现这种方法需要遍历两次，一次是二叉搜索树，一次是数组，那有没有一种方法只需遍历一次呢？这时候我们想到了利用双指针。怎么想到的呢？因为双指针的最大作用就是利用两个指针，把两次循环干的事情优化到一次循环。

代码如下：（利用双指针优化）

class Solution {
public:
    int result = INT_MAX;
    TreeNode* pre = nullptr;
    void traversal(TreeNode* root) {
        if (root == nullptr)
            return;
        traversal(root->left);//左
        if (pre != nullptr) {
            //根据二叉搜索树的性质，这里可以不用加绝对值
            result = min(result,root->val -pre->val); 
        }
        pre = root; //记录前一个节点
        traversal(root->right);//右
    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

上面代码还可以不用递归实现：

class Solution {
public:
    int getMinimumDifference(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode *cur = root, *pre = nullptr;
        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;
    }
};

Leetcode 501.二叉搜索树中的众数

题目链接：Leetcode 501.二叉搜索树中的众数

题目描述：给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。

假定 BST 有如下定义：

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

思路：既然是找所有众数，最先想到的还是把整棵树都遍历了，用map统计频率，把频率排个序，最后取前面高频的元素的集合。

代码如下：（二叉树通用的解法）

class Solution {
public:
    void searchBST(TreeNode* cur, unordered_map<int, int>& map) { //统计元素频率
        if (cur == nullptr)
            return;
        map[cur->val]++;
        searchBST(cur->left, map);
        searchBST(cur->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) {
        unordered_map<int, int> map;
        vector<int> result;
        if (root == nullptr)
            return result;
        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;
    }
};

既然是二叉搜索树，我们可以利用其中序遍历数组是有序的这个性质来做，结合上道题介绍的双指针法，可以写出如下代码。不过这里有个小技巧，我们寻找众数的逻辑代码可以用这种思路：如果频率cnt等于最大频率max，则把这个元素加入到结果集result中；如果频率cnt大于最大频率max，不仅要更新max，还要将原来的结果集result清空之后再把这个元素加入到结果集result。

代码如下：（利用双指针优化）

class Solution {
public:
    int max = 0, cnt = 0;
    TreeNode* pre = nullptr;
    vector<int> result;
    void searchBST(TreeNode* cur) {
        if (cur == nullptr)
            return;
        searchBST(cur->left); //左
        //中
        if (pre == nullptr)
            cnt = 1; //第一个节点
        else if (pre->val == cur->val)
            cnt++; //与前一个节点相同
        else
            cnt = 1; //否则重新计数
        pre = cur;
        if (cnt == max) { //和最大值相同则加入到结果数组内
            result.push_back(cur->val);
        }
        if (cnt >max) { //如果存在频率更大的，先清空之前的数组，再将元素加入到结果数组内
            max = cnt;
            result.clear();
            result.push_back(cur->val);
        }
        searchBST(cur->right); //右
    }
    vector<int> findMode(TreeNode* root) {
        //先初始化
        cnt = 0, max = 0;
        pre = nullptr;
        result.clear();
        //再搜索
        searchBST(root);
        return result;
    }
};

（迭代法）

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

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

题目链接：Leetcode 236. 二叉树的最近公共祖先

题目描述：给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

思路：由于需要寻找最近公共祖先，因此从下向上的遍历方式非常合适，也就是后序遍历的回溯过程。找到了合适的遍历方式，接下来就该思考该如何实现寻找最近祖先？分析题干信息后我们可以知道本题有以下三种情况：（假设root为p和q的公共祖先）

（1）p和q在root的子树中，且分别位于root的异侧（即分别在左、右子树中）

（2）p=root，且q在root的子树中

（3）q=root，且p在root的子树中

这道题理解起来比较抽象，可以先看看这篇文章，理解思路之后再根据这个图片，能更好的理解代码：

注：上述图片来源于leetcode题解区

代码如下：

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == p || root == q || root == nullptr)
            return root;
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);
        if (left != nullptr && right != nullptr)
            return root;
        if (left != nullptr && right == nullptr)
            return left;
        else if (left == nullptr && right != nullptr)
            return right;
        else
            return nullptr; //(left==nullptr&&right==nullptr)
    }
};

总结：今天最后一道题思维难度有点大，理解了很长时间才把思路和代码结合起来。

最后，如果文章有错误，请在评论区或私信指出，让我们共同进步！

Camellia__Wang

关注

21
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第21天| Leetcode 530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先

今天最后一道题思维难度有点大，理解了很长时间才把思路和代码结合起来。最后，如果文章有错误，请在评论区或私信指出，让我们共同进步！
复制链接

扫一扫