代码随想录算法训练营第18天 | 二叉搜索树进阶

合集 - 代码随想录算法训练营(24)

1.代码随想录算法训练营第2天 | 数组滑动窗口、螺旋打印2024-07-042.代码随想录算法训练营第1天 | 数组二分法、数组双指针2024-07-033.代码随想录算法训练营第3天 | 链表删除元素、翻转链表2024-07-054.代码随想录算法训练营第4天 | 链表两两交换、删除倒N、链表相交、环形链表2024-07-065.代码随想录算法训练营第6天 | 哈希表的应用、复习快慢指针思想2024-07-086.代码随想录算法训练营第7天 | 哈希表和双指针结合、三数和四数之和2024-07-097.代码随想录算法训练营第8天 | 复习字符串API、双指针2024-07-108.代码随想录算法训练营第9天 | 复习字符串匹配、KMP2024-07-129.代码随想录算法训练营第10天 | 复习队列和栈2024-07-1210.代码随想录算法训练营第11天 | 复习逆波兰表达式求值2024-07-1411.代码随想录算法训练营第13天 | 复习二叉树基础2024-07-1512.代码随想录算法训练营第14天 | 复习二叉树翻转2024-07-1713.代码随想录算法训练营第15天 | 二叉树进阶2024-07-2114.代码随想录算法训练营第16天 | 二叉树更加进阶2024-07-2115.代码随想录算法训练营第17天 | 复习二叉搜索树2024-07-22

16.代码随想录算法训练营第18天 | 二叉搜索树进阶2024-07-23

17.代码随想录算法训练营第20天 | 二叉搜索树中级2024-07-2318.代码随想录算法训练营第21天 | 二叉搜索树结尾2024-07-2419.代码随想录算法训练营第22天 | 开始复习回溯2024-07-2420.代码随想录算法训练营第23天 | 回溯进阶2024-07-2721.代码随想录算法训练营第24天 | 复习组合问题2024-07-2822.代码随想录算法训练营第25天 | 回溯问题完结2024-07-2823.代码随想录算法训练营第27天 | 初入贪心2024-07-3024.代码随想录算法训练营第28天 | 贪心进阶2024-07-30

收起

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