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

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

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

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

思路：

二叉搜索树有一个特点就是采用中序遍历的话元素的遍历顺序是从小到大排列的。这样的话我们就可以通过遍历这个二叉搜索树来计算两个相邻结点元素的差值，定义一个my_min来不断更新遍历到的差的最小值。

采用的是中序遍历，即左中右。

递归三部曲

第一部：确定函数的参数和返回值

void Mininum(TreeNode* root)

第二部：确定递归终止条件

if(root==NULL) return;

第三部：写出一次递归的逻辑

 Mininum(root->left);

        if(pre!=NULL)  

        {

        my_min = min(root->val-pre->val,my_min);

        pre = root;

        }

        else

        pre = root;

 Mininum(root->right);

代码：

/**
 * 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:
    TreeNode* pre = NULL;
    int my_min = INT_MAX;
    void Mininum(TreeNode* root)
    {
        if(root==NULL) return;
        Mininum(root->left);
        if(pre!=NULL)  
        {
        my_min = min(root->val-pre->val,my_min);
        pre = root;
        }
        else
        pre = root;
        Mininum(root->right);

    }
    int getMinimumDifference(TreeNode* root) {
        if(root==NULL) return 0;
        Mininum(root);
        return my_min;
    }
};

501. 二叉搜索树中的众数

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

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

假定 BST 满足如下定义：

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

思路：

我们知道二叉搜索树的一个特点是如果采用中序遍历的话，元素的遍历顺序是从小到大排列的。

我们可以利用这个特性，采用一个结点指向root结点的前一个结点pre，定义一个变量count，记录相同节点的个数。定义一个变量my_max来记录遍历过程中的临时的count的最大值。

如果root->val==pre->val;count++; 如果root->val!=pre->val;count = 1;通过遍历判断count的值和

my_max的关系。把最大的count对应的元素放入vector。如果count>my_max则更新my_max,清空vector数组，重新记录最大count对应的结点的元素的值。

递归三部曲：

第一部：确定函数的返回值和参数

 void treval(TreeNode* root)

第二部：确定递归结束的条件

 if(root==NULL) return;

第三部：写出一次递归的逻辑

 treval(root->left);
        if(pre==NULL)
        {
            count = 1;
        }
        else if(pre->val==root->val)
        {
            count++;
        }
        else{
            count = 1;
        }
        if(count==my_max)
        {
            result.push_back(root->val);
        }
        if(count>my_max)
        {
            my_max = count;
            result.clear();
            result.push_back(root->val);
        }
        pre = root;
        treval(root->right);

代码：

/**
 * 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 my_max = 0;
    int count = 1;
    TreeNode* pre = NULL;
    vector<int> result;
    void treval(TreeNode* root)
    {
        if(root==NULL) return;
        treval(root->left);
        if(pre==NULL)
        {
            count = 1;
        }
        else if(pre->val==root->val)
        {
            count++;
        }
        else{
            count = 1;
        }
        if(count==my_max)
        {
            result.push_back(root->val);
        }
        if(count>my_max)
        {
            my_max = count;
            result.clear();
            result.push_back(root->val);
        }
        pre = root;
        treval(root->right);
    }
    vector<int> findMode(TreeNode* root) {
            treval(root);
            return result;
    }
};

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

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

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

示例 1：

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3
解释：节点 5 和节点 1 的最近公共祖先是节点 3 。

示例 2：

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出：5
解释：节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。

示例 3：

输入：root = [1,2], p = 1, q = 2
输出：1

思路：

我们可以采用后序遍历，这样可以保证我们在以左右中的遍历顺序来从低到上遍历二叉树。

我们遍历到目标结点就要向上返回这个结点。如果我们遍历到空结点就返回NULL，

如果遍历的结点左不为空右为空，则返回左结点；如果遍历的结点左为空右不为空，则返回右结点；如果遍历的结点左不为空右不为空，则返回根节点。

递归三部曲

第一部：确定函数的返回值和参数

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q)

第二部：确定递归结束的条件

  if(root==NULL) return NULL;

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

        if(left==NULL&&right!=NULL) return right;

        if(left!=NULL&&right==NULL) return left;

代码：

/**
 * 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==NULL) return NULL;
        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 root;
        if(left==NULL&&right!=NULL) return right;
        if(left!=NULL&&right==NULL) return left;
        return NULL;
    }
};

还有很多瑕疵，还需继续坚持！