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

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

思路

遇到在二叉搜索树上求什么最值啊，差值之类的，就把它想成在一个有序数组上求最值，求差值，这样就简单多了。

代码

递归：

class Solution {
public:
    vector<int> vec;
    void travelsal(TreeNode* root){
        if(root == NULL) return;
        travelsal(root->left);
        vec.push_back(root->val);
        travelsal(root->right);
    }
    int getMinimumDifference(TreeNode* root) {
        vec.clear();
        travelsal(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 travelsal(TreeNode* cur) {
        if(cur == NULL) return;
        travelsal(cur->left);
        if(pre != NULL) {
            result = min(result,(cur->val - pre->val));
        }
        pre = cur;
        travelsal(cur->right);
    }
public:
    int getMinimumDifference(TreeNode* root) {
        travelsal(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;
    }
};

总结

1. 迭代法对我来说会更难记忆一些
2. 遇到在二叉搜索树上求什么最值，求差值之类的，都要思考一下二叉搜索树可是有序的，要利用好这一特点。

501.二叉搜索树中的众数

思路

如果不是二叉搜索树，最直观的方法一定是把这个树都遍历了，用map统计频率，把频率排个序，最后取前面高频的元素的集合。有的同学可能可以想直接对map中的value排序，还真做不到，C++中如果使用std::map或者std::multimap可以对key排序，但不能对value排序。所以要把map转化数组即vector，再进行排序，当然vector里面放的也是pair<int, int>类型的数据，第一个int为元素，第二个int为出现频率。
是二叉搜索树：中序遍历有序，统计出现次数，当统计到的次数大于记录中的最大次数时，清空结果集，更新记录，更新结果集。当统计到的次数等于记录最大次数时，更新结果集。

代码

不是二叉搜索树:

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) {
        vector<int> result;
        unordered_map<int, int> map;
        if(root == NULL) 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;
    }
};

情况二：

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.push_back(cur->val);
        }

        if(count > maxCount) {
            maxCount = count;
            result.clear();
            result.push_back(cur->val);
        }

        searchBST(cur->right);
        return ;
    }
    
public:
    vector<int> findMode(TreeNode* root) {
        count = 0;
        maxCount = 0;
        TreeNode* pre = NULL;
        result.clear();

        searchBST(root);
        return result;
    }
};

总结

1. sort方法用自定义的比较方式：首先写一个cmp方法，sort(vec.begin(),vec.end(),cmp);
2. 利用二叉搜索树的特点更高效

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

思路

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

代码

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == p || root == q || root == NULL) return root;

        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);

        if(left == NULL && right != NULL) return right;
        else if(left != NULL && right == NULL) return left;
        else {
            return NULL;
        }
    }
};

总结

1. 求最小公共祖先，需要从底向上遍历，那么二叉树，只能通过后序遍历（即：回溯）实现从底向上的遍历方式。

2. 在回溯的过程中，必然要遍历整棵二叉树，即使已经找到结果了，依然要把其他节点遍历完，因为要使用递归函数的返回值（也就是代码中的left和right）做逻辑判断。

3. 要理解如果返回值left为空，right不为空为什么要返回right，为什么可以用返回right传给上一层结果。