Maximum Depth of Binary Tree

Maximum Depth of Binary Tree - Problem

Given the root of a binary tree, return its maximum depth.

A binary tree's maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

Input & Output

Example 1 — Balanced Tree

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

› Output: 3

💡 Note: The longest path is from root 3 → 20 → 15 (or 7), which has 3 nodes, so depth is 3.

Example 2 — Linear Tree

$ Input: root = [1,null,2]

› Output: 2

💡 Note: The tree has only a right path: 1 → 2, so the depth is 2.

Example 3 — Single Node

$ Input: root = [1]

› Output: 1

💡 Note: Tree has only one node (the root), so the depth is 1.

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-100 ≤ Node.val ≤ 100

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is that the maximum depth equals 1 plus the maximum depth of the left and right subtrees. Best approach is DFS recursion for simplicity or BFS iteration to avoid stack overflow. Time: O(n), Space: O(h) where h is tree height.

Common Approaches

✓ Breadth-First Search (Iterative)

⏱️ Time: O(n) Space: O(w)

Process nodes level by level using a queue. Keep track of the current level depth and increment it for each complete level processed.

Depth-First Search (Recursive)

⏱️ Time: O(n) Space: O(h)

Visit each node and recursively calculate the maximum depth of its left and right subtrees. The depth at any node is 1 plus the maximum of its left and right subtree depths.

Breadth-First Search (Iterative) — Algorithm Steps

Initialize queue with root and depth counter
Process all nodes at current level
Add children of current level to queue
Increment depth and repeat until queue is empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Level

Process all nodes at current level, add children to queue

Increment Depth

After processing complete level, increment depth counter

Continue

Repeat until queue is empty, return final depth

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct Queue {
    struct TreeNode** nodes;
    int front;
    int rear;
    int capacity;
};

struct Queue* createQueue(int capacity) {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->nodes = (struct TreeNode**)malloc(capacity * sizeof(struct TreeNode*));
    q->front = 0;
    q->rear = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(struct Queue* q, struct TreeNode* node) {
    q->nodes[q->rear++] = node;
}

struct TreeNode* dequeue(struct Queue* q) {
    return q->nodes[q->front++];
}

int isEmpty(struct Queue* q) {
    return q->front == q->rear;
}

int size(struct Queue* q) {
    return q->rear - q->front;
}

int solution(struct TreeNode* root) {
    if (!root) {
        return 0;
    }
    
    struct Queue* queue = createQueue(1000);
    enqueue(queue, root);
    int depth = 0;
    
    while (!isEmpty(queue)) {
        depth++;
        int levelSize = size(queue);
        
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = dequeue(queue);
            
            if (node->left) {
                enqueue(queue, node->left);
            }
            if (node->right) {
                enqueue(queue, node->right);
            }
        }
    }
    
    return depth;
}

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* arrayToTree(int* arr, int size) {
    if (size == 0 || arr[0] == -1001) {
        return NULL;
    }
    
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size && arr[i] != -1001) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && arr[i] != -1001) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse input array - simplified parser
    int arr[1000];
    int size = 0;
    
    // Remove brackets and parse
    char* token = strtok(line, "[],\n");
    while (token != NULL && size < 1000) {
        while (*token == ' ') token++; // skip spaces
        if (strncmp(token, "null", 4) == 0) {
            arr[size++] = -1001; // Use -1001 as null marker
        } else {
            arr[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    struct TreeNode* root = arrayToTree(arr, size);
    int result = solution(root);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once where n is number of nodes

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes where w is maximum width of tree, worst case O(n)

✓ Linear Space

235.8K Views

High Frequency

~15 min Avg. Time

8.4K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Breadth-First Search (Iterative) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler