二叉树part07

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

题目链接：
https://leetcode.cn/problems/minimum-absolute-difference-in-bst/
思路：
二叉搜索树通过中序遍历变成一个有序数组，然后互相减，找那个最小差就可以
代码：

/*
 * @lc app=leetcode.cn id=530 lang=cpp
 *
 * [530] 二叉搜索树的最小绝对差
 */

// @lc code=start
/**
 * 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:
    vector<int> vec;
    void fun(TreeNode* root){
        if(root==nullptr) return;
        fun(root->left);
        vec.push_back(root->val);
        fun(root->right);
    }
    int getMinimumDifference(TreeNode* root) {
        fun(root);
        int min=INT_MAX;
        for(int i=0;i<vec.size()-1;i++){
            int temp=vec[i+1]-vec[i];
            if(min>temp){
                min=temp;
            }
        }
        return min;

    }
};
// @lc code=end

501二叉搜索树里的众数

链接：
https://leetcode.cn/problems/find-mode-in-binary-search-tree/
思路：
可以用那个unorder_map
但是我用的是一个数组就搞定
1首先是遍历这个二叉树
2.用mode数组放结果
3.遍历1的数组，记录每一个元素出现的次数
如果次数大于目前最大次数，mode数组清空，重新添加元素
如果次数等于目前最大数，mode数组添加元素
4.要记得每次把当前次数置1
5比较重要的一步，就是考虑到最后一个元素，如果这时count>max_count，mode重新清空添加元素，如果等于，就添加元素
6.最后返回mode数组

/*
 * @lc app=leetcode.cn id=501 lang=cpp
 *
 * [501] 二叉搜索树中的众数
 */

// @lc code=start
/**
 * 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:
    
    vector<int> vec;
    void fun(TreeNode* root){
        if(root==nullptr) return;
        fun(root->left);
        vec.push_back(root->val);
        fun(root->right);
    }
    vector<int> findMode(const std::vector<int>& nums) {
    int n = nums.size();
    std::vector<int> modes;  // 用于存储众数的容器
    int mode = nums[0];      // 默认众数为数组的第一个元素
    int count = 1;           // 当前元素的出现次数
    int maxCount = 1;        // 最大出现次数

    for (int i = 1; i < n; i++) {
        if (nums[i] == nums[i-1]) {
            count++;
        } else {
            if (count > maxCount) {
                maxCount = count;
                modes.clear();  // 清空容器，因为找到了更大的出现次数
                modes.push_back(nums[i-1]);
            } else if (count == maxCount) {
                modes.push_back(nums[i-1]);
            }
            count = 1;
        }
    }

    // 检查最后一个元素
    if (count > maxCount) {
        maxCount = count;
        modes.clear();
        modes.push_back(nums[n-1]);
    } else if (count == maxCount) {
        modes.push_back(nums[n-1]);
    }

    return modes;
}
    
    vector<int> findMode(TreeNode* root) {
        fun(root);
        return findMode(vec);
    }
};
// @lc code=end

我觉得这个比那个unorder_map好，这个就是用数组，很简单；

236二叉树祖先

题目链接

/*
 * @lc app=leetcode.cn id=236 lang=cpp
 *
 * [236] 二叉树的最近公共祖先
 */

// @lc code=start
/**
 * 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==p || root==q) return root;

        //定义一个左节点，来接收这个根节点的左边是否有要找的节点：
        TreeNode* left=lowestCommonAncestor(root->left,  p,  q);
        TreeNode* right=lowestCommonAncestor( root->right,  p,  q);

        //如果根节点都不为空（公共祖先就是根节点）：
        if(left!=nullptr && right!=nullptr) return root;
        if(left!=nullptr && right==nullptr) return left;
        if(left==nullptr && right!=nullptr) return right;
        if(left==nullptr && right==nullptr) return nullptr;
        
        return root;
    }
};
// @lc code=end

最后一个return root应该没有用上，但是必须有我就很不懂。