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

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

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

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

示例 1：

输入：root = [4,2,6,1,3]
输出：1

示例 2：

输入：root = [1,0,48,null,null,12,49]
输出：1

提示：

• 树中节点的数目范围是 [2, 104]
• 0 <= Node.val <= 105

思路:二叉搜索树的中序遍历结果是递增数列,我们可以把遍历的结果存入一个数组中,遍历该数组找到最小绝对差,但是开辟该数组需要额外存储空间,我们可以使用两个指针,分别执行当前结点和前一结点来更新最小绝对差

递归三要素:

1.确定返回值和参数的类型

传入一颗树的根节点,返回值为void,由全局变量记录最小绝对差

2.确定结束条件

遇见空节点就停止继续递归

3.单层递归逻辑

中序遍历的结果是按从小到大排列的,用一个全局变量记录上一个结点的位置,进而更新绝对差

代码参考:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    TreeNode pre=null;
    int mindiff=Integer.MAX_VALUE;
    public int getMinimumDifference(TreeNode root) {
           travel(root);
           return mindiff;
    }
    public void travel(TreeNode cur){
        if(cur==null) return;
        travel(cur.left);
         if(pre !=null){
            mindiff = Math.min(mindiff,Math.abs(cur.val-pre.val));
         }
           pre=cur;
         travel(cur.right);

    }
}

---

501. 二叉搜索树中的众数

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

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

假定 BST 满足如下定义：

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

示例 1：

输入：root = [1,null,2,2]
输出：[2]

示例 2：

输入：root = [0]
输出：[0]

提示：

• 树中节点的数目在范围 [1, 104] 内
• -105 <= Node.val <= 105

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    TreeNode pre=null;
    List<Integer> result = new LinkedList<>();
    int maxCount=0;
    int curCount=1;//初始化,第一个结点时curCount1;
    public int[] findMode(TreeNode root) {
        travel(root);
   int[]  result1= new int[result.size()];
    for(int i=0;i<result.size();i++){
        result1[i]=result.get(i);
    }
return result1;
    }

    public void travel(TreeNode cur){
       
        if(cur == null)
        return;
        travel(cur.left);
         //不为第一个结点时,如何计算curCount
        if(pre != null){
           if(pre.val==cur.val){
            curCount++;
            
           }else{
             curCount=1;
           }
        }
       //为第一个结点时,curCount已经初始化为1;
           if(maxCount==curCount){
            result.add(cur.val);
           }
           if(maxCount < curCount){
            //如今次数更多的结点要将结果集里的数字清空
            result.clear();
            maxCount=curCount;
            result.add(cur.val);
           }
       
        pre=cur;
         travel(cur.right);
    }
}

---

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

提示：

• 树中节点数目在范围 [2, 105] 内。
• -109 <= Node.val <= 109
• 所有 Node.val 互不相同 。
• p != q
• p 和 q 均存在于给定的二叉树中。

思路:

采用后序遍历,递归遍历左右子树后,

如果遍历左子树得到的值不为null且右子树遍历得到的值不为空,这个返回该节点,该节点则是最近公共祖先

如果其中一个得到的值不为空,则返回这个值,这个值结果最近公共祖先

如果该节点为目标结点的其中一个,返回该节点

递归三部曲

1.确定返回值和参数的类型

返回值为TreeNode,参数为当前结点,两个目标结点

2.确定递归结束条件

遇见空结点,返回null

遇见目标结点,返回目标结点

3.确定单层递归逻辑 

递归遍历左右子树后,如果遍历左子树得到的值不为null且右子树遍历得到的值不为空,这个返回该节点,该节点则是最近公共祖先

如果其中一个得到的值不为空,则返回这个值,这个值结果最近公共祖先

如果两个值都为空,则没找到最近公共祖先,返回Null

代码参考:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
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;
        }
        return left==null?right:left;
    }
}