算法Day16|.二叉树专题五 700.二叉搜索树中的搜索，98.验证二叉搜索树，530.二叉搜索树的最小绝对差，501. 二叉搜索树中的众数

已于 2022-11-20 10:49:49 修改
阅读量226 收藏
点赞数
分类专栏： 算法 文章标签： 算法 leetcode java 数据结构
于 2022-11-11 12:18:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Road_slow/article/details/127802570
版权

700.二叉搜索树中的搜索

1.题目描述

  • 给定二叉搜索树（BST）的根节点 root 和一个整数值 val。
  • 你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

2.解题思路 

二叉搜索树是一个有序树：

  • 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
  • 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
  • 它的左、右子树也分别为二叉搜索树。

3.代码实现

1.确定递归函数的参数和返回值：

        递归函数定义：传入根节点和目标值，返回目标值所在的节点，目标值不存在就返回null。

    //700.二叉搜索树中的搜索
    //递归函数定义：传入根节点和目标值，返回目标值所在的节点，目标值不存在就返回null 
    public TreeNode searchBST(TreeNode root, int val) {}

2.确定终止条件：

        如果为空节点的话，就返回null，表示目标值不存在。

        //递归终止条件
        if (root == null) {
            return root;
        }

 3.确定单层递归的逻辑：

        利用二叉搜索树的特性：

  • 目标值小于当前节点值，去当前节点的左子树寻找。
  • 目标值大于当前节点值，去当前节点的右子树寻找。
  • 目标值等于当前节点值，返回当前节点。
        //单层递归逻辑
        TreeNode res = null;
        if (val < root.val) {
            res = searchBST(root.left, val);//去当前节点的左子树寻找
        } else if (val > root.val) {
            res = searchBST(root.right, val);//去当前节点的右子树寻找
        } else {
            return root;//返回当前节点
        }
        return res;

 完整代码如下：

class Solution {
    //700.二叉搜索树中的搜索
    //递归函数定义：传入根节点和目标值，返回目标值所在的节点，目标值不存在就返回null
    public TreeNode searchBST(TreeNode root, int val) {
        //递归终止条件
        if (root == null) {
            return root;
        }
        //单层递归逻辑
        TreeNode res = null;
        if (val < root.val) {
            res = searchBST(root.left, val);
        } else if (val > root.val) {
            res = searchBST(root.right, val);
        } else {
            return root;
        }
        return res;
    }
}

 98.验证二叉搜索树

1.题目描述

    给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

    有效二叉搜索树定义如下：

  • 节点的左子树只包含 小于 当前节点的数。
  • 节点的右子树只包含 大于 当前节点的数。
  • 所有左子树和右子树自身必须也是二叉搜索树。

2.解题思路 

要知道中序遍历下，输出的二叉搜索树节点的数值是有序序列。

有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。

3.代码实现

3.1递归法

1.确定递归函数的参数和返回值：

        递归函数定义：传入一个节点,采用中序遍历，把节点值放进list中。

     //递归函数定义：传入一个节点,采用中序遍历，把节点值放进list中
    public void travesal(TreeNode root) {}

2.确定终止条件：

        如果为空节点的话，就return。

        //递归终止条件
        if (root == null) {
            return;
        }

 3.确定单层递归的逻辑：

       利用二叉搜索树的特性：

  • 单层递归逻辑(一定采用中序遍历，左中右)。

  • 把遍历到的所有节点值放进list 中。

  • 将list转换为数组，检查是否有序即可。

        //单层递归逻辑(一定采用中序遍历，左中右)
        isValidBST(root.left);//左
        //把遍历到的所有节点值放进list 中
        inOrderList.add(root.val);
        isValidBST(root.right);//右

完整代码如下：

class Solution {
    //98.验证二叉搜索树
    List<Integer> inOrderList = new ArrayList<>();

    public boolean isValidBST(TreeNode root) {
        travesal(root);
        //将list转换为数组，检查是否有序即可
        int[] inOrderArray = inOrderList.stream()
                           .mapToInt(Integer::intValue).toArray();
        for (int i = 1; i < inOrderArray.length; i++) {
            if (inOrderArray[i] <= inOrderArray[i - 1]) {
                return false;
            }
        }
        return true;
    }

    //递归函数定义：传入一个节点,采用中序遍历，把节点值放进list中
    public void travesal(TreeNode root) {
        //递归终止条件
        if (root == null) {
            return;
        }
        //单层递归逻辑(一定采用中序遍历，左中右)
        isValidBST(root.left);//左
        //把遍历到的所有节点值放进list 中
        inOrderList.add(root.val);
        isValidBST(root.right);//右
    }
}

3.2递归法（双指针）

class Solution {
   //98.验证二叉搜索树（双指针-递归）
    TreeNode pre;
    //递归函数定义：传入一个节点,检查以该节点为根节点的树是不是二叉搜索树
    public boolean isValidBST(TreeNode root) {
        //递归终止条件
        if (root == null) {
            return true;
        }
        //单层递归逻辑(一定采用中序遍历，左中右)
        boolean leftBST = isValidBST(root.left); //左
        //每次比较pre和root的值，只要不满足单调递增就返回false
        if (pre != null && pre.val >= root.val) {
            return false;
        }
        //更新pre，让pre跟在root的后面
        pre = root;                                //中
        boolean rightBST = isValidBST(root.right); //右
        return leftBST && rightBST;
    }
}

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

1.题目描述

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

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

 2.解题思路 

  • 题目中要求在二叉搜索树上任意两节点的差的绝对值的最小值。
  • 注意是二叉搜索树，二叉搜索树可是有序的。
  • 遇到在二叉搜索树上求什么最值啊，差值之类的，就把它想成在一个有序数组上求最值，求差值，这样就简单多了。
  • 当然也可以采用双指针的写法，每次更新差值即可。

 3.代码实现（递归-双指针）

1.确定递归函数的参数和返回值：

        递归函数定义：传入一个节点,用于更新最小绝对差（res)。

    //递归函数定义：传入一个节点,用于更新最小绝对差（res)
    public void travesal2(TreeNode cur) {}

2.确定终止条件：

        如果为空节点的话，就return。

        //递归终止条件
        if (root == null) {
            return;
        }

 3.确定单层递归的逻辑：

       利用二叉搜索树的特性：

  • 单层递归逻辑(一定采用中序遍历，左中右)。

  • 每次得到cur和preNode的差值，更新res。

  • 更新preNode，让preNode跟在cur的后面。

        //单层递归逻辑
        travesal2(cur.left);
        //每次得到cur和preNode的差值，更新res
        if (preNode != null) {
            res = Math.min(res, cur.val - preNode.val);
        }
        //更新preNode，让preNode跟在cur的后面
        preNode = cur;
        travesal2(cur.right);

完整代码如下：

class Solution {
 //530.二叉搜索树的最小绝对差
    int res = Integer.MAX_VALUE;
    TreeNode preNode;

    public int getMinimumDifference(TreeNode root) {
        travesal2(root);
        return res;
    }

    //递归函数定义：传入一个节点,用于更新最小绝对差（res)
    public void travesal2(TreeNode cur) {
        //递归终止条件
        if (cur == null) {
            return;
        }
        //单层递归逻辑
        travesal2(cur.left);
        //每次得到cur和preNode的差值，更新res
        if (preNode != null) {
            res = Math.min(res, cur.val - preNode.val);
        }
        //更新preNode，让preNode跟在cur的后面
        preNode = cur;
        travesal2(cur.right);
    }
}

501. 二叉搜索树中的众数

1.题目描述

        给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有众数（即出现频率最高的元素）。如果树中有不止一个众数，可以按任意顺序返回。

假定 BST 满足如下定义：

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

 2.解题思路  

 这道题目呢，递归法从两个维度来讲。

        首先如果不是二叉搜索树的话，应该怎么解题，是二叉搜索树，又应该如何解题，两种方式做一个比较，可以加深大家对二叉树的理解。

3.代码实现

3.1递归法（非二叉搜索树）

  1. 新建一个map，Key：节点值，value:用于存放每个节点出现的频率。
  2. 将map按频率由高到低进行排序，并转换为list。
  3. 得到list中第一个元素（排序后频率最高），添加到结果集中。
  4. 查看是否有和最大频率相同的元素，有的话就加到结果集中，如果不相等，因为排序了，后边的频次都比前边小，终止循环。

 完整代码如下：

class Solution {
    //501. 二叉搜索树中的众数-暴力解法
    //Key：节点值，value:用于存放每个节点出现的频率
    HashMap<Integer, Integer> map = new HashMap<>();

    public int[] findMode(TreeNode root) {
        //结果集
        ArrayList<Integer> ans = new ArrayList<>();
        if (root == null) {
            return ans.stream().mapToInt(Integer::intValue).toArray();
        }
        //得到节点出现的频率map
        travesal4(root);
        //将map按频率由高到低进行排序，并转换为list
        List<Map.Entry<Integer, Integer>> list = map.entrySet().stream()
                .sorted((c1, c2) -> c2.getValue() - c1.getValue())
                .collect(Collectors.toList());
        //得到list中第一个元素（排序后频率最高），添加到结果集中
        ans.add(list.get(0).getKey());
        //查看是否有和最大频率相同的元素，有的话就加到结果集中
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i).getValue() == list.get(0).getValue()) {
                ans.add(list.get(i).getKey());
            } else {
                //如果不相等，因为排序了，后边的频次都比前边小，终止循环
                break;
            }
        }
        return ans.stream().mapToInt(Integer::intValue).toArray();

    }
    public void travesal4(TreeNode cur) {
        //递归终止条件
        if (cur == null) {
            return;
        }
        //单层递归逻辑
        map.put(cur.val, map.getOrDefault(cur.val, 0) + 1);
        travesal4(cur.left);   //左
        travesal4(cur.right);   //右
    }
}

3.2递归法（二叉搜索树）

1.确定递归函数的参数和返回值：

        递归函数定义：传入一个节点,用于更新众数MaxCount，并将众数放进list中。

     //递归函数定义：传入一个节点,用于更新众数MaxCount，并将众数放进list中
    public void travesal3(TreeNode cur) {}

2.确定终止条件：

        如果为空节点的话，就return。

        //递归终止条件
        if (root == null) {
            return;
        }

 3.确定单层递归的逻辑：

       利用二叉搜索树的特性：

  1. 单层递归逻辑(一定采用中序遍历，左中右)。

  2. 根据preNode和cur的值，更新count。

  3. 为了只遍历一次，碰到一个count就添加到list中。

  4. count（一个节点出现的个数）大于MaxCount(之前记录的节点最大出现次数)，更新MaxCount值​​​​​​​，并将list清空，把MaxCount对应的节点放进list。

  5. 更新preNode，让preNode跟在cur的后面。

        //单层递归逻辑
        travesal3(cur.left);   //左
        //根据preNode和cur的值，更新count
        if (preNode == null) {
            count = 1; //pre不存在，cur为第一个节点，count=1
        } else if (preNode.val == cur.val) {
            count++; //两者相等，count++
        } else {
            count = 1;//两者不相等，新节点出现次数为1
        }
        //为了只遍历一次，碰到一个count就添加到list中
        if (count == MaxCount) {
            list.add(cur.val);
            //count（一个节点出现的个数）大于MaxCount(之前记录的节点最大出现次数)
        } else if (count > MaxCount) {
            MaxCount = count;//更新MaxCount值
            list.clear();//并将list清空
            list.add(cur.val);//把MaxCount对应的节点放进list
        }
        //更新preNode，让preNode跟在cur的后面
        preNode = cur;         //中
        travesal3(cur.right);   //右

 完整代码如下：

class Solution {
     //501. 二叉搜索树中的众数
    TreeNode preNode;
    int count = 0;
    int MaxCount = 0;
    List<Integer> list = new ArrayList<>();

    public int[] findMode(TreeNode root) {
        travesal3(root);
        return list.stream().mapToInt(Integer::intValue).toArray();
    }

    //递归函数定义：传入一个节点,用于更新众数MaxCount，并将众数放进list中
    public void travesal3(TreeNode cur) {
        //递归终止条件
        if (cur == null) {
            return;
        }
        //单层递归逻辑
        travesal3(cur.left);   //左
        //根据preNode和cur的值，更新count
        if (preNode == null) {
            count = 1; //pre不存在，cur为第一个节点，count=1
        } else if (preNode.val == cur.val) {
            count++; //两者相等，count++
        } else {
            count = 1;//两者不相等，新节点出现次数为1
        }
        //为了只遍历一次，碰到一个count就添加到list中
        if (count == MaxCount) {
            list.add(cur.val);
            //count（一个节点出现的个数）大于MaxCount(之前记录的节点最大出现次数)
        } else if (count > MaxCount) {
            MaxCount = count;//更新MaxCount值
            list.clear();//并将list清空
            list.add(cur.val);//把MaxCount对应的节点放进list
        }
        //更新preNode，让preNode跟在cur的后面
        preNode = cur;         //中
        travesal3(cur.right);   //右
    }
}

Road_slow
关注
专栏目录
lambda小技巧：List变数组 reduce flatMap......
weixin_44841849的博客
12-19 1567
List< Integer > 变为int[]: list.stream().mapToInt(Integer::intValue).toArray() mapToInt 方法：就是让list这个stream中的每个元素，调用里面的这个转为int方法的方法（Returns an {@code IntStream} consisting of the results of applying the given function to the elements of this stream.） .
记录Java编程小技巧——将存放Integer的List、Map等结构转化成int数组
NinoSun的博客
11-12 540
方法很简单，这里举两个例子，套用即可。 // ArrayList<Integer> --> int[] int[] nums = list.stream().mapToInt(Integer::intValue).toArray(); // Map.keySet() --> int[] int[] arr = map.keySet().stream().mapToInt(Integer::intValue).toArray(); ...
Java集合使用
weixin_44442186的博客
03-31 773
集合转Map 使用 java.util.stream.Collectors类的 toMap()方法转为 Map 集合，其内部调用了 Map 接口的merge()方法，而merge()方法会先调用 Objects.requireNonNull()方法判断 value 是否为空 list.stream().collect(Collectors.toMap()); 注意：list是要转换的List表名，toMap()内是需要的list里面的内容 基本类型数组转List 1、使用Arrays.asList
Java Integer intValue()方法具有什么功能呢？
qq_25073223的博客
09-07 958
Java Integer intValue()方法的功能简介说明
Lambda表达式
Flying_Fish_roe的博客
04-22 300
在这个例子中，我们使用Lambda表达式来计算一个整数列表的平均值。首先，我们将整数列表转换为一个IntStream流，然后使用mapToInt方法将流中的元素映射为int类型，接着使用average方法计算所有元素的平均值。expression或statements是函数体，可以是一个表达式或一组语句。Lambda表达式可以让代码更加简洁和易读，同时也可以提高代码的可维护性和可扩展性。Lambda表达式是Java 8中新增的一个语言特性，它可以用更简洁的方式来表示匿名函数。
INTEGER的INTVALUE()方法
az44yao的专栏
06-18 1261
Integer n1 = 123; Integer n2 = 123; Integer n3 = 128; Integer n4 = 128; System.out.println(n1 == n2);// true System.out.println(n3 == n4);// false System.out.println(n3.intValue()==n4.intValue());// true System.out.println(128==n3);// true System.out.print
二叉树-基于C++实现的二叉搜索树.zip
最新发布
04-26
二叉搜索树（Binary Search Tree，BST）是二叉树的一个特例，它具有以下特性：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种特性使得二叉搜索树非常...
树-98. 验证二叉搜索树-PYTHON
01-20
验证二叉搜索树”中，我们需要编写一个Python函数来验证一个给定的二叉树是否符合二叉搜索树的特性。 题目提供了三个不同的解法：递归、迭代以及中序遍历。 1. **递归解法**： 这种方法基于二叉搜索树的性质，将...
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
二叉搜索树（Binary Search Tree, BST）是一种特殊的二叉树结构，它的每个节点都包含一个键值（key）、一个指向左子树的指针和一个指向右子树的指针。在二叉搜索树中，对于任意节点，其左子树中的所有节点的键值都...
二叉树的二叉搜索表示.rar_二叉搜索树_二叉树的二叉搜索
09-22
二叉搜索树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都具有以下特性： 1. **左子树性质**：左子树上所有节点的值都小于当前节点的值。 2. **右子树性质**：右子树上所有节点的值都大于当前...
BST.rar_binary search tree_二叉搜索树
09-19
二叉搜索树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉搜索树中，对于任意节点，其左子树中的所有...
Java 语法小记
小威的博客
05-15 1788
本文用于记录日常遇到的不常见的 Java 语法。
上好的刷题Day17
hushe20202020的博客
04-19 337
刷题Day17
Integer.valueOf、intValue、Integer.parseInt使用
liyuan_yoao的博客
11-29 489
Integer.parseInt()；是不是效果更好
SpringDataJPA--实际操作
zgz102928的博客
04-24 1885
SpringDataJPA,实际中具体的操作可以有很多种不同的方式，在进行区分的时候通常要结合Stream流进行操作，
Java8<将Integer[]转换为int[]数组>
Gpwner的博客
06-24 1万+
如何 将一个Integer数组拆箱转换为int[]?(你当然可以用for循环来做) public static void main(String[] args) { Integer[] integers = new Integer[10]; int[] ints; for (int i = 0; i < integers.length; i++)
Java中List, Integer[], int[]的相互转换
编码行者的博客
09-14 1637
相信新手们在学习Java的过程中都会遇到和我一样的问题：想要把List和int[]相互转换太麻烦了。 List和String[]也同理。难道每次非得写一个循环遍历吗？其实一步就可以搞定。 本文涉及到一些Java8的特性。如果没有接触过就先学会怎么用，然后再细细研究。 import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class Main { public stati
JDK8新特性05-Stream API
程序员飞扬的博客
06-04 372
Java8重点掌握Stream API，太优雅了
java中intvalue方法作用_Java Integer类intValue()方法及示例
热门推荐
weixin_39952800的博客
02-28 1万+
整数类intValue()方法intValue()方法在java.lang包中可用。intValue()方法用于返回此Integer对象表示的值，该值转换为int类型(通过强制转换)。intValue()方法是一个非静态方法，只能通过类对象访问，如果尝试使用类名称访问该方法，则会收到错误消息。从整数转换为int时，intValue()方法不会引发异常。语法：publicintintValue(...
C++高效二叉搜索树查找算法实现探讨
资源摘要信息:"二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme" 本资源是一个关于二叉搜索树查找算法的实现的压缩包文件，文件名称为“二叉搜索树查找算法【实现】”，其内容主要涉及使用C++...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Road_slow

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值