leetCode 树专题递归

最新推荐文章于 2022-09-27 15:14:17 发布

一名路过的小码农啊

最新推荐文章于 2022-09-27 15:14:17 发布

阅读量126

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/lovely_girl1126/article/details/104413613

版权

leetcode 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

3
/ \
9 20
/ \
15 7
返回它的最大深度 3 。

public int maxDepth(TreeNode root) {
        if(root==null)return 0;
        return Math.max(maxDepth(root.left),maxDepth(root.right));
    }

110. 平衡二叉树

难度简单231

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

返回 false 。

    private boolean result=true;
    public int maxDeptha(TreeNode root){
        if(root==null)return 0;
        int l=maxDeptha(root.left);
        int r=maxDeptha(root.right);
        if(Math.abs(l-r)>1)result=false;
        return 1+Math.max(l,r);
    }
    public boolean isBalanced(TreeNode root) {
        maxDeptha(root);
        return result;
    }

543. 二叉树的直径

给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过根结点。

示例 :
给定二叉树

1
/ \
2 3
/ \
4 5
返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。

注意：两结点之间的路径长度是以它们之间边的数目表示。

class Solution {
    private int max=0;
    public int depth(TreeNode root){
        if(root==null)return 0;
        int l=depth(root.left);
        int r=depth(root.right);
        max=Math.max(max,l+r);
        return Math.max(l,r)+1;
    }
    public int diameterOfBinaryTree(TreeNode root) {
        depth(root);
        return max;
    }
}

226. 翻转二叉树

翻转一棵二叉树。

示例：

输入：

4
/ \
2 7
/ \ / \
1 3 6 9
输出：

4
/ \
7 2
/ \ / \
9 6 3 1

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

617. 合并二叉树

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

示例 1:

输入:
   Tree 1 Tree 2
1 2
/ \ / \
3 2 1 3
/ \ \
5 4 7
输出:
合并后的树:
   3
   / \
   4 5
   / \ \
   5 4 7
注意: 合并必须从两个树的根节点开始。

  public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
        if(t1==null&&t2==null)return null;
        if(t1==null)return t2;
        if(t2==null)return t1;
        TreeNode res=new TreeNode(t1.val+t2.val);
        res.left=mergeTrees(t1.left,t2.left);
        res.right=mergeTrees(t1.right,t2.right);
        return res;
    }

112. 路径总和

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

示例:
给定如下二叉树，以及目标和 sum = 22，

5
/ \
4 8
/ / \
11 13 4
/ \ \
7 2 1
返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。


    public boolean hasPathSum(TreeNode root, int sum) {
        if(root==null)return false;
        if(root.left==null&&root.right==null&&root.val==sum)return true;
        return hasPathSum(root.left,sum-root.val)||hasPathSum(root.right,sum-root.val);
    }

437. 路径总和 III

给定一个二叉树，它的每个结点都存放着一个整数值。

找出路径和等于给定数值的路径总数。

路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。

示例：

root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8

10
/ \
5 -3
/ \ \
3 2 11
/ \ \
3 -2 1

返回 3。和等于 8 的路径有:

1. 5 -> 3
2. 5 -> 2 -> 1
3. -3 -> 11

    private int pathRootSum(TreeNode root,int sum){
        if(root==null)return 0;
        int ret=0;
        if(root.val==sum)ret++;
        ret+=pathRootSum(root.left,sum-root.val)+pathRootSum(root.right,sum-root.val);
        return ret;
    }
    public int pathSum(TreeNode root, int sum) {
       if(root==null)return 0;
       int ret=pathRootSum(root,sum)+pathSum(root.left,sum)+pathSum(root.right,sum);
       return ret;
    }

101. 对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

1
/ \
2 2
/ \ / \
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

1
/ \
2 2
\ \
3 3
说明:

如果你可以运用递归和迭代两种方法解决这个问题，会很加分。

public boolean isSymmetric(TreeNode root) {
        if(root==null)return true;
        return isSymmetric(root.left,root.right);
    }
    public boolean isSymmetric(TreeNode t1,TreeNode t2){
        if(t1==null&&t2==null)return true;
        if(t1==null||t2==null)return false;
        if(t1.val!=t2.val)return false;
        return isSymmetric(t1.left,t2.right)&&isSymmetric(t1.right,t2.left);
    }

111. 二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

示例:

给定二叉树 [3,9,20,null,null,15,7],

3
/ \
9 20
/ \
15 7
返回它的最小深度 2.

 public int minDepth(TreeNode root) {
        if(root==null)return 0;
        int left=minDepth(root.left);
        int right=minDepth(root.right);
        if(left==0||right==0)return left+right+1;
        return Math.min(left,right)+1;
    }

404. 左叶子之和

计算给定二叉树的所有左叶子之和。

示例：

3
/ \
9 20
/ \
15 7

在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

    public boolean isLeaf(TreeNode root){
        if(root==null)return false;
        return root.left==null&&root.right==null;
    }
    public int sumOfLeftLeaves(TreeNode root) {
        if(root==null)return 0;
        if(isLeaf(root.left))return root.left.val+sumOfLeftLeaves(root.right);
        return sumOfLeftLeaves(root.left)+sumOfLeftLeaves(root.right);
    }

687. 最长同值路径

给定一个二叉树，找到最长的路径，这个路径中的每个节点具有相同值。这条路径可以经过也可以不经过根节点。

注意：两个节点之间的路径长度由它们之间的边数表示。

示例 1:

输入:

5
/ \
4 5
/ \ \
1 1 5
输出:

2
示例 2:

输入:

1
/ \
4 5
/ \ \
4 4 5
输出:

    private int path=0;
    private int dfs(TreeNode root){
        if(root==null)return 0;
        int left=dfs(root.left);
        int right=dfs(root.right);
        int leftPath=root.left!=null&&root.left.val==root.val?left+1:0;
        int rightPath=root.right!=null&&root.right.val==root.val?right+1:0;
        path=Math.max(path,leftPath+rightPath);
        return Math.max(leftPath,rightPath);
    }
    public int longestUnivaluePath(TreeNode root) {
        dfs(root);
        return path;
    }

337. 打家劫舍 III

在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

示例 1:

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

3
/ \
2 3
\ \
3 1

输出: 7
解释: 小偷一晚能够盗取的最高金额 = 3 + 3 + 1 = 7.
示例 2:

输入: [3,4,5,1,3,null,1]

3
/ \
4 5
/ \ \
1 3 1

输出: 9
解释: 小偷一晚能够盗取的最高金额 = 4 + 5 = 9.

    public int rob(TreeNode root) {
        if(root==null)return 0;
        int val=root.val;
        if(root.left!=null)val+=rob(root.left.left)+rob(root.left.right);
        if(root.right!=null)val+=rob(root.right.left)+rob(root.right.right);
        int val2=rob(root.left)+rob(root.right);
        return Math.max(val,val2);
    }

671. 二叉树中第二小的节点

给定一个非空特殊的二叉树，每个节点都是正数，并且每个节点的子节点数量只能为 2 或 0。如果一个节点有两个子节点的话，那么这个节点的值不大于它的子节点的值。

给出这样的一个二叉树，你需要输出所有节点中的第二小的值。如果第二小的值不存在的话，输出 -1 。

示例 1:

输入:
2
/ \
2 5
/ \
5 7

输出: 5
说明: 最小的值是 2 ，第二小的值是 5 。
示例 2:

输入:
2
/ \
2 2

输出: -1
说明: 最小的值是 2, 但是不存在第二小的值。

    public int findSecondMinimumValue(TreeNode root) {
        if(root==null)return -1;
        if(root.left==null&&root.right==null)return -1;
        int leftval=root.left.val;
        int rightval=root.right.val;
        if(leftval==root.val)leftval=findSecondMinimumValue(root.left);
        if(rightval==root.val)rightval=findSecondMinimumValue(root.right);
        if(leftval!=-1&&rightval!=-1)return Math.min(leftval,rightval);
        if(leftval!=-1)return leftval;
        return rightval;
    }

一名路过的小码农啊

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
leetCode 树专题递归

104. 二叉树的最大深度给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明:叶子节点是指没有子节点的节点。示例：给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7返回它的最大深度3 。public int maxDepth(TreeN...
复制链接

扫一扫