二叉树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

相关文章
|
2月前
【每日一题Day222】LC1110删点成林 | dfs后序
【每日一题Day222】LC1110删点成林 | dfs后序
34 0
|
2月前
【每日一题Day335】LC1993树上的操作 | dfs
【每日一题Day335】LC1993树上的操作 | dfs
30 0
|
2月前
【每日一题Day214】LC1080根到叶路径上的不足节点 | 递归
【每日一题Day214】LC1080根到叶路径上的不足节点 | 递归
31 0
|
26天前
|
算法
二叉树LC总结(二)
二叉树LC总结(二)
|
20天前
|
PHP C++
LC59螺旋矩阵II
LC59螺旋矩阵II
8 0
|
2月前
【每日一题Day256】LC2600K 件物品的最大和
【每日一题Day256】LC2600K 件物品的最大和
31 2
|
2月前
|
算法
【每日一题Day235】LC1483树节点的第 K 个祖先 | 倍增
【每日一题Day235】LC1483树节点的第 K 个祖先 | 倍增
29 1
|
2月前
【每日一题Day295】LC617合并二叉树 | DFS BFS
【每日一题Day295】LC617合并二叉树 | DFS BFS
15 0
|
2月前
【每日一题Day318】LC1123最深叶节点的最近公共祖先 | dfs
【每日一题Day318】LC1123最深叶节点的最近公共祖先 | dfs
22 0
|
2月前
【每日一题Day309】LC823带因子的二叉树 | dp
【每日一题Day309】LC823带因子的二叉树 | dp
22 0