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

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

文章讲解：代码随想录 530.二叉搜索树的最小绝对差讲解

视频讲解：二叉搜索树中，需要掌握如何双指针遍历！| LeetCode：530.二叉搜索树的最小绝对差

思路和解法

题目：
给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。

差值是一个正数，其数值等于两值之差的绝对值。
想法：
二叉搜索树可以利用性质中序遍历先得到排序后的数组，然后双指针遍历记录最小差值。也可以直接中序遍历二叉搜索树，同样需要双指针，记录最小差值，这道题目需要注意一些细节问题，注意要在利用完pre指针后更新pre指针，还有result的初始化，要取最小差值，就用INT_MAX。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int result = INT_MAX;
    TreeNode* pre = nullptr;
    void traversal(TreeNode* cur) {
        if (cur == nullptr) return ;
        traversal(cur -> left);
        if (pre != nullptr) {
            result = min(result, cur -> val - pre -> val);
        }
        pre = cur;
        traversal(cur -> right);
        return ;
    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

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

文章讲解：代码随想录 501.二叉搜索树中的众数讲解

视频讲解：不仅双指针，还有代码技巧可以惊艳到你！ | LeetCode：501.二叉搜索树中的众数

思路和解法

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

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

假定 BST 满足如下定义：

结点左子树中所含节点的值 小于等于 当前节点的值
结点右子树中所含节点的值 大于等于 当前节点的值
左子树和右子树都是二叉搜索树
想法：
这里用了两种解法，一种是不利用二叉搜索树的性质，用任何方式遍历一次二叉树，用哈希表记录元素的频率，然后用sort自定义比较规则，按频率排序，最后把频率排在前面的元素取出来，注意可能不止一个，注意代码中break的使用。另外这里学到了一点新知识，自定义比较规则函数因为在类内，要写成static，在类内部取类内部的函数地址有点麻烦。还有就是map的具体写法，我自己写成了类的成员变量，也可以在类的成员函数中传递引用，熟悉这个做法。
第二种方法是利用二叉搜索树性质，中序遍历就是有序的从小到大，注意处理当前节点时频率的记录和更新，为了判断当前节点值是否等于上一个节点值需要pre指针，如果频率追平最大频率，当前节点值要放入结果数组，如果超过最大频率，要及时清空结果数组，并放入当前节点值，还要记得及时更新pre指针。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
 //如果不是二叉搜索树的做法
// class Solution {
// private:
//     unordered_map map;
//     //递归遍历二叉树 用map统计元素出现频率 map key:元素 value:频率
//     void searchTree(TreeNode* cur) {
//         if (cur == nullptr) return ;
//         if (cur -> left) searchTree(cur -> left);
//         map[cur -> val]++;
//         if (cur -> right) searchTree(cur -> right);
//         return ;
//     }
//     //自定义比较规则 把元素按照频率从高到低排序
//     //注意 自定义比较这个函数写在类里面 要static才行
//     //自己写没加const 加不加都对
//     bool static myComp(const pair& p1, const pair& p2) {
//         return p1.second > p2.second;
//     }
// public:
//     vector findMode(TreeNode* root) {
//         searchTree(root);
//         //注意这里的创建方式，一定要记下来
//         vector> vec(map.begin(), map.end());
//         sort(vec.begin(), vec.end(), Solution::myComp);
//         vector result;
//         //这里犯了错误 自己写直接用下标访问，是错的
//         result.push_back(vec[0].first);
//         for (int i = 1; i < vec.size(); i++) {
//             if (vec[i].second == vec[i - 1].second) {
//                 result.push_back(vec[i].first);
//             } else {
//                 //这里break的用法也要记住
//                 break;
//             }
//         }
//         return result;
//     }
// };
//下面代码和自己写的区别在于没有写成员变量map，而是在递归函数中传递map的引用，也要熟悉这种写法
// class Solution {
// private:

// void searchBST(TreeNode* cur, unordered_map& map) { // 前序遍历
//     if (cur == NULL) return ;
//     map[cur->val]++; // 统计元素频率
//     searchBST(cur->left, map);
//     searchBST(cur->right, map);
//     return ;
// }
// bool static cmp (const pair& a, const pair& b) {
//     return a.second > b.second;
// }
// public:
//     vector findMode(TreeNode* root) {
//         unordered_map map; // key:元素，value:出现频率
//         vector result;
//         if (root == NULL) return result;
//         searchBST(root, map);
//         vector> 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++) {
//             // 取最高的放到result数组中
//             if (vec[i].second == vec[0].second) result.push_back(vec[i].first);
//             else break;
//         }
//         return result;
//     }
// };

//利用二叉搜索树的性质 中序遍历是从小到大遍历
class Solution {
private:
    //记录上一个节点
    TreeNode* pre =nullptr;
    //记录当前频率
    int count = 0;
    //记录最大频率
    int maxCount = 0;
    //记录众数的集合
    vector<int> result;
    //递归函数 不需要返回值
    void searchBST(TreeNode* cur) {
        //终止条件
        if (cur == nullptr) return ;
        searchBST(cur -> left);
        //第一个节点
        if (pre == nullptr) {
            count = 1;
        } else if (pre -> val == cur -> val) {
            count++;
        } else {
            count = 1;
        }

        //这个先后顺序很重要
        if (count == maxCount) {
            result.push_back(cur -> val);
        }
        //判断是否更新最大频率
        if (count > maxCount) {
            maxCount = count;
            result.clear();
            result.push_back(cur -> val);
        }
        //自己写忘记更新pre了
        pre = cur;
        searchBST(cur -> right);
        return ;
    }

public:
    vector<int> findMode(TreeNode* root) {
        searchBST(root);
        return result;
    }
};

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

文章讲解：代码随想录 236. 二叉树的最近公共祖先讲解

视频讲解：自底向上查找，有点难度！ | LeetCode：236. 二叉树的最近公共祖先

思路和解法

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

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
想法：
这里只学了递归法，用后序遍历，这样可以做到自底向上的处理。（需要自己体会一下自底向上）处理逻辑就是如果遇到了目标的两个节点就直接返回该节点，如果当前节点左右子节点返回都是有效节点，那就直接返回当前节点就是最近的公共祖先。这个规则可以解决所有情况。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        //递归法
        //终止条件
        if (root == nullptr) return nullptr;
        if (root -> val == p ->val || root -> val == q -> val) return root;

        //递归
        TreeNode* leftResult = lowestCommonAncestor(root -> left, p, q);
        TreeNode* rightResult = lowestCommonAncestor(root -> right, p, q);
        if (leftResult && rightResult) {
            return root;
        } else if (leftResult == nullptr && rightResult != nullptr) {
            return rightResult;
        } else if (leftResult != nullptr && rightResult == nullptr) {
            return leftResult;
        } else {
            return nullptr;
        }
    }
};