代码随想录| 530.二叉搜索树的最小绝对差501.二叉搜索树中的众数 236. 二叉树的最近公共祖先

import java.util.*;

public class Day16 {
    private static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        public TreeNode(int val) {
            this.val = val;
        }

        public TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
//    给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。
//
//    差值是一个正数，其数值等于两值之差的绝对值。
    int min=Integer.MAX_VALUE;
    TreeNode pre=null;
    public int getMinimumDifference(TreeNode root) {
        if(root==null)
            return min;
二叉搜索树用中序遍历可以得到递增的序列
        int left=getMinimumDifference(root.left);

        if(pre!=null&&min>root.val-pre.val) {
                min =Math.abs(root.val - pre.val);
        }
        pre=root;

        int right=getMinimumDifference(root.right);

        return Integer.min(left,right);
    }
    //给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。
    //如果树中有不止一个众数，可以按 任意顺序 返回。
    //假定 BST 满足如下定义：
    //结点左子树中所含节点的值 小于等于 当前节点的值
    //结点右子树中所含节点的值 大于等于 当前节点的值
    //左子树和右子树都是二叉搜索树
    List<Integer> list=new ArrayList<>();
    int count=0,maxCount=0;
    TreeNode pre1=null;
    public int[] findMode(TreeNode root) {
        findTra(root);
        int[] res=new int[list.size()];
        for(int i=0;i<list.size();i++)
            res[i]=list.get(i);
        return res;
    }
    public void findTra(TreeNode root){

        if(root==null)
            return;

        findTra(root.left);

        if(pre1==null)
            count=1;
        else if(pre1.val==root.val)
            count++;
        else count=1;
        pre1=root;
        if(count==maxCount)
            list.add(root.val);
        if(count>maxCount){//不断更改maxCount，只保留更改后的val
            maxCount=count;
            list.clear();
            list.add(root.val);
        }

        findTra(root.right);
    }
    //给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
    //百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，
    // 满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
    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;//判断逻辑是 如果递归遍历遇到q，就将q返回，遇到p 就将p返回，
            // 那么如果 左右子树的返回值都不为空，说明此时的中节点，一定是q 和p 的最近祖先。
        else if(left==null&&right!=null)
            return right;
        else if(left!=null&&right==null)
            return left;
        else return null;
    }
}