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

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

题目：

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

差值是一个正数，其数值等于两值之差的绝对值。

/**
 * 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 res=INT_MAX;
    TreeNode* pre=nullptr, *cur=nullptr;
    void travl(TreeNode* root){
        if(root==nullptr) return;
        travl(root->left);

        //cur=root;
        if(pre!=nullptr){
            //int de = abs(cur->val - pre->val);
            //res = res<de ? res:de;
            res = min(res,abs(root->val - pre->val));

        }
        //pre = cur;
        pre=root;

        travl(root->right);
    }

    int getMinimumDifference(TreeNode* root) {
        travl(root);
        return res;
    }
};

中序遍历，记录最小差值

501. 二叉搜索树中的众数

题目：

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

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

假定 BST 满足如下定义：

• 结点左子树中所含节点的值 小于等于 当前节点的值
• 结点右子树中所含节点的值 大于等于 当前节点的值
• 左子树和右子树都是二叉搜索树

/**
 * 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> res;
    int max_len = 1;
    int len=1;
    //int val;
    TreeNode *pre=nullptr, *cur=nullptr;
    void travel(TreeNode* root){
        if(root==nullptr) return;

        travel(root->left);

        cur=root;
        //val=cur->val;
        if(cur&&pre){
            if(cur->val==pre->val){
                len++;
            }
            else{
                if(len>max_len){
                    max_len=len;
                    res.clear();
                    res.push_back(pre->val);
                }
                else if(len==max_len){
                    res.push_back(pre->val);
                }
                else{

                }
                len=1;//重置len
            }
        }
        pre=cur;
        travel(root->right);
        return;
    }
    vector<int> findMode(TreeNode* root) {
        if(root->left==nullptr&&root->right==nullptr) return vector<int> {root->val};
        travel(root);
        //判断加上最后一个节点的结果
        if(len>max_len){
            res.clear();
            res.push_back(pre->val);
        }
        else if(len==max_len){
            res.push_back(pre->val);
        }
        return res;
    }
};

维护、更新最大长度以及当前最大长度（数量）的数值组成的数组，遍历完一遍之后，该长度自动变为最大长度，该数组也就是最大长度的元素的数组。

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:
//明确语义： 返回以root为跟节点的子树中是否含有待查找节点（没有则返回nullptr，有就返回该节点指针，以此判断），
// 公共子树逻辑：若该root节点的左子树和右子树中都有待查找节点，则返回当前节点，此时函数语义为返回要找的公共祖先节点
    TreeNode* travel(TreeNode* root, TreeNode* p, TreeNode* q){
        if(root==nullptr) return nullptr;
        if(root==p||root==q) return root;

        TreeNode* lp=travel(root->left,p,q);
        TreeNode* rp=travel(root->right,p,q);

        if(lp!=nullptr&&rp!=nullptr) return root;
        if(lp!=nullptr&&rp==nullptr) return lp;
        if(lp==nullptr&&rp!=nullptr) return rp;
        return nullptr;
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        return travel(root,p,q);
    }
};