LeetCode： 104. 二叉树的最大深度（包含递归模板）

104. 二叉树的最大深度

  

给定一个二叉树 root ，返回其最大深度。

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

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：3

示例 2：

输入：root = [1,null,2]
输出：2

提示：

• 树中节点的数量在 [0, 104] 区间内。
• -100 <= Node.val <= 100

时间复杂度： O(N)
每个结点只访问一次，因此时间复杂度为 O(N)，其中 N 是结点数。

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

思路：

参考 LeetCode题解

解法1 递归（dfs）：

1. 添加终结条件，空节点深度为0
2. 左子树深度 +1
3. 右子树深度 +1
4. 返回左或右中的较大者

解法2 迭代（bfs）：

1. 每遍历一层，则计数器 +1 ，直到遍历完成，则可得到树的深度。

Go版本：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

// 解法1 dfs（递归）
func maxDepth(root *TreeNode) int {
    if root == nil {
        return 0 // 节点不存在，返回 深度=0
    }

    l := maxDepth(root.Left)    // 向左边递归得到的深度
    r := maxDepth(root.Right)   // 向右边递归得到的深度

    return max(l, r) + 1        // 比较并返回最大深度
}

func max(a, b int) int {
    if a > b {
        return a
    }

    return b
}

// 解法2 bfs（迭代）：利用队列"先进先出"的性质
func maxDepth(root *TreeNode) int {
    if root == nil {
        return 0
    }

    res := 0
    queue := make([]*TreeNode, 0)
    queue = append(queue, root)

    for len(queue) > 0 {
        // 保留上一层节点数，避免内存循环因为对queue进行append操作，导致n值变化
        n := len(queue)
        
        for i := 0; i < n; i++ {
            root = queue[0]     // get front node value
            queue = queue[1:]   // pop
        
            if root.Left != nil {
                queue = append(queue, root.Left)
            }
            if root.Right != nil {
                queue = append(queue, root.Right)
            }
        }
        res++
    }

    return res
}

C++版本：

int maxDepth(TreeNode* root) {
        // 1.递归终结条件
        if (root == NULL)
            return 0;
        // 2.处理当前层逻辑
        int l = maxDepth(root->left) + 1;   // 向左边递归得到的深度
        int r = maxDepth(root->right) + 1;  // 向右边递归得到的深度
        // 3.下探到下一层
        return l > r ? l : r;               // 比较并返回最大深度
}

另外，这道题使用递归的解题方法步骤如下图（按这4步来熟悉递归的过程）：

方法2 迭代（BFS，利用队列）：

int maxDepth(TreeNode* root)
{
	int sum = 0;
	queue<TreeNode*> q;
	q.push(root);
	while (!q.empty())
	{
		for (int i = 0; i < q.size(); i++)	// size：上一层节点个数
		{
			root = q.front();
			//cout << root->data << endl;
			q.pop();

			if (root->left != NULL)
				q.push(root->left);
			if (root->right != NULL)
				q.push(root->right);
		}
		sum++;
	}

	return sum;
}