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).

 /**
  * Definition for a binary tree node.
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
  *     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;
     }
 }

Solution 2 -- Iteration

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

 /**
  * Definition for a binary tree node.
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
  *     TreeNode(int x) { val = x; }
  * }
  */
 public class Solution {
     public int maxDepth(TreeNode root) {
         if (root == null)
             return 0;
         List<TreeNode> current = new ArrayList<TreeNode>();
         current.add(root);
         List<TreeNode> next;
         int result = 1;
         while (current.size() > 0) {
             next = new ArrayList<TreeNode>();
             for (TreeNode tmpNode : current) {
                 if (tmpNode.left != null)
                     next.add(tmpNode.left);
                 if (tmpNode.right != null)
                     next.add(tmpNode.right);
             }
             current = next;
             result++;
         }
         return result - 1;
     }
 }

DFS: Traverse tree while recording level number.

 # 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
         node_stack = [root]
         value_stack = [1]
         result = 1
         while node_stack:
             node = node_stack.pop()
             value = value_stack.pop()
             result = max(value, result)
             if node.left:
                 node_stack.append(node.left)
                 value_stack.append(value + 1)
             if node.right:
                 node_stack.append(node.right)
                 value_stack.append(value + 1)
         return result