LeetCode 111. Minimum Depth of Binary Tree

Description

https://leetcode.com/problems/minimum-depth-of-binary-tree/

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

Note: A leaf is a node with no children.

Example 1:

Input: root = [3,9,20,null,null,15,7]
Output: 2

Example 2:

Input: root = [2,null,3,null,4,null,5,null,6]
Output: 5

Constraints:

  • The number of nodes in the tree is in the rangeĀ [0, 105].
  • -1000 <= Node.val <= 1000

Explanation

Use findMinDepth() as helper function.

If the tree is null, the minimum depth would be 0.

If the tree has only the root node, the minimum depth would be 1.

For normal case,  findMinDepth() takes the minimum depth between left and right subtree of the node and plus 1.

Java Solution

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        
        return findMinDepth(root);
    }
    
    private int findMinDepth(TreeNode root) {
        if (root == null) {
            return Integer.MAX_VALUE;
        }
                
        if (root.left == null && root.right == null) {
            return 1;
        }
        
        return Math.min(findMinDepth(root.left), findMinDepth(root.right)) + 1;
    }
}

Python Solution

# 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 minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        
        self.min_depth = sys.maxsize
        
        self.helper(root, 0)
        
        return self.min_depth
        
    def helper(self, root, depth):
        if not root:
            return 0
        
        
        depth += 1
        
        if not root.left and not root.right:            
            self.min_depth = min(self.min_depth, depth)
            return
        
        self.helper(root.left, depth)
        
        self.helper(root.right, depth)
        
  • Time Complexity: O(N)
  • Space Complexity: O(N)

One Thought to “LeetCode 111. Minimum Depth of Binary Tree”

  1. Can you please explain why we need a helper in this case? And also why it’s important to have one in general when doing recursion. Thank you.

Leave a Reply

Your email address will not be published. Required fields are marked *