代码随想录：二叉树22-24

最新推荐文章于 2024-11-01 15:19:21 发布
最新推荐文章于 2024-11-01 15:19:21 发布
阅读量406 收藏 10
点赞数 5
分类专栏： 代码随想录学习笔记 文章标签： leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46531010/article/details/138205657
版权

目录

700.二叉搜索树的搜索

题目

代码（二叉搜索树迭代）

代码（二叉搜索树递归）

代码（普通二叉树递归）

代码（普通二叉树迭代）

98.验证二叉搜索树

题目

代码（中序递归得到中序序列）

代码（中序迭代得到中序序列）

代码（中序递归）

代码（中序迭代）

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

题目

代码（中序递归得到中序序列）

代码（中序迭代得到中序序列）

代码（中序迭代）

代码（中序递归）

700.二叉搜索树的搜索

题目

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

示例 1:

输入：root = [4,2,7,1,3], val = 2
输出：[2,1,3]

代码（二叉搜索树迭代）

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        while(root != null){
            //值相等，直接返回节点
            if(root.val == val){
                return root;
            }
            //target小，往左子树走
            else if(root.val > val){
                root = root.left;
            }
            //targer大，往右子树走
            else if(root.val < val){
                root = root.right;
            }
        }
        //最后root走到空，说明没找到
        return null;
    }
}

代码（二叉搜索树递归）

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        //终止条件
        if(root == null){
            return null;
        }
        if(root.val == val){
            return root;
        }

        //单层逻辑
        if(root.val > val){
            return searchBST(root.left,val);  //目标小，往左子树走
        }
        //这里要用else，不然报错没有返回值
        else{
            return searchBST(root.right,val); //目标大，往右子树走
        }
    }
}

代码（普通二叉树递归）

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        //终止条件
        if(root == null || root.val == val){
            return root;
        }

        //单层逻辑(前序遍历)
        TreeNode left = searchBST(root.left,val);
        TreeNode right = searchBST(root.right,val);
        if(left != null){
            return left;
        }
        else{
            return right;
        }
    }
}

代码（普通二叉树迭代）

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        Stack<TreeNode> stack = new Stack<>();
        if(root == null){
            return null;
        }
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode cur = stack.pop();;
            if(cur.val == val){
                return cur;
            }
            if(cur.right != null){
                stack.push(cur.right);
            }
            if(cur.left != null){
                stack.push(cur.left);
            }
        }
        return null;
    }
}

98.验证二叉搜索树

题目

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

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

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

示例 1：

输入：root = [2,1,3]
输出：true

代码（中序递归得到中序序列）

class Solution {
    public boolean isValidBST(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root == null){
            return true;
        }
        inOrder(root,list); //获取中序遍历序列list
        for(int i=1;i < list.size();i++){
            if(list.get(i) <= list.get(i-1)){  //判断list是否递增
                return false;
            }
        }
        //list递增，返回true
        return true;

    }
    //中序递归二叉树，list存储中序遍历序列
    public void inOrder(TreeNode root,List<Integer> list){
        //终止条件
        if(root == null){
            return;
        }
        //单层逻辑
        inOrder(root.left,list);  //递归左子树
        list.add(root.val); //处理中间节点
        inOrder(root.right,list); //递归右子树
    }
}

代码（中序迭代得到中序序列）

class Solution {
    public boolean isValidBST(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root == null){
            return true;
        }

        //中序迭代遍历得到中序序列
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            //cur非空，一直走到左子树最下
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            //cur为空，最左下节点出栈
             cur = stack.pop();  
             list.add(cur.val);
             cur = cur.right;
        }

        for(int i=1;i < list.size();i++){
            if(list.get(i) <= list.get(i-1)){  //判断list是否递增
                return false;
            }
        }
        //list递增，返回true
        return true;
    }
}

代码（中序递归）

class Solution {
    //核心是pre的设计，pre代表中序序列下root的前一个节点
    //判断中间节点root时，root必须大于pre的值
    TreeNode pre = null;  //pre初始化为空，之后就一直指向root的前一个中序节点
    public boolean isValidBST(TreeNode root) {
        //终止条件
        if(root == null){
            return true;
        }

        //单层逻辑
        boolean left = isValidBST(root.left);  //判断左子树是否满足

        //判断中间节点root是否比左子树的都大，pre是左子树最大节点
        if(pre != null && root.val <= pre.val){
            return false; 
        }
        pre = root;  //更新pre，指向中间节点
        
        boolean right = isValidBST(root.right);  //判断右子树是否满足
        return left && right;  //左右子树同时满足
    }
}

代码（中序迭代）

class Solution {
    //核心是pre的设计，pre代表中序序列下root的前一个节点
    //判断中间节点root时，root必须大于pre的值
    TreeNode pre = null;  //pre初始化为空，之后就一直指向root的前一个中序节点
    public boolean isValidBST(TreeNode root) {
        //终止条件
        if(root == null){
            return true;
        }

        //中序迭代
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        TreeNode pre = null;  //增加pre，指向root的前一个节点
        while(cur != null || !stack.isEmpty()){
            //cur非空一直往左子树走
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            //cur为空，最左下节点出栈
            cur = stack.pop();
            if(pre != null && pre.val >= cur.val){
                return false;
            }
            pre = cur;
            cur = cur.right;  //往右子树走
        }
        return true;
    }
}

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

题目

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

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

示例 1：

输入：root = [4,2,6,1,3]
输出：1

代码（中序递归得到中序序列）

class Solution {
    public int getMinimumDifference(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        inOrder(root,list);
        int min = Integer.MAX_VALUE;
        for(int i=1;i < list.size();i++){
            int abs = list.get(i) - list.get(i-1);
            if(abs < min){
                min = abs;
            }
        }
        return min;
    }
    //中序递归得到中序序列list
    public void inOrder(TreeNode root,List<Integer> list){
        if(root == null){
            return;
        }
        inOrder(root.left,list);
        list.add(root.val);
        inOrder(root.right,list);
    }
}

代码（中序迭代得到中序序列）

class Solution {
    public int getMinimumDifference(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        inOrder(root,list);
        int min = Integer.MAX_VALUE;
        for(int i=1;i < list.size();i++){
            int abs = list.get(i) - list.get(i-1);
            if(abs < min){
                min = abs;
            }
        }
        return min;
    }
    //中序遍历得到中序序列list
    public void inOrder(TreeNode root,List<Integer> list){
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.pop();
            list.add(cur.val);
            cur = cur.right;
        }
    }
}

代码（中序迭代）

class Solution {
    public int getMinimumDifference(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode pre = null;  //代表cur的前一个中序节点
        TreeNode cur = root;
        int result = Integer.MAX_VALUE;  //初始化最大值
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.pop();
            //更新最小值
            if(pre != null){
                int abs = cur.val - pre.val;
                if(abs < result){
                    result = abs;
                }
            }
            pre = cur;
            cur = cur.right;
        }
        return result;
    }
}

代码（中序递归）

class Solution {
    TreeNode pre = null;  //pre指向中序序列的前一个节点
    int result = Integer.MAX_VALUE;  //初始化result
    public int getMinimumDifference(TreeNode root) {
        //终止条件
        if(root == null){
            return result;
        }
        //单层逻辑
        result = getMinimumDifference(root.left);  //获取左边的最小值
        //获取中间节点的最小值
        if(pre != null){
            int abs = root.val - pre.val;
            if(abs < result){
                result = abs;
            }
        }
        pre = root;
        result = getMinimumDifference(root.right); //获取右边的最小值
        return result;
    }
}
守岁白驹hh
关注
专栏目录
代码随想录：全面解析二叉树理论与应用实例
09-17
内容概要：本文来自《代码随想录》，详尽探讨了有关二叉树的各类知识。包含了二叉树的种类（满二叉树、完全二叉树）、平衡树、遍历方式及其实现代码，涵盖了深度与广度两种不同的搜索策略以及非递归的方法。本文适用...
「代码随想录」二叉树专题精讲（v1.2）.pdf
12-14
"代码随想录二叉树专题精讲" 本资源是关于二叉树的专题讲解，涵盖了二叉树的基本概念、avl树、红黑树、堆、trie树等多种二叉树结构的实现和应用。 知识点一：二叉树的基本概念 二叉树是一种特殊的树状结构，它的每...
代码随想录：二叉树11-12
weixin_46531010的博客
04-19 1210
层序迭代和后序递归的核心逻辑很简单，就是用普通的遍历二叉树的方法，一边遍历一边计算节点数，即在原先的遍历代码中加上计算节点数的代码即可。时间复杂度是o(n)。满二叉树递归的核心逻辑，利用了满二叉树的性质，如果一个子树的满二叉树，从根节点往左和往右的最大深度是一样的。因此我们通过前序递归遍历二叉树，如果当前节点时满二叉树（终止条件），就可以直接计算节点数是2^depth-1，不用继续遍历其孩子节点。如果不是满二叉树（单层逻辑），就继续前序遍历下去，不是满二叉树的节点数=左子树节点+右子树节点+1。
代码随想录：二叉树25-28
weixin_46531010的博客
04-28 883
给你一个含重复值的二叉搜索树（BST）的根节点root，找出并返回 BST 中的所有（即，出现频率最高的元素）。如果树中有不止一个众数，可以按返回。[2]
代码随想录 -- 二叉树 -- 对称二叉树
weixin_56989647的博客
09-06 268
【代码】代码随想录 -- 二叉树 -- 对称二叉树。
代码随想录：二叉树
Hello_Hamburger的博客
08-20 735
代码随想录：二叉树（一）
代码随想录：二叉树概念和题目
weixin_45419660的博客
07-31 1076
int val;如何写递归算法的三要素：确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。确定单层递归的逻辑： 确定每一层递归需要处理的信息。
代码随想录 -- 二叉树 -- 平衡二叉树
weixin_56989647的博客
09-07 243
2. isBalanced 函数：如果传入根节点为空返回真；如果根节点 | 左子树的层数 - 右子树的层数 | 大于1，返回假；最后返回根节点左子树、右子树是否是平衡二叉树。1. 定义一个递归函数 count 用来计算二叉树的层数。思路：仍然是递归调用。
代码随想录 -- 二叉树 -- 合并二叉树
weixin_56989647的博客
09-12 168
令新节点的值为传入两个节点的值相加，调用递归函数。
代码随想录 -- 二叉树 -- 最大二叉树
weixin_56989647的博客
09-11 230
递归出口：当传入数组为空时，返回空。思路：（和前两道题很像）
代码随想录 -- 二叉树 -- 翻转二叉树
weixin_56989647的博客
09-05 271
【代码】代码随想录 -- 二叉树 -- 翻转二叉树。
代码随想录-- 二叉树 -- 路径总和
weixin_56989647的博客
09-10 404
【代码】代码随想录-- 二叉树 -- 路径总和。
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
《代码随想录》是一本深受程序员喜爱的编程学习资料，尤其在算法领域，它提供了丰富的实例和深入的解析，帮助读者理解并掌握动态规划、回溯、递归、二叉树以及贪心等核心算法。这些算法是解决复杂计算问题的基础工具...
【力扣 + 牛客 | SQL题 | 每日5题】牛客SQL热题216，217，223
2301_80912559的博客
10-30 957
你正在搭建一个用户活跃度的画像，其中一个与活跃度相关的特征是“最长连续登录天数”， 请用SQL实现“2023年1月1日-2023年1月31日用户最长的连续登录天数”一句话：两个记录的日期的差值如果等于两记录的排名差值，说明中间一直是连续的。使用join查询方式找出没有分类的电影id以及其电影名称。这不一眼窗口函数么。
【力扣专题栏】合并K个升序链表，3种解法讲解如何实现vector容器里面多个链表的合并？
2301_78704584的博客
10-30 344
解释：首先vector容器里面放有多个元素，每个元素是一个链表，每个链表含有0个或多个节点。当到达递归结束条件时，就开始往回归并。
Leetcode 62. 不同路径 动态规划+空间优化
最新发布
想买很多漂亮衣服但是买不起的博客
11-01 204
【代码】Leetcode 62. 不同路径 动态规划+空间优化。
力扣-最小覆盖子串
Dennis_nafla的博客
10-29 296
可以定义一个distance这样的int变量，当移动右指针后，如果此时右指针指向的字符在当前窗口中的个数严格小于t中所需要的个数，那么distance++。滑动窗口，初始时左右指针都指向s的第一个字符,对于每个遍历到的窗口，判断当前窗口是否包含了t中所需要的所有字符，不是的话就移动右指针，是的话就移动左指针。在移动左指针前,如果此时左指针指向的字符在当前窗口中的个数等于t中所需要的个数，那么distance--。给定一个字符串s,和目标字符串t，需要找出s中包含t中所有字符且长度最小子串，输出这个子串。
【Python3】【力扣题】409. 最长回文串
yannan20190313的博客
11-01 283
【Python3】【力扣题】409. 最长回文串
力扣——另一个的子树（C语言）
2401_83456040的博客
10-30 187
原理：这里调用前面比较两颗树是否相同的函数（小编之前文章里面有：相同的树），将节点与subRoot传入函数，向下递归，左右节点，只要找到一个返回true，说明存在子树，即最后返回true。具有相同结构和节点值的子树。的某个节点和这个节点的所有后代节点。也可以看做它自身的一棵子树。
代码随想录知识星球精华-大厂面试八股文v1.1.pdf
06-24
### 回答1： 《代码随想录知识星球精华-大厂面试八股文v1.1.pdf》是一份介绍八股文的面试指南，针对大厂面试常见题型进行分类，以及给出相应的解答思路。这份资料具有很高的参考价值，在为即将面试的求职者提供指引的同时，也可以让读者对八股文的思维框架和策略有更好的了解。 这份资料主要包括面试题目的主题分类，如动态规划、字符串、树等，每个分类下又相应给出了典型的问题，如“最长公共子序列”、“二叉树的层次遍历”等等。对于每个问题，都给出了具体的思路指导和代码模板，许多题目给出了多种不同的解法，这些解法包括时间复杂度和空间复杂度的优化。 这份资料对于求职者来说，意义重大。在面试中，对于某些问题我们可能没有完全解决，但如果有了这份资料，我们在面试中也会有一个清晰的思考框架和即时可用的代码模板。此外，这份资料同样适用于对算法和数据结构感兴趣的开发者和工程师，对于自学和提高都有帮助。 总之，《代码随想录知识星球精华-大厂面试八股文v1.1.pdf》是一个非常实用的参考材料，它是广大求职者和程序员不可或缺的工具，值得一读。 ### 回答2： 《代码随想录知识星球精华-大厂面试八股文v1.1.pdf》是一份由知名博主“代码随想”的知识星球推出的热门资料。该资料主要介绍了大厂面试中常见的八股文，包括但不限于动态规划、双指针、贪心算法、字符串操作等。 通过学习该资料，可以系统地学习和掌握各种常见的算法和数据结构，有助于提高自己的代码能力和面试竞争力。此外，资料还给出了一些实际的面试题目例子，对于准备去大厂面试的人来说，是一份非常实用的资料。 当然，要想真正掌握这些算法和数据结构，需要自己的不断练习和实践。只有在解决实际问题的过程中，才能真正体会到这些算法和数据结构的作用和优越性。 总之，该资料对于想要深入了解算法和数据结构、提高面试竞争力的人来说是一份值得推荐的优秀资料。 ### 回答3： 代码随想录知识星球精华-大厂面试八股文v1.1.pdf是一份关于大厂面试八股文的精华资料，它收集整理了各个大厂面试中常见的八股文题目和解题思路，对于准备求职或者升职的程序员来说是一份非常有价值的资料。 该资料中涵盖了常见的算法、数据结构、操作系统、计算机网络、数据库、设计模式等知识点，每个知识点都有详尽的讲解和相应的面试题目，可以帮助面试者全面了解每个知识点的考察方向和难点。 此外，该资料还提供了八股文的解题思路和解题方法，强调了实战经验和面试技巧，对于提高面试的成功率也是非常有帮助的。 总之，代码随想录知识星球精华-大厂面试八股文v1.1.pdf是一份非常实用的面试资料，它帮助面试者深入了解各个知识点的考察方向和难点，提高了应对面试的能力和成功率，对于准备求职或者升职的程序员来说是一份不可或缺的资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

守岁白驹hh

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

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

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

打赏作者

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

抵扣说明：

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

余额充值