二叉树LC总结(一)

简介: 二叉树LC总结 (一)
  • 1.将有序数组转化为二叉搜索树:总是选择中间位置左边的数字作为根节点
  • 2.反转二叉树:判空,定义左右结点,交换左右子树
  • 3.对称二叉树:判空,比较左右结点,比较左右孩子,再比较左节点右孩子和右节点左孩子
  • 4.二叉树的直径:定义最大长度,最大深度递归
  • 5.二叉树的中序遍历:设置res存结果,Deque存储结点,先左后右,出栈
  • 6.二叉树的最大深度:判空,遍历左右子树的最大深度
  • 7.二叉树的层序遍历:Deque存树节点,res存最终结果,tmp存每层节点
  • 8.验证二叉搜索树:设置最大、最小两个变量,每个根节点小于右子树,大于左子树
  • 9.二叉树展开为链表:判空,若左子树为空,直接将右子树展开,否则,展开左右子树,设置TreeNode 值存之前根节点的右子树,设置变量循环,找到左子树的最右节点,分别挂载
  • 10.从前序与中序遍历序列构造二叉树:前序第一个节点是根结点,中序定位根节点,递归
  • 11.二叉搜索树中第K小的元素:设置Deque栈,判空,循环
  • 12.二叉树的右视图:设置RES,dfs(root,0)

1.将有序数组转化为二叉搜索树

给你一个整数数组 nums ,其中元素已经按 升序 排列,请你将其转换为一棵 平衡 二叉搜索树。


输入:nums = [-10,-3,0,5,9]

输出:[0,-3,9,-10,null,5]

解释:[0,-10,5,null,-3,null,9] 也将被视为正确答案:

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return helper(nums, 0, nums.length - 1);
    }
    public TreeNode helper(int[] nums, int left, int right) {
        if (left > right) {
            return null;
        }
        // 总是选择中间位置左边的数字作为根节点
        int mid = (left + right) / 2;
        TreeNode root = new TreeNode(nums[mid]);
        root.left = helper(nums, left, mid - 1);
        root.right = helper(nums, mid + 1, right);
        return root;
    }
}
————————————————

                            版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
                        
原文链接:https://blog.csdn.net/m0_60469045/article/details/136693632

2.反转二叉树:

给你一棵二叉树的根节点 root ,翻转这棵二叉树,并返回其根节点。

输入:root = [4,2,7,1,3,6,9]

输出:[4,7,2,9,6,3,1]

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        TreeNode left = invertTree(root.left);
        TreeNode right = invertTree(root.right);
        root.left = right;
        root.right = left;
        return root;
    }
}
————————————————

                            版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
                        
原文链接:https://blog.csdn.net/m0_60469045/article/details/136693632

3.对称二叉树:

给你一个二叉树的根节点 root , 检查它是否轴对称。

输入:root = [1,2,2,3,4,4,3]

输出:true

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root==null) {
        return true;
        }
        //调用递归函数,比较左节点,右节点
        return dfs(root.left,root.right);
    }
    boolean dfs(TreeNode left, TreeNode right) {
        //递归的终止条件是两个节点都为空
        //或者两个节点中有一个为空
        //或者两个节点的值不相等
        if(left==null && right==null) {
            return true;
        }
        if(left==null || right==null) {
            return false;
        }
        if(left.val!=right.val) {
            return false;
        }
        //再递归的比较 左节点的左孩子 和 右节点的右孩子
        //以及比较  左节点的右孩子 和 右节点的左孩子
        return dfs(left.left,right.right) && dfs(left.right,right.left);
    }
}
————————————————

                            版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
                        
原文链接:https://blog.csdn.net/m0_60469045/article/details/136693632

4.二叉树的直径:

给你一棵二叉树的根节点,返回该树的 直径

二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root

两节点之间路径的 长度 由它们之间边数表示

输入:root = [1,2,3,4,5]

输出:3

解释:3 ,取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。

class Solution {
    int maxDiameter = 0;
    public int diameterOfBinaryTree(TreeNode root) {
        maxDepth(root);
        return maxDiameter;
    }
    int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int LeftMax = maxDepth(root.left);
        int rightMax = maxDepth(root.right);
        int myDiameter = LeftMax + rightMax;
        maxDiameter= Math.max(maxDiameter, myDiameter);
        return Math.max(LeftMax, rightMax) + 1;
    }
}
————————————————

                            版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
                        
原文链接:https://blog.csdn.net/m0_60469045/article/details/136693632

5.二叉树的中序遍历:

给定一个二叉树的根节点 root ,返回 它的 中序 遍历

输入:root = [1,null,2,3]

输出:[1,3,2

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
     //将所有节点的值存入res中
     List<Integer> res=new ArrayList<Integer>();
     //建立一个双端队列
     Deque<TreeNode> dl = new LinkedList<TreeNode>();
     //判断根节点是否为空或者队列是否为空
     while(root != null || !dl.isEmpty()){
         while(root != null){
             dl.push(root); //将当前节点压入
             root = root.left; //遍历左子树
         }
         root = dl.pop(); //出栈
         res.add(root.val);//将值加入res中
         root = root.right;//迭代右子树
     }
     return res;
    }
}
————————————————

                            版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
                        
原文链接:https://blog.csdn.net/m0_60469045/article/details/136693632

6.二叉树的最大深度:

给定一个二叉树 root ,返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数

输入:root = [3,9,20,null,null,15,7]

输出:3

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        int LeftDepth =  maxDepth(root.left);
        int RightDepth = maxDepth(root.right);
        int res = Math.max(LeftDepth,RightDepth) + 1;
        return res;
    }
}
————————————————

                            版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
                        
原文链接:https://blog.csdn.net/m0_60469045/article/details/136693632

二叉树LC总结(二):https://developer.aliyun.com/article/1534447

相关文章
|
数据库 SQL Cloud Native
DBA福利:云原生分布式数据库 PolarDB-X 操作指南
【6月更文挑战第2天】简述如何使用PXD工具一键安装PolarDB-X操作
72590 10
|
关系型数据库 MySQL Shell
CMake构建Makefile深度解析:从底层原理到复杂项目(三)
CMake构建Makefile深度解析:从底层原理到复杂项目
469 0
|
SQL 缓存 Java
MyBatis原理分析之获取SqlSessionFactory
MyBatis原理分析之获取SqlSessionFactory
603 0
|
Kubernetes API 索引
|
JSON 缓存 Java
优雅至极!Spring Boot 3.3 中 ObjectMapper 的最佳实践
【10月更文挑战第5天】在Spring Boot的开发中,ObjectMapper作为Jackson框架的核心组件,扮演着处理JSON格式数据的核心角色。它不仅能够将Java对象与JSON字符串进行相互转换,还支持复杂的Java类型,如泛型、嵌套对象、集合等。在Spring Boot 3.3中,通过优雅地配置和使用ObjectMapper,我们可以更加高效地处理JSON数据,提升开发效率和代码质量。本文将从ObjectMapper的基本功能、配置方法、最佳实践以及性能优化等方面进行详细探讨。
1045 2
|
缓存 前端开发 JavaScript
构建高性能与用户体验并重的现代Web应用
构建高性能与用户体验并重的现代Web应用
149 5
|
存储 Java 调度
Android面试题之Kotlin协程到底是什么?它是线程吗?
本文探讨了协程与线程的区别,指出协程并非线程,而是轻量级的线程替代。协程轻量体现在它们共享调用栈,内存占用少,仅需几个KB。协程切换发生在用户态,避免了昂贵的内核态切换。在Kotlin中,协程通过Continuation对象实现上下文保存,允许高效并发执行,而不会像线程那样消耗大量资源。通过`runBlocking`和`launch`示例展示了协程的非阻塞挂起特性。总结来说,协程的轻量主要源于内存占用少、切换开销低和高并发能力。
491 0
|
Java 编译器 程序员
C++中的语法知识虚继承和虚基类
**C++中的多继承可能导致命名冲突和数据冗余,尤其在菱形继承中。为解决这一问题,C++引入了虚继承(virtual inheritance),确保派生类只保留虚基类的一份实例,消除二义性。虚继承通过`virtual`关键字指定,允许明确访问特定路径上的成员,如`B::m_a`或`C::m_a`。这样,即使基类在继承链中多次出现,也只有一份成员副本,简化了内存布局并避免冲突。虚继承应在需要时提前在继承声明中指定,影响到从虚基类派生的所有后代类。**
254 7
|
小程序
小程序如何刷新当前页面
小程序如何刷新当前页面
645 0
|
机器学习/深度学习 测试技术
LLM-Blender:大语言模型也可以进行集成学习
最近在看arxiv的时候发现了一个有意思的框架:LLM-Blender,它可以使用Ensemble 的方法来对大语言模型进行集成。
617 0