day21 | 二叉树 530,501,236

• 530.二叉搜索树的最小绝对差
  • 先转换为有序list，再比较差值

• 501.二叉搜索树中的众数
  • ​​​​​​​先转换为有序list，再进行众数统计寻找

• 236. 二叉树的最近公共祖先
  • ​​​​​​​后序遍历，再根据返回的值寻找祖先

package algor.trainingcamp;

import algor.junior_algor.tree.TreeNode;

import java.util.ArrayList;
import java.util.List;

/**
 * @author lizhe
 * @version 1.0
 * @description: 二叉搜索树的最小绝对差
 * @date 2023/4/25 07:47
 *
 * 先转换为有序list 再进行处理
 */
public class LeetCode530 {
    List<Integer> midList = new ArrayList<>();
    public int getMinimumDifference(TreeNode root) {
        helper(root);

        int min = Integer.MAX_VALUE;
        for(int i = 0;i < midList.size() - 1;i++){
            if(min > midList.get(i + 1) - midList.get(i)){
                min = midList.get(i + 1) - midList.get(i);
            }
        }

        return min;
    }

    /**
     * 中序遍历
     */
    public void helper(TreeNode root){
        if(null == root){
            return;
        }

        helper(root.left);
        midList.add(root.val);
        helper(root.right);
    }
}

package algor.trainingcamp;

import algor.junior_algor.tree.TreeNode;

import java.util.*;

/**
 * @author lizhe
 * @version 1.0
 * @description:二叉搜索树中的众数
 *
 * 给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。
 *
 * 假定 BST 有如下定义：
 *
 * 结点左子树中所含结点的值小于等于当前结点的值
 * 结点右子树中所含结点的值大于等于当前结点的值
 * 左子树和右子树都是二叉搜索树
 * @date 2023/4/25 07:56
 */
public class LeetCode501 {
    List<Integer> midList = new ArrayList<>();
    public int[] findMode(TreeNode root) {
        helper(root);

        //如何取众数
        return findMode(midList);
    }

    /**
     * 中序遍历
     */
    public void helper(TreeNode root){
        if(null == root){
            return;
        }

        helper(root.left);
        midList.add(root.val);
        helper(root.right);
    }

    public int[] findMode(List<Integer> list){
        List<Integer> resList = new ArrayList<>();

        Map<Integer, Integer> map = new HashMap<>();
        for(Integer num : list){
            map.put(num, map.getOrDefault(num, 0) + 1);
        }

        //众数出现的次数
        int num = map.values().stream().mapToInt(Integer::intValue).max().getAsInt();

        for (Integer elem : map.keySet()) {
            if(map.get(elem).equals(num)){
                resList.add(elem);
            }
        }

        return resList.stream().mapToInt(Integer::intValue).toArray();
    }

    public static void main(String[] args) {
        LeetCode501 demo = new LeetCode501();
        Arrays.stream(demo.findMode(Arrays.asList(1, 2, 2))).forEach(System.out::println);
    }
}

package algor.trainingcamp;

import algor.junior_algor.tree.TreeNode;

/**
 * @author lizhe
 * @version 1.0
 * @description: 236. 二叉树的最近公共祖先
 * 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
 *
 * 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
 *
 * 后序遍历,自底向上寻找
 *
 * 1. 如果左子树为p 右子树为q 或者 左为q右为p，则该节点是祖先
 * 2.
 */
public class LeetCode236 {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null || 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;
    }
}