Maximum Depth of Binary Tree 解答

Question

Given a binary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

Solution 1 -- Recursion

Recursion way is easy to think. Similar with "Minimum Depth of Binary Tree", time complexity is O(n).

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     int val;
 5  *     TreeNode left;
 6  *     TreeNode right;
 7  *     TreeNode(int x) { val = x; }
 8  * }
 9  */
10 public class Solution {
11     public int maxDepth(TreeNode root) {
12         if (root == null)
13             return 0;
14         return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
15     }
16 }

Solution 2 -- Iteration

BFS: We can still use level order traversal to get depth.

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     int val;
 5  *     TreeNode left;
 6  *     TreeNode right;
 7  *     TreeNode(int x) { val = x; }
 8  * }
 9  */
10 public class Solution {
11     public int maxDepth(TreeNode root) {
12         if (root == null)
13             return 0;
14         List<TreeNode> current = new ArrayList<TreeNode>();
15         current.add(root);
16         List<TreeNode> next;
17         int result = 1;
18         while (current.size() > 0) {
19             next = new ArrayList<TreeNode>();
20             for (TreeNode tmpNode : current) {
21                 if (tmpNode.left != null)
22                     next.add(tmpNode.left);
23                 if (tmpNode.right != null)
24                     next.add(tmpNode.right);
25             }
26             current = next;
27             result++;
28         }
29         return result - 1;
30     }
31 }

DFS: Traverse tree while recording level number.

 1 # Definition for a binary tree node.
 2 # class TreeNode:
 3 #     def __init__(self, x):
 4 #         self.val = x
 5 #         self.left = None
 6 #         self.right = None
 7 
 8 class Solution:
 9     def maxDepth(self, root: TreeNode) -> int:
10         if not root:
11             return 0
12         node_stack = [root]
13         value_stack = [1]
14         result = 1
15         while node_stack:
16             node = node_stack.pop()
17             value = value_stack.pop()
18             result = max(value, result)
19             if node.left:
20                 node_stack.append(node.left)
21                 value_stack.append(value + 1)
22             if node.right:
23                 node_stack.append(node.right)
24                 value_stack.append(value + 1)
25         return result