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

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

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

通过遍历二叉树将所有节点的值放入数组中，然后对数组进行排序，则相邻数组的最小绝对差，就是二叉搜索树的最小绝对差。

class Solution {
    private:
    vector<int> nums;
public:
    void preorder(TreeNode* root) {
        if(root == NULL) return;
        preorder(root -> left);
        nums.push_back(root -> val);
        preorder(root -> right);
    }
    int getMinimumDifference(TreeNode* root) {
        preorder(root);//利用中序遍历将其放进数组，则数组应是递增的
        int min = 999999;
        for(int i = 1; i < nums.size(); i++) {//最小差值只需比较相邻数组值
            min = min > abs(nums[i] - nums[ i - 1]) ? abs(nums[i] - nums[ i - 1]) : min;
        }
        return min;

    }
};

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

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

利用哈希表记录二叉树中各节点值的出现频率，然后根据频率的大小进行排序（降序），返回出现频率最高的节点值数组。

来看代码：

class Solution {
    private:
    unordered_map<int,int>map;//利用哈希表map记录各节点值出现的次数
public:
    void orderd(TreeNode* Node) {//遍历各节点创建哈希表
        if(Node == NULL) {
            return;
        }
        orderd(Node -> left);
        map[Node->val]++;
       // cout<<map[Node->val]<< " ";
        orderd(Node -> right);
        return;
    }
    bool static compare(const pair<int,int>&a, const pair<int,int>&b) {//比较规则
        return a.second > b.second;
    }
    vector<int> findMode(TreeNode* root) {
        orderd(root);
        vector<pair<int,int>>res(map.begin(), map.end());//将哈希表中的数据放入数组中
        sort(res.begin(), res.end(), compare);//按照频率排序（降序）
        int max = res[0].second;
        vector<int>result;
        //cout<<res.size();
        for(int i = 0; i < res.size(); i++) {
           // cout<<max;
            if(max == res[i].second) result.push_back(res[i].first);
        }
        return result;

    }
};

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

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

难的题不必要难为自己，该看题解时就看题解😂，然后根据自己的理解敲一遍。

这道题运用递归和回溯，还有后序遍历，如果遇到空节点或pq 就返回。

然后递归遍历左子树和右子树，记录左右子树返回的值。

通过判断每个节点的左右子树返回的值是否为空来返回不同的结果。

如果左右子树返回都不为空说明当前节点为pq节点的最近公共祖先，如果有一个不为空，说明该子树有p或q节点，返回不为空的值。如果都为空说明以该节点为根节点的树无pq节点，返回空。

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == NULL || root == p || root == q) return root;//遇到空节点或pq时返回
        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;
        }    
        
    }
};

总结：最近公共祖先，回溯的逻辑，只是大概明白，还不是很深刻。