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

二叉搜索树的最小绝对值差

递归法        

        首先需考虑这是一个二叉搜索树，在中序遍历后的结果为从小到大的一个序列，寻找二叉搜索树的最小绝对值差，只需比较一个节点与之后的差值即可。在遍历的过程中，我们需要一个节点保存前节点，之后计算前节点和当前节点的差值，将所有节点都遍历一遍后即可得到二叉搜索树的最小绝对值差。

class Solution {
public:
    // 用于存储最小差值的变量，初始值设为最大整数，以便后续比较
    int minDiff = INT_MAX;
    // 用于记录前一个节点的指针，初始值为nullptr
    TreeNode *pre = nullptr;

    // 中序遍历二叉树的递归函数
    void inorder_traversal(TreeNode* root, TreeNode*& pre, int& minDiff) {
        // 如果当前节点为空，则返回
        if(root == nullptr){
            return;
        }
        // 首先递归遍历左子树
        inorder_traversal(root->left, pre, minDiff);
        // 如果前一个节点不为空，则计算当前节点和前一个节点的差值，并更新最小差值
        if(pre != nullptr){
            minDiff = std::min(minDiff, root->val - pre->val);
        }
        // 将当前节点设置为前一个节点，以便下一次比较
        pre = root;
        // 最后递归遍历右子树
        inorder_traversal(root->right, pre, minDiff);
    }

    // 主函数，调用中序遍历函数并返回最小差值
    int getMinimumDifference(TreeNode* root) {
        TreeNode* pre = nullptr; // 前一个节点的指针
        int minDiff = INT_MAX;  // 最小差值
        // 调用中序遍历函数
        inorder_traversal(root, pre, minDiff);
        // 返回最小差值
        return minDiff;
    }
};

算法的时间复杂度和空间复杂度为O(n)。

二叉搜索树中的众数

递归+哈希表

        由于要遍历所有的节点，最简单的方法，创建一个哈希表，将所有的节点出现次数加入哈希表，最后将哈希表中出现次数最多的数全部返回。

class Solution {
public:
    //前序遍历
    void preorder_traversal(TreeNode* root, unordered_map<int, int>& umap) {
        if (root == nullptr) {
            return;
        }
        umap[root->val] += 1; // 统计当前节点值的出现次数
        preorder_traversal(root->left, umap); 
        preorder_traversal(root->right, umap);
    }

    vector<int> findMode(TreeNode* root) {
        int max_value = 0; // 用于存储最大出现次数
        vector<int> ans; // 用于存储众数
        unordered_map<int, int> umap; // 用于存储每个值及其出现次数
        preorder_traversal(root, umap); // 调用前序遍历函数

        // 遍历哈希表，找到出现次数最多的值
        for (const auto& pair : umap) {
            if (pair.second > max_value) {
                max_value = pair.second; // 更新最大出现次数
                ans.clear(); // 清空之前的众数
                ans.push_back(pair.first); // 添加新的众数
            } else if (pair.second == max_value) {
                ans.push_back(pair.first); // 如果有多个出现次数相同的值，都添加到众数列表中
            }
        }
        return ans; // 返回众数列表
    }
};

分析代码的时间复杂度和空间复杂度。

在时间复杂度上，遍历树的每一节点，时间复杂度为O(n)，此外，在寻找众数时，需要遍历哈希表，同样需要O(n)，综上，时间复杂度为O(n)。

空间复杂度，哈希表存储了树中所有不同值的出现次数，最差情况为O(n)，此外，递归调用栈的空间复杂度为O(H),H为树的高度，最差情况下为O(n)。因此最终时间复杂度和空间复杂度均为O(n)。

双指针

二叉搜索树，一定得是中序遍历，中序遍历结果的序列才是有序的。

定义一个全局变量max_count,一个count，在函数体创建一个ans数组，在中序遍历时，参考上题，设定一个pre指针，指向当前的前一个位置，当现在位置的val与pre->val相同时，count++，遍历第一次的count更新max_count，并将值加入ans数组，之后的遍历结果若count大于max_count，则更新max_count，并将ans数组清空，并将val值存入数组，若count等于max_count，则在ans数组中加入val。遍历一次之后即能得到所有众数。

class Solution {
public:
    int max_count = 0;
    int count = 1;
    TreeNode*pre = nullptr;
    void inorder_traversal(TreeNode* root,vector<int>&ans){

        if(root == nullptr){
            return;
        }
        inorder_traversal(root->left,ans);
        if(pre != nullptr){
                if(root->val == pre->val){
                    count++;
                }
                else{
                    count = 1;
            }
        }
        if(count > max_count){
            max_count = count;
            ans.clear();
            ans.push_back(root->val);
        }
        else if(count == max_count){
            ans.push_back(root->val);
        }
        pre = root;
        inorder_traversal(root->right,ans);
    }
    vector<int> findMode(TreeNode* root) {
        vector<int>ans;
        inorder_traversal(root,ans);
        return ans;

    }
};

算法的时间复杂度和空间复杂度均为O(n)。

二叉树的最近公共祖先

递归法

由于是要寻找最近的公共祖先，我们得考虑从叶子节点向上递归，因此考虑后序遍历的方式，左右中，从底部向上找。

具体参考代码随想录讲解视频。

自底向上查找，有点难度！ | LeetCode：236. 二叉树的最近公共祖先_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1jd4y1B7E2/?spm_id_from=333.788&vd_source=fc4a6e70e3a87b7ea67c2024e326e7c5

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        // 如果当前节点为空，或者等于p或q，直接返回当前节点
        if (root == nullptr || root == p || root == q) {
            return root;
        }

        // 在左右子树中递归寻找p和q
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);

        // 如果左右子树的返回值都不为空，说明当前节点就是最近公共祖先
        if (left != nullptr && right != nullptr) {
            return root;
        }

        // 否则，返回非空的子树返回值
        return left != nullptr ? left : right;
    }
};

算法的时间复杂度和空间复杂度均为O(n)