Day24 530二叉搜索树的最小绝对差 501二叉搜索树中的众数 236二叉树的最近公共祖先

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

给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。

        注意本题是一个二叉搜索树，看到二叉搜索树要想到以下几点：按照中序遍历（左中右）之后的val是单调递增的。本题可以采用数组法，双指针法和迭代法来进行处理。

//数组法
class Solution {
private:
vector<int> vec;
void traversal(TreeNode* root) {
    if (root == NULL) return;
    traversal(root->left);
    vec.push_back(root->val); // 将二叉搜索树转换为有序数组
    traversal(root->right);
}
public:
    int getMinimumDifference(TreeNode* root) {
        vec.clear();
        traversal(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 {
public:
    TreeNode* pre = nullptr; 
    int result = INT_MAX; //存放最后的最小差结果
    void traversal(TreeNode* cur){
         if(!cur) return; //终止条件

        traversal(cur->left); //左

        if(pre) result = min(result, cur->val - pre->val); //中
        pre = cur; //让上一个结点等于当前结点

        traversal(cur->right); //右
    }

    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

//迭代法
class Solution {
public:
    int getMinimumDifference(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* pre = nullptr;
        int result = INT_MAX;
        while(cur || !st.empty()){
            if(cur){
                st.push(cur);
                cur = cur->left;
            }
            else{
                cur = st.top();
                st.pop();
                if(pre){
                    result = min(result, cur->val - pre->val);
                }
                pre = cur;
                cur = cur->right;
            }
        }
        return result;
    }
};

501 二叉搜索树中的众数

给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。

        本题提供两种思路，一种是按照普通二叉树的方法，另一种是利用本题给出的二叉搜索树的做法，如果按照普通二叉树的做法，那么就要创建一个哈希表，unordered map，记录频次，之后排序求众数，如果利用二叉搜索树的方法，那么就是利用双指针法或者迭代法，具体代码如下：

//普通二叉树的方法
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) {
        unordered_map<int, int> map; // key:元素，value:出现频率
        vector<int> result; //存放最后的结果
        if (root == NULL) return result;

        searchBST(root, map);
        
        //map可以通过key排序，但是不能通过value排序，所以我们把map转化为vector
        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++) {
            // 取最高的放到result数组中
            if (vec[i].second == vec[0].second) result.push_back(vec[i].first);
            else break;
        }
        return result;
    }
};

//双指针法
class Solution {
public:
    int MaxCount = 0; //记录最大的频率
    int count = 0; //记录每一组的频率
    vector<int> result; //记录最终的结果
    TreeNode* pre = nullptr; //记录前一个指针

    void searchBST(TreeNode* cur){
        if(cur == nullptr) return;
        searchBST(cur->left); //左

        if(pre == nullptr) count = 1; //第一个要访问的元素
        else if(cur->val == pre->val) count++; //如果相同count+1
        else count =1; //不相同则归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); //右
    }
    vector<int> findMode(TreeNode* root) {
        searchBST(root);
        return result;
    }
};

//迭代法
class Solution {
public:
    vector<int> findMode(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        int maxCount = 0; // 最大频率
        int count = 0; // 统计频率
        vector<int> result;
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) { // 指针来访问节点，访问到最底层
                st.push(cur); // 将访问的节点放进栈
                cur = cur->left;                // 左
            } else {
                cur = st.top();
                st.pop();                       // 中
                if (pre == NULL) { // 第一个节点
                    count = 1;
                } else if (pre->val == cur->val) { // 与前一个节点数值相同
                    count++;
                } else { // 与前一个节点数值不同
                    count = 1;
                }
                if (count == maxCount) { // 如果和最大值相同，放进result中
                    result.push_back(cur->val);
                }

                if (count > maxCount) { // 如果计数大于最大值频率
                    maxCount = count;   // 更新最大频率
                    result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了
                    result.push_back(cur->val);
                }
                pre = cur;
                cur = cur->right;               // 右
            }
        }
        return result;
    }
};

 236 二叉树的最近公共祖先

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

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

         求最小公共祖先，需要从底往上遍历，所有要通过二叉树的后序遍历（即回溯）实现，回溯过程中，必须要遍历整颗二叉树，即使已经找到结果了，依然要把其他结点遍历完，因为要使用递归函数的返回值（right，left）做逻辑判断，对于什么时候返回值，什么时候不返回呢？

搜索一条边的写法：

if (递归函数(root->left)) return ;

if (递归函数(root->right)) return ;

 搜索整棵树的写法：

left = 递归函数(root->left);  // 左
right = 递归函数(root->right); // 右
left与right的逻辑处理;         // 中 

         如果要搜索一条边，递归函数返回值不为空的时候，立刻返回，如果搜索整棵树，要用变量接住返回值，这个变量后序还有逻辑处理的需要，也就是后序遍历中处理中间结点的逻辑（回溯）

         总而言之，不回溯的话，得到条件立刻返回即可，如果要回溯就要接住以后处理返回处理后的值。本题代码如下：

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == nullptr) return nullptr; //如果遍历到空节点，就返回空
        if(root == p || root == q) return root; //如果遍历到了p或者q，就不会继续遍历了，直接向上返回
        //采用后序遍历左右中的方法向上回溯，如果某一边不存在p或者q，就设置为空，否则就会向上返回
        TreeNode* left = lowestCommonAncestor(root->left, p, q); //左
        TreeNode* right = lowestCommonAncestor(root->right, p, q) ; //右
        if(left != nullptr && right != nullptr) return root; //如果左右节点都不为空，这就是公共祖先
        else if(left != nullptr && right == nullptr) return left; //左不空右空说明左子树右p或者q
        else if(left == nullptr && right != nullptr) return right; //和上面同理
        else return nullptr; //左右都为空，遍历结束
    }
};