AlgoExplained.dev

from collections import deque
Import deque for efficient queue operations (O(1) append/pop from both ends).

def minDepth(root):
Main function that takes the root of a binary tree.

    if not root:
Edge case: empty tree has depth 0.

        return 0
Return 0 for null root.

    queue = deque([(root, 1)])
Initialize queue with root node and depth 1. Each element is a (node, depth) tuple.

    while queue:
Process nodes level by level until queue is empty.

        node, depth = queue.popleft()
Dequeue the next node and its depth from the front of the queue.

        if not node.left and not node.right:
Check if this node is a leaf (has no children). This is our target!

            return depth
Found a leaf! Return current depth immediately - this is the minimum.

        if node.left:
If left child exists, add it to the queue.

            queue.append((node.left, depth + 1))
Add left child with incremented depth to the queue.

        if node.right:
If right child exists, add it to the queue.

            queue.append((node.right, depth + 1))
Add right child with incremented depth to the queue.

public int minDepth(TreeNode root) {
Main method that takes root node and returns minimum depth.

    if (root == null) {
Edge case: empty tree.

        return 0;
Return 0 for null root.

    }
End of null check.

    Queue<TreeNode> queue = new LinkedList<>();
Create a queue using LinkedList which implements Queue interface.

    queue.offer(root);
Add root to queue using offer() method.

    int depth = 1;
Start with depth 1 (root level).

    while (!queue.isEmpty()) {
Continue while queue has nodes to process.

        int levelSize = queue.size();
Get number of nodes at current level for level-by-level processing.

        for (int i = 0; i < levelSize; i++) {
Process all nodes at current level.

            TreeNode node = queue.poll();
Remove node from front of queue.

            if (node.left == null && node.right == null) {
Check if this node is a leaf (no children).

                return depth;
Found a leaf! Return current depth - this is the minimum.

            }
End of leaf check.

            if (node.left != null) queue.offer(node.left);
Add left child to queue if it exists.

            if (node.right != null) queue.offer(node.right);
Add right child to queue if it exists.

        }
End of level processing loop.

        depth++;
Increment depth after processing all nodes at current level.

    }
End of while loop.

    return depth;
Return depth (should never reach here for valid trees).

}
End of method.

int minDepth(TreeNode* root) {
Main function that takes root pointer and returns minimum depth.

    if (!root) {
Check for null root (empty tree).

        return 0;
Return 0 for empty tree.

    }
End of null check.

    queue<pair<TreeNode*, int>> q;
Create queue of (node, depth) pairs using STL queue.

    q.push({root, 1});
Push root with initial depth 1.

    while (!q.empty()) {
Continue while queue has elements.

        auto [node, depth] = q.front();
Get front element with structured binding (C++17).

        q.pop();
Remove front element from queue.

        if (!node->left && !node->right) {
Check if node is a leaf (no left and no right child).

            return depth;
Found a leaf! Return current depth - minimum found.

        }
End of leaf check.

        if (node->left) q.push({node->left, depth + 1});
Add left child with incremented depth if it exists.

        if (node->right) q.push({node->right, depth + 1});
Add right child with incremented depth if it exists.

    }
End of while loop.

    return 0;
Return 0 (should never reach for valid trees).

}
End of function.