精华内容
下载资源
问答
  • 二叉树的最大深度 题目描述: 给定一个二叉树,找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。题目链接 /** * Definition for a binary tree node. * public class TreeNode { * ...

    二叉树的最大深度

    题目描述:

    给定一个二叉树,找出其最大深度。
    二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

    题目链接

    /**
     * Definition for a binary tree node.
     * public class TreeNode {
     *     int val;
     *     TreeNode left;
     *     TreeNode right;
     *     TreeNode() {}
     *     TreeNode(int val) { this.val = val; }
     *     TreeNode(int val, TreeNode left, TreeNode right) {
     *         this.val = val;
     *         this.left = left;
     *         this.right = right;
     *     }
     * }
     */
    class Solution {
        int maxDepath;
        public int maxDepth(TreeNode root) {
            if(root == null) return 0;
            helper(root,0);
            return maxDepath;
        }
        private void helper(TreeNode root,int curDepath){
            if(root == null){
                if(curDepath > maxDepath) maxDepath = curDepath;
                return;
            }
            helper(root.left,curDepath+1);
            helper(root.right,curDepath+1);
        }
    }
    

    按照题意,递归即可,定义一个全局最大的深度的变量。详细请看代码,有疑问欢迎留言。

    展开全文
  • 题目 104:给定一个二叉树,找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。...使用函数递归的方法求二叉树的最大深度,如果根节点为空,那么深度为 0;如果根节点不为空,分...

    题目 104:给定一个二叉树,找出其最大深度。

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

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

    示例

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

      3
     / \
    9  20
      /  \
     15   7
    

    返回它的最大深度 3。

    函数递归

    使用函数递归的方法求二叉树的最大深度,如果根节点为空,那么深度为 0;如果根节点不为空,分别计算左子树和右子树的最大深度,比较左子树和右子树的最大深度,返回两者的最大值。

    函数递归的终止条件就是根节点为空,返回 0。如果只有一个根节点,那么深度应该为 1,也就是只要有节点最大深度至少为 1,这也是左子树的深度和右子树的深度都加 1的原因。

    具体的代码实现如下:

    /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     * };
     */
    class Solution {
    public:
        int maxDepth(TreeNode* root) {
            if (root == NULL)
                return 0;
            int l = maxDepth(root->left) + 1;
            int r = maxDepth(root->right) + 1;
            return l > r ? l : r;
        }
    };
    

    运行结果:

    alt 运行结果

    展开全文
  • 给定一个二叉树,找出其最大深度。 二叉树的深度为根节点到最...返回它的最大深度 3 。 先来说迭代,依然是用队列。 # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val...

    给定一个二叉树,找出其最大深度。
    二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
    说明: 叶子节点是指没有子节点的节点。
    示例:
    在这里插入图片描述
    返回它的最大深度 3 。
    先来说迭代,依然是用队列。

    # Definition for a binary tree node.
    # class TreeNode:
    #     def __init__(self, x):
    #         self.val = x
    #         self.left = None
    #         self.right = None
    from collections import deque
    class Solution:
        def maxDepth(self, root: TreeNode) -> int:
            que=deque()
            if not root:
                return 0
            elif not root.left and not root.right:
                return 1
            else:
                que.append([1,root])
            d=0
            while que:
                depth,p=que.popleft()
                if p:
                    que.append([depth+1,p.left])
                    que.append([depth+1,p.right])
                    d=max(d,depth)
            return d

    再来说递归

    # Definition for a binary tree node.
    # class TreeNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.left = None
    #         self.right = None
    class Solution(object):
        def find_depth(self,p1,p2,l1):
            if not p1 and not p2:
                return l1
            if not p1:
                l1+=1
                return self.find_depth(p2.left,p2.right,l1)
            elif not p2:
                l1+=1
                return self.find_depth(p1.left,p1.right,l1)
            else:
                l1+=1
                l2=self.find_depth(p1.left,p1.right,l1)
                l3=self.find_depth(p2.left,p2.right,l1)
                return max(l2,l3)
        def maxDepth(self, root):
            """
            :type root: TreeNode
            :rtype: int
            """
            if not root:
                return 0
            if not root.right and not root.left:
                return 1
            l1=l2=1
            while root:
                l1=self.find_depth(root.left,root.right,l1)
                l2=self.find_depth(root.left,root.right,l2)
                return max(l1,l2)
    展开全文
  • 给定一个二叉树,找出其最大深度二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例: 给定二叉树 [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 输出...

    给定一个二叉树,找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

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

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

        3
       / \
      9  20
        /  \
       15   7
       输出:3
    

    思路:递归(深度优先搜索)
    将左右结点传入递归函数,每次调用递归函数深度加1,遇到0时返回一个0
    时间复杂度:O(n)空间复杂度:O(n)

    /**
     * Definition for a binary tree node.
     * public class TreeNode {
     *     public int val;
     *     public TreeNode left;
     *     public TreeNode right;
     *     public TreeNode(int x) { val = x; }
     * }
     */
    public class Solution {
        public int MaxDepth(TreeNode root) 
        {
            if(root==null)
                return 0;
            return Math.Max(MaxDepth(root.left),MaxDepth(root.right))+1;
    
        }
    }
    

    在这里插入图片描述
    题目链接:https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/submissions/

    展开全文
  • 代码 public class TreeNode{ int val; TreeNode left; TreeNode right; TreeNode(int x){ val=x; } } if(root==null) return 0; int left_height=maxDepth(root.left);...是如何得到深度
  • @Leetcode二叉树的最大深度 又是一道二叉树结构的基础题,与之前的相同树和对称树有几分相似也有几分不同,请看题干: 给定一个二叉树,找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点...
  • 文章目录二叉树的最大深度题目描述具体代码1.递归写法2.精简版的递归写法3. 二叉树的最大深度 题目描述 输入一棵二叉树的根节点,求该树的深度。从根节点到叶节点依次经过的节点(含根、叶节点)形成树的一条路径,...
  • 104. 二叉树的最大深度 题目 给定一个二叉树,找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 递归 class Solution: def maxDepth(self, root:...
  • 问题描述: 给定一个二叉树,找出其最大深度。 二叉树的深度为根节点到最远叶子...返回它的最大深度 3 。 解答如下: class Solution { public int maxDepth(TreeNode root) { int leftDepth = 0; int rightDepth
  • 二叉树的最大深度 给定一个二叉树,找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 递归: class Solution { public: int maxDepth(TreeNode*...
  • 二叉树的最大深度 给定一个二叉树,找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例: 给定二叉树 [3,9,20,null,null,15,7], 3 / \ ...
  • 题目描述: 给定一个二叉树,找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的...返回它的最大深度 3 。 C++代码如下: /** * Definition for a binar...
  • 显然BFS可以直接解决,如果要用递归可以直接解决 class Solution { public: int maxDepth(TreeNode* root) { if(root==NULL) return 0; return max(maxDepth(root->left),maxDepth(root->...这里树最小高..
  • 给定一个二叉树,找出其最大深度二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 address # Definition for a binary tree node. class TreeNode: def __...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,469
精华内容 987
关键字:

leetcode二叉树的最大深度