Height of Special Binary Tree

Height of Special Binary Tree - Problem

You are given a root, which is the root of a special binary tree with n nodes. The nodes of the special binary tree are numbered from 1 to n.

Suppose the tree has k leaves in the following order: b₁ < b₂ < ... < bₖ. The leaves of this tree have a special property:

For every leaf bᵢ, the right child of bᵢ is bᵢ + 1 if i < k, and b₁ otherwise.
For every leaf bᵢ, the left child of bᵢ is bᵢ - 1 if i > 1, and bₖ otherwise.

Return the height of the given tree.

Note: The height of a binary tree is the length of the longest path from the root to any other node.

Input & Output

Example 1 — Basic Binary Tree

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

› Output: 2

💡 Note: The longest path is from root to leaf: 3→20→15 or 3→20→7, both have length 2, so height is 2.

Example 2 — Simple Tree

$ Input: root = [1,2,3,4,5]

› Output: 2

💡 Note: Tree has 3 levels (0,1,2). Longest path is 1→2→4 or 1→2→5, both have length 2.

Example 3 — Single Node

$ Input: root = [1]

› Output: 0

💡 Note: Only root node exists, so height is 0 (no edges from root to itself).

Constraints

The number of nodes in the tree is in the range [1, 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 to find the longest path from root to any leaf node. Best approach uses DFS recursion to calculate maximum depth by exploring left and right subtrees. Time: O(n), Space: O(h) where h is tree height.

Common Approaches

✓ Breadth-First Search

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

Use a queue to traverse the tree level by level. Count the number of levels processed to determine the tree height. This approach naturally processes nodes by their distance from the root.

Brute Force DFS

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

Visit every node in the tree using depth-first search, keeping track of the current depth at each node. Return the maximum depth encountered during the traversal.

Optimized DFS with Early Pruning

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

Improved depth-first search that tracks the maximum depth found so far and can potentially skip subtrees that won't improve the result. Uses tail recursion optimization where possible.

Breadth-First Search — Algorithm Steps

Initialize queue with root node
Process all nodes at current level
Add children to queue for next level
Increment level counter and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with root node in queue

Process Level

Process all nodes at current level

Count Levels

Track level count as tree height

Code -

solution.c — C

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

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

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

struct Queue* createQueue(int capacity) {
    struct Queue* q = malloc(sizeof(struct Queue));
    q->nodes = malloc(capacity * sizeof(struct TreeNode*));
    q->front = 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* q = createQueue(1000);
    enqueue(q, root);
    int height = 0;
    
    while (!isEmpty(q)) {
        int levelSize = size(q);
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = dequeue(q);
            if (node->left) enqueue(q, node->left);
            if (node->right) enqueue(q, node->right);
        }
        height++;
    }
    
    free(q->nodes);
    free(q);
    return height - 1;
}

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

struct TreeNode* buildTree(char* input) {
    if (strlen(input) <= 2) return NULL;
    
    char* token;
    char* saveptr;
    struct TreeNode** nodes = malloc(1000 * sizeof(struct TreeNode*));
    int nodeCount = 0;
    
    input[strlen(input)-1] = '\0';
    char* start = input + 1;
    
    token = strtok_r(start, ",", &saveptr);
    while (token != NULL) {
        while (*token == ' ') token++;
        char* end = token + strlen(token) - 1;
        while (*end == ' ') end--;
        *(end+1) = '\0';
        
        if (strcmp(token, "null") == 0) {
            nodes[nodeCount++] = NULL;
        } else {
            nodes[nodeCount++] = createNode(atoi(token));
        }
        token = strtok_r(NULL, ",", &saveptr);
    }
    
    if (nodeCount == 0 || !nodes[0]) {
        free(nodes);
        return NULL;
    }
    
    struct TreeNode* root = nodes[0];
    int i = 1;
    
    for (int parentIdx = 0; parentIdx < nodeCount && i < nodeCount; parentIdx++) {
        if (!nodes[parentIdx]) continue;
        
        if (i < nodeCount) {
            nodes[parentIdx]->left = nodes[i++];
        }
        if (i < nodeCount) {
            nodes[parentIdx]->right = nodes[i++];
        }
    }
    
    free(nodes);
    return root;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    struct TreeNode* root = buildTree(line);
    int result = solution(root);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during traversal

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes where w is maximum width of tree

✓ Linear Space

78.5K Views

High Frequency

~15 min Avg. Time

2.8K 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler