代码随想录算法训练营day 21|第六章 二叉树part07

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

需要领悟一下二叉树遍历上双指针操作，优先掌握递归 

题目链接/文章讲解：代码随想录

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

这道题首先就是要把握好二叉搜索树的特性——中序遍历的结果一定是从小到大排列的，而寻找的是最小差值，就意味着一定是要从两个最相近的值中得到最小值。

使用递归的方法。直接在递归地中序遍历中处理，每次当前遍历到的节点都有一个pre节点作为中序遍历的前一个节点，只要将这两个的差值与variance进行比较取小者即可——

class Solution {
public:
    TreeNode* pre=NULL;
    int variance=INT_MAX;
    void traversal(TreeNode* node){
        if(node==NULL) return ;
        traversal(node->left);
        if(pre&&node->val-pre->val<variance) variance=node->val-pre->val;
        pre=node;
        traversal(node->right);
    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return variance;
    }
};

迭代法。这道题因为是要中序遍历，所以要使用栈来实现，每次到取节点的时候更新variance，并且更新pre节点即可，在这里更新pre节点是因为pre节点是用过了之后才需要更新的——

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;
    }

501.二叉搜索树中的众数 

和 530差不多双指针思路，不过 这里涉及到一个很巧妙的代码技巧。可以先自己做做看，然后看我的视频讲解。

文章讲解/题目链接：

代码随想录

视频讲解：

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

如果不是搜索二叉树的话，那么就需要使用map来辅助（统计次数）了，原理是很简单的，主要是看看怎么具体实现，对于map怎么操作，还有sort函数的应用。sort函数不能直接对map排序，得将map转换成数组之后才能使用sort——

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);
        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;
    }
};

这里的cmp函数就是直接正常的比较方法，但是在创建堆的时候是相反的比较，就是说大顶堆的判定函数是要左边小于右边，突然想到了，所以这里回忆一下怎么创建一个小顶堆，顺带复习一下map怎么遍历（是要使用iterator迭代器的）——

    // 小顶堆
    class mycomparison {
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second;
        }
    };
    // 定义一个小顶堆，大小为k
    priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;
 
    // 使用迭代器扫map
    for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) 

对于二叉搜索树，那就和上一道题一个思路，也是在递归的时候处理中间节点，主要利用了中序遍历二叉搜索树是按照单调不减的顺序排列的，所以相等的两个数应该在中序遍历的结果中是相邻的，这时候可以根据是否和pre节点相等来统计出现的次数，而如果不相等那就直接重置统计的次数，开始新一轮的统计；这里还要注意就是一旦统计的次数大于了最大的次数，就要将res数组clear掉，再存进当前节点的数值；还有如果当前统计的次数等于最大统计次数或者最大统计次数为1的时候，就要直接将当前节点的数值存进res数组——

class Solution {
public:
    TreeNode* pre=NULL;
    vector<int> res;
    int maxTime=1;
    int time=1;
    void traversal(TreeNode* node){
        if(node==NULL) return;
        traversal(node->left);
        if(maxTime==1) res.push_back(node->val);
        if(pre){
            if(pre->val==node->val) {
                time++;
                if(time>maxTime){
                    res.clear(); 
                    res.push_back(node->val);
                    maxTime=time;
                }else if(time==maxTime) res.push_back(node->val);                
            }else time=1;            
        }
        pre=node;
        traversal(node->right);
    }
    vector<int> findMode(TreeNode* root) {
        traversal(root);
        return  res;
    }
};

迭代法只要实现中序遍历，对于中间节点的处理和递归法大差不差。

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

本题其实是比较难的，可以先看我的视频讲解 

题目链接/文章讲解：

代码随想录

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

递归首先要确定递归函数的参数和返回值，返回值必然是要返回最近祖先节点，每次递归函数都需要对当前节点进行判断（判断是不是要求节点的最近祖先节点），所以需要当前节点和要求节点作为参数。

还要确定递归何时结束，那就是当当前节点为空或者恰好就是两个要求节点中的一个的时候，就需要终止递归，返回当前节点。

然后就是单次递归要完成什么，如果当前遍历的节点不满足要求，那就要判断它的左子树和右子树是否满足。如果成功找到了满足要求的节点，那就会经历先在本次递归中返回自身，然后再在上次递归中（它的父母节点的那次递归中）返回该节点（也就是返回父母节点的左子树或右子树），所以后续递归的回收返回的都会是找到的那个节点（精髓在于设置了left和right指针来接住找到的那个节点）——

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root==NULL||root==p||root==q) return root;
        TreeNode* left=lowestCommonAncestor(root->left,p,q);
        TreeNode* right=lowestCommonAncestor(root->right,p,q);
        if(left!=NULL&&right!=NULL) return root;
        if(left!=NULL&&right==NULL) return left;
        else if(left==NULL&&right!=NULL) return right;
        else return NULL;
    }