算法学习打卡day20｜530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先

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

力扣题目链接
题目描述：
给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。
差值是一个正数，其数值等于两值之差的绝对值。

思路：

• 和验证二叉搜索树一样，二叉搜索树中序遍历是有序的，所以中序遍历提前保存前一个节点，然后存储一个全局差值，遍历完之后就得到了最小绝对差

代码实现：

TreeNode* pre;
    int min = INT_MAX;
    void traversal(TreeNode* node) {
        if (node == nullptr)    return;
        traversal(node->left);
        if (pre && abs(node->val - pre->val) < min) {
            min = node->val - pre->val;
        }
        pre = node;
        traversal(node->right);
    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return min;
    }

501.二叉搜索树中的众数

力扣题目链接
题目描述：
给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。

如果树中有不止一个众数，可以按 任意顺序 返回。

假定 BST 满足如下定义：

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

思路：

• 方法一：普通二叉树的做法：遍历一次二叉树，把每个元素出现的次数存到map里，然后对这些数据排序，注意这里是先转换为vector才能排序，然后取出众数就行。
• 方法二： 和上一个题是一样的解题方法，我们在遍历过程中就去计数，当和pre节点相同就count++，如果和pre节点不同就count = 1，然后比较count和max_count，如果相等就push_back，如果比max_count大就清空vector，否则就去遍历右子树。

代码实现

• 普通方法

void traversal(TreeNode* root, unordered_map<int, int>& count) {
        if (root == nullptr)    return;
        count[root->val]++;
        traversal(root->left, count);
        traversal(root->right, count);
    }
    static bool cmp(const pair<int, int>& a, const pair<int, int>& b) {
        return a.second > b.second;
    }//必须定义成静态的，因为sort函数调用的地方找不到这个类的成员函数
    vector<int> findMode(TreeNode* root) {
        vector<int> results;
        unordered_map<int, int> count;//计数
        traversal(root, count);

        //排序
        vector<pair<int, int>> vec(count.begin(), count.end());
        sort(vec.begin(), vec.end(), cmp);
        results.push_back(vec[0].first);
        for (int i = 1; i < vec.size(); ++i) {
            if (vec[i].second == vec[0].second) {
                results.push_back(vec[i].first);
            }
        }
        return results;
    }

• 中序遍历递归法

vector<int> results;
    int max_count = INT_MIN;
    int count = 0;
    TreeNode* pre = nullptr;
    void traversal(TreeNode* root) {
        if (root == nullptr)    return;
        traversal(root->left);
        if (pre == nullptr) {
            count = 1;
        } else if (root->val == pre->val) {
            count++;
        } else {
            count = 1;
        }
        if (count == max_count) results.push_back(root->val);
        if (count > max_count) {
            max_count = count;
            results.clear();
            results.push_back(root->val);
        }
        pre = root;
        
        traversal(root->right);
    }
    vector<int> findMode(TreeNode* root) {
        traversal(root);
        return results;
    }

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

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

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

示例 1：

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3
解释：节点 5 和节点 1 的最近公共祖先是节点 3 。
思路：

• 这道题是找最近公共祖先，那么应该是从下往上找才是最近的，怎么从下往上找呢，二叉树里只有后序遍历是从下往上找。
• 在找的过程中，我们遇到p或者q就返回p或者q，然后分别递归左右子树，拿到返回值，对返回值分情况讨论，第一、左右返回值都为空，说明没找到，直接返回nullptr，第二、左节点为空右不为空就返回右节点，右为空左不为空就返回左节点，第三、都不为空就返回当前节点（说明左右节点分别找到了p和q，因为二叉树里没有重复元素！！！），我们可以发现只要找到了祖先它就会一路向上返回到根节点（其他位置肯定都是空了！）
• 还有一种情况是恰好p或者q是祖先，那么其实这种情况已经包含在上面描述的情形里了，如果q或q是祖先，那么遇到它就返回它，另一个目标值在它的子树里，二叉树的其他节点肯定找不到了，返回的都是空，那么最后得到的结果还是这个祖先值。

代码实现：

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
       if (root == nullptr) return root;
       if (root == p || root == q)  return root;
       TreeNode* left = lowestCommonAncestor(root->left, p, q);
       //这里做了一个优化，如果找到了祖先，直接就退出了，
       //不去遍历右子树（但是上面说的第二种情况还是会遍历右子树）
       if (left && left != q && left != p)  return left;
       TreeNode* right = lowestCommonAncestor(root->right, p, q);
       if (left && right) return root;
       if (right && !left)   return right;
       if (!right && left)  return left;
       return nullptr;
    }