YOLO 普通 2024年3月21日上午10:56

 /*输入一棵二叉树的根节点，求该树的深度。
 从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。
  */
class Solution {
    public int calculateDepth(TreeNode root) {
        if(root == null)
            return 0;
        int left = calculateDepth(root.left);
        int right = calculateDepth(root.right);

        return Math.max(left,right)+1;

    }
}

0 赞同 0 条回复

kfaebot 普通 2024年3月13日下午9:07

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    //步骤1：定义返回值和参数
    int backtrack(TreeNode* node){
        //步骤2：定义终止条件
        if(node==nullptr){
            return 0;
        }

        //步骤3：定义遍历过程
        //二叉树根节点的最大高度就是二叉树的深度，使用后序遍历（左右中）
        int left=backtrack(node->left);
        int right=backtrack(node->right);
        int depth=max(left,right)+1; //加1算上当前的中间节点
        return depth;
    }
    int calculateDepth(TreeNode* root) {
        return backtrack(root);
    }
};
//时间复杂度O(N)
//空间复杂度O(N)

0 赞同 0 条回复

RunAsOne 普通 2024年3月12日下午12:37

第n次打卡

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def calculateDepth(self, root):
        """
        :type root: Optional[TreeNode]
        :rtype: int
        """
        if not root:
            return 0
        left = self.calculateDepth(root.left)
        right = self.calculateDepth(root.right)
        return max(left, right) + 1

0 赞同 0 条回复

HU 普通 2024年3月12日上午9:27

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var calculateDepth = function(root) {
    // 1. calculateDepth函数的功能是计算root的深度

    // 2. 定义结束条件
    if(root == null) return 0;

    // 3. 定义递归关系式
    return Math.max(calculateDepth(root.left), calculateDepth(root.right)) + 1;
};

0 赞同 0 条回复

e=mc² 普通 2024年3月11日下午2:35

class Solution {
    public int calculateDepth(TreeNode root) {
        return root == null ? 0 : Math.max(calculateDepth(root.left), calculateDepth(root.right)) + 1;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

0 赞同 0 条回复

MARS 普通 2024年3月10日下午11:30

day6第一题

function calculateDepth(root: TreeNode | null): number {
    if(root===null) return 0    

    let leftDepth = calculateDepth(root.left)
    let rightDepth = calculateDepth(root.right)

    return Math.max(leftDepth,rightDepth)+1
};

0 赞同 0 条回复

普通 2024年3月10日下午2:35

class Solution {
public:
int calculateDepth(TreeNode* root) {
if(rootnullptr) return 0;

    int left = calculateDepth(root->left);
    int right = calculateDepth(root->right);

    return max(left,right)+1;
 }

};
打卡

0 赞同 0 条回复

零普通 2024年3月9日下午9:25

思路：递归左右子树深度，当前节点深度等于左右子树的大的
代码：


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

0 赞同 0 条回复

helloMoon 普通 2024年3月9日下午9:10

二叉树的深度java

/**
 * 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 {
    public int calculateDepth(TreeNode root) {
        if(root == null) return 0;
        int left = calculateDepth(root.left);
        int right = calculateDepth(root.right);

        return Math.max(left, right) + 1;
    }
}

0 赞同 0 条回复

=.= 普通 2024年3月9日下午6:25

/**
* 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 {
public int calculateDepth(TreeNode root) {
if(root null) return 0;

    int left = calculateDepth(root.left);
    int right = calculateDepth(root.right);

    return Math.max(left, right) + 1;
}

}

时间复杂度O(n)
空间复杂度O(n)

0 赞同 0 条回复

方铎码农普通 2024年3月9日上午11:44

class Solution {
    public int calculateDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        int leftDepth = calculateDepth(root.left);
        int rightDepth = calculateDepth(root.right);
        return Math.max(leftDepth,rightDepth)+1;
    }
}

时间复杂度$O(n)$，空间复杂度$O(n)$

0 赞同 0 条回复

mpweixin用户普通 2024年3月9日上午11:30

时间复杂度O(N)，空间复杂度O(N)
class Solution {
public:
int calculateDepth(TreeNode* root) {
int val=1;
if(!root)
return 0;
if(root->leftnullptr && root->rightnullptr)
return val;
int val1=1,val2=1;
if(root->left!=nullptr) val1+=calculateDepth(root->left);
if(root->right!=nullptr) val2+=calculateDepth(root->right);
return (val1>val2)?val1:val2;
}
};

0 赞同 0 条回复

东普通 2024年3月8日下午7:39

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        //树形递归
        int left = maxDepth(root.left);
        int right = maxDepth(root.right);
        return Math.max(left,right) + 1;
    }
}

0 赞同 0 条回复

ChenZhangHangTime 永久会员 2024年3月8日下午2:22

二叉树的深度
class Solution{
public int calculateDepth(TreeNode root){
if(root null) return 0;
return Math.max(calculateDepth(root.left),calculateDepth(root.right)) + 1;
}
}

0 赞同 0 条回复

一个达不刘普通 2024年3月8日上午10:51

class Solution {
public:
//后序遍历
int calculateDepth(TreeNode* root) {
if(root nullptr){
return 0;
}
int left = calculateDepth(root->left);//左子树高度
int right = calculateDepth(root->right);
if(left > right) {
return left+1;
}else{
return right +1;
}

};
时间复杂度：O(n)；空间复杂度O(n)

0 赞同 0 条回复

神经蛙普通 2024年3月7日下午11:56

/
class Solution {
public:
int calculateDepth(TreeNode root) {
if(nullptr root) return 0;
int left = calculateDepth(root->left);
int right = calculateDepth(root->right);
return max(left,right) + 1;
}
};
时间复杂度：O(n)；空间复杂度O(n)

0 赞同 0 条回复

mpweixin用户普通 2024年3月7日下午10:10

java
class Solution{
public int calculateDepth(TreeNode root){
if(root null) return 0;
return Math.max(calculateDepth(root.left),calculateDepth(root.right)) + 1;
}
}
时间复杂度 O(N)
空间复杂度 O(N)

0 赞同 0 条回复

heathhou 普通 2024年3月7日下午9:01

class Solution {
public:
    // 递归函数：求二叉树的高度
    int calculateDepth(TreeNode* root) {
        // 递归函数的结束条件
        if(root == nullptr){
            return 0;
        }else if(root->left == nullptr && root->right == nullptr){
            return 1;
        }
        // 递归函数的等价关系式
        int num1 = calculateDepth(root->left);
        int num2 = calculateDepth(root->right);
        return max(num1, num2) + 1;
    }
};

0 赞同 0 条回复

土豆丝（知足常乐版）普通 2024年3月7日下午8:09

递归法，时间复杂度O(n)，空间复杂度O(n)

public int calculateDepth(TreeNode root) {
        if(root <span class="text-highlighted-inline" style="background-color: #fffd38;"> null){
            return 0;
        }
        return Math.max(calculateDepth(root.left), calculateDepth(root.right)) + 1;
    }

0 赞同 0 条回复

Jimmy 普通 2024年3月7日下午7:34

递归法，时间复杂度O(n)，空间复杂度O(n)

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

0 赞同 0 条回复

　南木普通 2024年3月7日下午6:42

递归深搜，时间复杂度 O(n)，空间复杂度 O(n)

/**
 * 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 {
    public int calculateDepth(TreeNode root) {
        if(root == null)
            return 0;
        int max_l = calculateDepth(root.left);
        int max_r = calculateDepth(root.right);
        return Math.max(max_l,max_r) + 1;
    }
}

0 赞同 0 条回复

叫不醒装睡的人普通 2024年3月7日下午5:32

class Solution {
    // 计算二叉树的深度需要对每一层都进行遍历
    // 采用递归思想
    // 当本层级为 null 时返回 0
    // 一整个大的二叉树可以分解成多个小二叉树，小二叉树又能分解成每个元素
    public int calculateDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        return Math.max(calculateDepth(root.left), calculateDepth(root.right)) + 1;
    }
    // 时间复杂度 O(n)
    // 空间复杂度 O(n) 最好情况是只有一层 O(1) 最坏情况是二叉树退化成链表 O(n)
}

0 赞同 0 条回复

云无深雁影普通 2024年3月7日下午4:30

class Solution {
public int calculateDepth(TreeNode root) {
if(root null)
return 0;
else
return(Math.max(calculateDepth(root.left),calculateDepth(root.right))+1);

}
//递归时空复杂度均为On

0 赞同 0 条回复

mpweixin用户普通 2024年3月7日上午10:46

public int calculateDepth(TreeNode root) {
if(rootnull) return 0;
return Math.max(calculateDepth(root.left),calculateDepth(root.right))+1;
}
思路：二叉树的深度=左右子树的深度+1 递归即可

0 赞同 0 条回复

Yuki 永久会员 2024年3月7日上午10:26

打卡
https://leetcode.cn/problems/er-cha-shu-de-shen-du-lcof/solutions/2672345/ceng-xu-bian-li-ji-suan-er-cha-shu-shen-b2idc

0 赞同 0 条回复

Thaddeus 永久会员 2024年3月7日上午9:19

打卡

class Solution {
public:
    int calculateDepth(TreeNode* root) {
        if(!root) return 0;
        return max(calculateDepth(root->left), calculateDepth(root->right)) + 1;
    }
};

0 赞同 0 条回复

紫芝普通 2024年3月7日上午8:57

思路：使用队列记录每一层的非空节点，然后逐层遍历

“`c++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int calculateDepth(TreeNode* root) {
if (root == nullptr) return 0;
queue que;
que.push(root);
int res = 0;
while (!que.empty()) {
int size = que.size();
while (size–) {
TreeNode* cur = que.front();
que.pop();
if (cur->left) que.push(cur->left);
if (cur->right) que.push(cur->right);
}
res++;
}
return res;
}
};
“`

0 赞同 0 条回复

Yox 普通 2024年3月7日上午3:35

Definition for a binary tree node.

class TreeNode:

def init(self, val=0, left=None, right=None):

self.val = val

self.left = left

self.right = right

class Solution:
def calculateDepth(self, root: Optional[TreeNode]) -> int:
if not root:
return 0
return max(self.calculateDepth(root.left),self.calculateDepth(root.right))+1

        双 o n

0 赞同 0 条回复

南梁陈庆之普通 2024年3月7日上午12:52

/**
 * 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 max = 0;
    public int calculateDepth(TreeNode root) {
        if (root == null) {
            return 0;
        } 
        int leftHight = calculateDepth(root.left);
        int rightHight = calculateDepth(root.right);
        return Math.max(leftHight, rightHight) + 1;

    }



}

时间复杂度O（N）
空间复杂度O（N）
后续遍历二叉树

0 赞同 0 条回复

进取普通 2024年3月6日下午11:33

class Solution {
public:
int calculateDepth(TreeNode* root) {
if (root nullptr) return 0;
return max(calculateDepth(root->left), calculateDepth(root->right)) + 1;
}
};后序遍历，时空复杂度O(N)

0 赞同 0 条回复

NULL 普通 2024年3月6日下午11:27

class Solution {
public int calculateDepth(TreeNode root) {
if(root null) return 0; // 递归出口
return Math.max(calculateDepth(root.left),calculateDepth(root.right)) + 1;
}
}

0 赞同 0 条回复

机电皮怪永久会员 2024年3月6日下午11:25

时间复杂度O(n)
空间复杂度O(n)

“`C++
class Solution {
public:
int calculateDepth(TreeNode* root) {
if (root == nullptr)
{
return 0;
}

    int res1 = calculateDepth(root->left) + 1;
    int res2 = calculateDepth(root->right) + 1;
    return res1 > res2 ? res1 : res2;
}

};

“`

0 赞同 0 条回复

莫～慢～待普通 2024年3月6日下午11:15

class Solution {
public int calculateDepth(TreeNode root) {
if(rootnull)
return 0;
return 1+Math.max(calculateDepth(root.left),calculateDepth(root.right));
}
}
时间复杂度O(n)

0 赞同 0 条回复

Raphtalia. 普通 2024年3月6日下午10:51

class Solution {
public:
int calculateDepth(TreeNode* root) {
if(root nullptr) return 0;
return 1 + max(calculateDepth(root->left),calculateDepth(root->right));
}
};
时间O（n），空间O（logn）

0 赞同 0 条回复

白雪公主倒拔垂杨柳永久会员 2024年3月6日下午9:21

class Solution {
    public int calculateDepth(TreeNode root) {
        if(root==null) return 0;
        if(root!=null && root.left==null && root.right==null) return 1; //其实这行可去掉

        return Math.max(calculateDepth(root.left),calculateDepth(root.right))+1;
    }
}

0 赞同 0 条回复

Free 普通 2024年3月6日下午9:07

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution 
{
public:
    int calculateDepth(TreeNode* root) 
    {
        if(root == nullptr)
            return 0;
        int leftdepth = calculateDepth(root->left) + 1;
        int rightdepth = calculateDepth(root->right) + 1;
        return max(leftdepth, rightdepth);
    }
};

时空复杂度：O(n)

0 赞同 0 条回复

言之命至普通 2024年3月6日下午8:13

class Solution {
    public int calculateDepth(TreeNode root) {
   if(root == null) return 0;
        int left = calculateDepth(root.left);
        int right = calculateDepth(root.right);

        return Math.max(left, right) + 1;
    }
}

递归的方式做，时空复杂度：O(n)

0 赞同 0 条回复

王位詮釋普通 2024年3月6日下午8:11

class Solution {
    int depth = 0;
    public int calculateDepth(TreeNode root) {
        if(root==null){
            return 0;
        }
        int leftDepth = calculateDepth(root.left);
        int rightDepth = calculateDepth(root.right);
        return leftDepth>rightDepth?leftDepth+1:rightDepth+1;
    }
}
思路：树是一个递归类型的数据结构，所以树的深度=子树的深度(左右子树谁更深就是谁)+1；因此递归调用方法，获取子树的高度，然后进行左右子树的高度对比，谁深就返回谁，如果某一颗子树为空，那这个子树的深度就为0；
空间复杂度：主要是递归深度，O(length)

0 赞同 0 条回复

【二叉树专题】剑指 Offer 55 – I. 二叉树的深度

共以下 38 个回答

Definition for a binary tree node.

class TreeNode:

def init(self, val=0, left=None, right=None):

self.val = val

self.left = left

self.right = right

# 回答此问题取消回复

【二叉树专题】剑指 Offer 55 – I. 二叉树的深度

共以下 38 个回答

Definition for a binary tree node.

class TreeNode:

def init(self, val=0, left=None, right=None):

self.val = val

self.left = left

self.right = right

# 回答此问题 取消回复

# 回答此问题取消回复