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

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

文章链接：代码随想录

视频链接：LeetCode:530.二叉搜索树的最小绝对差

题目链接：力扣题目链接

解法1：

class Solution {
public:
	int  result = INT32_MAX;
	TreeNode* pre = NULL;
	void tarversal(TreeNode* node) {
		if (node == NULL) return;
		// 前序遍历 二叉搜索树是一个有序数组
		tarversal(node->left); // 左 先是一直进入递归进到 node = [1]
		if (pre != NULL) {
			result = min(result, node->val - pre->val); 
		}
		pre = node; // pre = node = [1]
		tarversal(node->right); // 遍历[1]的右子树，返回null
		return;  //再返回到上一层, node = [2]
	}
	int getMinimumDifference(TreeNode* root) {
		tarversal(root);
		return result;
	}
};

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

 文章链接：代码随想录

视频链接：LeetCode:501.二叉搜索树中的众数

题目链接：力扣题目链接

解法1：当二叉树不是搜索树时，需要遍历二叉树中的所有值，再进行排序

class Solution {
public:
    // map<int,int> key:元素 , value:出现频率
    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; // 按照频率从大到小排序
    }

    vector<int> findMode(TreeNode* root) {
        unordered_map<int, int> map;
        vector<int> result;
        if(root == NULL) return result;

        searchBST(root, map);
        // 在cpp中如果是用map或者unordered_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++){
            if(vec[0].second == vec[i].second) result.push_back(vec[i].first);
        }
        return result;
    }
};

解法2：

class Solution {
public:
    int maxCount = 0; // 最大频率
    int count = 0; // 统计的频率
    TreeNode* pre = NULL;
    vector<int> result;

    void tarversal(TreeNode* cur){
        if(cur == NULL) return;

        // 中序遍历 左中右
        tarversal(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); //重新放入数值 
        }
        tarversal(cur->right);
        return;
    }

    vector<int> findMode(TreeNode* root) {
        // 初始化
        maxCount = 0;
        count = 0;
        result.clear();
        pre = NULL; 
        
        tarversal(root);
        return result;
    }
};

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

 文章链接：代码随想录

视频链接：LeetCode:236.二叉树的最近公共祖先

题目链接：力扣题目链接

情况1：p,q在左右两端的情况，左右都不为空（left != NULL && right != NULL）

情况2：当p，q在同一端时，遇到q相等就直接返回节点4了，不会再遍历下面，公共祖先就是4，如果另外一个节点在另一边，则又是第一种情况。

解法1：

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == NULL) return root; // 因为root 就是null 所以，返回null与root一样的
        // 当遍历到目标节点时，直接将节点进行返回
        if(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 right;
         else if(left != NULL && right == NULL) return left; 
         else if(left != NULL && right != NULL) return root; // 左右都不为空，则说明祖先是根节点
         else{   // 都为空，则没有，返回null
             return NULL;
         }        
    }
};