代码随想录训练营第二十一天——二叉搜索树的最小绝对差，二叉搜索树中的众数，二叉树的最小公共祖先

荒野饮冰室

已于 2023-12-24 23:08:05 修改

阅读量421

点赞数 9

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

于 2023-12-21 23:38:19 首次发布

本文链接：https://blog.csdn.net/qq_39088868/article/details/135142183

版权

leetcode训练——代码随想录专栏收录该内容

57 篇文章 0 订阅

订阅专栏

二叉搜索树的最小绝对差

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

递归法：

使用中序遍历：
方法一：二叉树转化为有序数组

class Solution {
private:
vector<int> vec;
void traversal(TreeNode* root) {
    if (root == NULL) return;
    traversal(root->left);
    vec.push_back(root->val); // 将二叉搜索树转换为有序数组
    traversal(root->right);
}
public:
    int getMinimumDifference(TreeNode* root) {
        vec.clear();
        traversal(root);
        if (vec.size() < 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 {
private:
int result = INT_MAX;
TreeNode* pre = NULL;
void traversal(TreeNode* cur) {
    if (cur == NULL) return;
    traversal(cur->left);   // 左
    if (pre != NULL){       // 中
        result = min(result, cur->val - pre->val);
    }
    pre = cur; // 记录前一个节点
    traversal(cur->right);  // 右
}
public:
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

迭代法：

依然使用中序遍历：

class Solution {
public:
    int getMinimumDifference(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        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, cur->val - pre->val);
                }
                pre = cur;
                cur = cur->right;               // 右
            }
        }
        return result;
    }
};

二叉搜索树中的众数

题目链接：二叉搜索树中的众数
注意：本题的题目提到的是含重复值的二叉搜索树。

递归法：

方法一：按照普通二叉树解题： 遍历整颗树，用map统计频率，把频率排个序，最后取前面高频的元素的集合
下面代码使用前序遍历：注意C++中map可以只对key排序，不能对value排序

class Solution {
private:
    void searchBST(TreeNode* cur, unordered_map<int, int>& map) { // 前序遍历
        if (cur == NULL) 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; // 按照频率从大到小排序
    }
public:
    vector<int> findMode(TreeNode* root) {
        unordered_map<int, int> map; // key:元素，value:出现频率
        vector<int> result;
        if (root == NULL) return result;
        searchBST(root, map);
        vector<pair<int, int>> vec(map.begin(), map.end());  //map转化为vector
        sort(vec.begin(), vec.end(), cmp); // 给频率排个序
        result.push_back(vec[0].first);
        for (int i = 1; i < vec.size(); i++) {
            // 取最高的放到result数组中
            if (vec[i].second == vec[0].second) result.push_back(vec[i].first);
            else break;
        }
        return result;
    }
};

方法二：按照二叉搜索树的有序性解题：
二叉搜索树就要使用中序遍历了，只可能出现相邻的元素相等，其他元素按照从小到大排序。

class Solution {
private:
    int maxCount = 0; // 最大频率
    int count = 0; // 统计频率
    TreeNode* pre = NULL;
    vector<int> result;
    void searchBST(TreeNode* cur) {
        if (cur == NULL) return ;

        searchBST(cur->left);       // 左
                                    //中
        if (pre == NULL) //第一个节点
            count = 1;
        else if (pre->val == cur->val) // 与前一个节点数值相同
            count++;
        else  // 与前一个节点数值不同
            count = 1;
        pre = cur; // 更新上一个节点
        if (count == maxCount)   // 如果和最大值相同，放进result中
        { 
            result.push_back(cur->val); 
        }
        if (count > maxCount)  //如果计数大于最大值频率
         {
            maxCount = count;   //更新最大频率
            result.clear();  //很关键的一步，出现了更大频率的值，此时需要清空result，之前result里的元素都失效了
            result.push_back(cur->val);
        }
        searchBST(cur->right);      // 右
        return ;
    }
public:
    vector<int> findMode(TreeNode* root) {
        count = 0;
        maxCount = 0;
        pre = NULL; // 记录前一个节点
        result.clear();
        searchBST(root);
        return result;
    }
};

迭代法：

直接使用栈模拟中序遍历：

class Solution {
public:
    vector<int> findMode(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        int maxCount = 0; // 最大频率
        int count = 0; // 统计频率
        vector<int> result;
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) { // 指针来访问节点，访问到最底层
                st.push(cur); // 将访问的节点放进栈
                cur = cur->left;                // 左
            } else {
                cur = st.top();
                st.pop();                       // 中
                if (pre == NULL) { // 第一个节点
                    count = 1;
                } else if (pre->val == cur->val) { // 与前一个节点数值相同
                    count++;
                } else { // 与前一个节点数值不同
                    count = 1;
                }
                if (count == maxCount) { // 如果和最大值相同，放进result中
                    result.push_back(cur->val);
                }

                if (count > maxCount) { // 如果计数大于最大值频率
                    maxCount = count;   // 更新最大频率
                    result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了
                    result.push_back(cur->val);
                }
                pre = cur;
                cur = cur->right;               // 右
            }
        }
        return result;
    }
};

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

题目链接：二叉树的最近公共祖先
最近公共祖先：对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）
二叉树可以通过回溯从底向上查找。后序遍历（左右中）就是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。
本题递归遍历，需要遍历整棵树，通过回溯遍历整棵树，将结果返回给头节点。
递归函数有返回值，如何区分要搜索一条边，还是要搜索整棵树：
搜索一条边的写法：

if (递归函数(root->left)) return ;

if (递归函数(root->right)) return ;

搜索整棵树的写法：

left = 递归函数(root->left);  // 左
right = 递归函数(root->right); // 右
left与right的逻辑处理;         // 中

在递归函数有返回值的情况下：如果要搜索一条边，递归函数返回值不为空的时候，立刻返回，如果搜索整个树，直接用一个变量left、right接住返回值，这个left、right后序还有逻辑处理的需要，也就是后序遍历中处理中间节点的逻辑（也是回溯）。

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