【LeetCode刷题-简单】104. 二叉树的最大深度（python c++）

题目

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

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

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

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

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

 

思路

由于树是一种递归的数据结构，因此用递归去解决的时候往往非常容易，这道题恰巧也是如此， 用递归实现的代码如下：

var maxDepth = function(root) {
  if (!root) return 0;
  if (!root.left && !root.right) return 1;
  return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
};

如果使用迭代呢？ 我们首先应该想到的是树的各种遍历，由于我们求的是深度，因此 使用层次遍历（BFS）是非常合适的。 我们只需要记录有多少层即可。相关思路请查看binary-tree-traversal

 

迭代关键点解析

• 队列
• 队列中用 Null(一个特殊元素)来划分每层，或者在对每层进行迭代之前保存当前队列元素的个数（即当前层所含元素个数）
• 树的基本操作- 遍历 - 层次遍历（BFS）

 

迭代

复杂度分析

• 时间复杂度：O(N)。
• 空间复杂度：O(N)。

Python

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root : return 0
        tmp = [root, None]
        depth = 1
        while tmp:
            t = tmp.pop(0)
            if t:
                if t.left : tmp.append(t.left)
                if t.right: tmp.append(t.right)
            elif tmp:
                tmp.append(None)
                depth += 1
        return depth

 

C++

/**
 * 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 == nullptr) return 0;
        auto tmp = vector<TreeNode*>();
        auto d = 0;
        tmp.push_back(root);
        while(!tmp.empty()){
            ++d;
            auto size = tmp.size();
            for(auto i=0; i<size; ++i){
                auto t = tmp.front();
                tmp.erase(tmp.begin());
                if(t->left != nullptr) tmp.push_back(t->left);
                if(t->right!= nullptr) tmp.push_back(t->right);
            }
        }
        return d;
    }
};

 

递归

DFS可能会爆栈，BFS可以避免。

复杂度分析

• 时间复杂度：我们每个结点只访问一次，因此时间复杂度为 O(N)，其中 N 是结点的数量。
• 空间复杂度：在最糟糕的情况下，树是完全不平衡的，例如每个结点只剩下左子结点，递归将会被调用 N 次（树的高度），因此保持调用栈的存储将是 O(N)。但在最好的情况下（树是完全平衡的），树的高度将是log(N)。因此，在这种情况下的空间复杂度将是 O(log(N))。

Python

class Solution:
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """ 
        if root is None: 
            return 0 
        else: 
            left_height = self.maxDepth(root.left) 
            right_height = self.maxDepth(root.right) 
            return max(left_height, right_height) + 1 

 

C++

/**
 * 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 dfs(TreeNode* root, int max_dept) {
        if(!root) return max_dept;
        int left_dept = dfs(root->left, max_dept+1);
        int right_dept = dfs(root->right, max_dept+1);
        return max(left_dept, right_dept);
    } 

    int maxDepth(TreeNode* root) {
        int max_dept = 0;
        return  dfs(root, max_dept);
    }
};