2024年7月20日

题530. 二叉搜索树的最小绝对差
使用递归获取中序遍历，然后遍历一遍vector即可得到结果。

import java.util.*;

class Solution {

    Vector<Integer> vec;

    public int getMinimumDifference(TreeNode root) {
        //首先得到中序遍历的结果
        vec = new Vector<>();
        digui(root.left);
        vec.add(root.val);
        digui(root.right);
        int minD = Integer.MAX_VALUE;
        for(int i=0;i<vec.size()-1;i++){
            if(minD>vec.get(i+1)-vec.get(i)){
                minD = vec.get(i+1)-vec.get(i);
            }
        }
        return minD;
    }

    public void digui(TreeNode root){
        if(root==null){
            return;
        }
        digui(root.left);
        vec.add(root.val);
        digui(root.right);
    }   
}

题501. 二叉搜索树中的众数
易错，注意最后遍历map是要找的是频率的最大值，然后依据频率来找key，赋值时不要混淆

/**
 * 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;
 *     }
 * }
 */
import java.util.*;

class Solution {

    HashMap<Integer, Integer> map = new HashMap<>();

    public int[] findMode(TreeNode root) {
        
        digui(root.left);
        map.put(root.val,map.getOrDefault(root.val,0)+1);
        digui(root.right);
        //找出map中value最多的那几个key返回即可
        int maxV = -1;
        for(int i:map.keySet()){
            if(map.get(i)>maxV){
                maxV=map.get(i);
            }
        }
        ArrayList<Integer> list = new ArrayList<>();
        for(int i:map.keySet()){
            if(map.get(i)==maxV){
                list.add(i);
            }
        }
        int[] res = new int[list.size()];
        for(int i=0;i<list.size();i++){
            res[i] = list.get(i);
        }
        return res;
    }

    public void digui(TreeNode root){
        if(root==null){
            return;
        }else{
            digui(root.left);
            map.put(root.val,map.getOrDefault(root.val,0)+1);
            digui(root.right);
            return;
        }
    }
}

题236. 二叉树的最近公共祖先
注意记忆回溯模板，也就是给一个节点，记录root到其的路径的板子

import java.util.*;

class Solution {

    Vector<TreeNode> vec1;
    Vector<TreeNode> vec2; 
    int flag1=0;
    int flag2=0;

    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        //回溯，用path存储两个节点的路径，然后比较，如果第n个不一样了，那么n-1就是答案
        //中序遍历
        vec1 = new Vector<>();
        vec2 = new Vector<>();
        if(root.val==p.val && root.val==q.val){
            return root;
        }
        digui1(root,p);
        digui2(root,q);

        TreeNode pre = root;
        for(int i=0;i<vec1.size()&&i<vec2.size();i++){
            if(vec1.get(i).val==vec2.get(i).val){
                pre = vec1.get(i);
                continue;
            }else{
                break;
            }
        }
        return pre;

    }

    public void digui1(TreeNode root,TreeNode p){
        if(flag1==1){
            return;
        }
        if(root==null){
            return;
        }
        vec1.add(root);
        if(root.val==p.val){
            flag1=1;
            return;
        }else{
            digui1(root.left,p);
            digui1(root.right,p);
        }
        if(flag1==0){
            vec1.remove(vec1.size()-1);
        }
        return;
    }

    public void digui2(TreeNode root,TreeNode q){
        if(flag2==1){
            return;
        }
        if(root==null){
            return;
        }
        vec2.add(root);
        if(root.val==q.val){
            flag2=1;
            return;
        }else{
            digui2(root.left,q);
            digui2(root.right,q);
        }
        if(flag2==0){
            vec2.remove(vec2.size()-1);
        }
        
        return;
    }
}