Height of Special Binary Tree - Practice Coding Problems

Height of Special Binary Tree - Problem

You are given a special binary tree with a fascinating structure! This isn't your ordinary binary tree - it has a unique property that creates connections between its leaves.

Here's how it works:

The tree has n nodes numbered from 1 to n
The tree has k leaves arranged in order: b₁ < b₂ < ... < bₖ
Special Property: Each leaf bᵢ has children that reference other leaves:

Right child: bᵢ₊₁ if i < k, otherwise b₁ (wraps around)
Left child: bᵢ₋₁ if i > 1, otherwise bₖ (wraps around)

Your task is to find the height of this tree - the length of the longest path from the root to any node.

Note: The height is measured as the number of edges in the longest path, not the number of nodes.

Input & Output

example_1.py — Simple Special Tree

$ Input: root = [1,2,3,4,5,null,null,null,null,null,null] Leaves: [4,5] where 4->right=5, 5->right=4, 4->left=5, 5->left=4

› Output: 3

💡 Note: The longest path is from root(1) -> node(2) -> node(4) -> node(5), which has 3 edges, so height is 3.

example_2.py — Single Node Tree

$ Input: root = [1] Leaves: [1] where 1->right=1, 1->left=1

› Output: 1

💡 Note: The tree has only one node which references itself. The path from root to itself through children has length 1.

example_3.py — Linear Tree

$ Input: root = [1,2,null,3,null,null,null] Leaves: [3] where 3->right=3, 3->left=3

› Output: 3

💡 Note: The path is root(1) -> node(2) -> node(3) -> node(3), giving height 3.

Constraints

1 ≤ n ≤ 10⁴ (number of nodes)
1 ≤ Node.val ≤ n
All node values are unique
The tree follows the special property described
The root is guaranteed to exist

Visualization

Tap to expand

Understanding the Visualization

Identify Tree Structure

Recognize the main tree structure and identify which nodes are leaves

Handle Circular References

Use visited tracking to avoid infinite loops when following leaf connections

Calculate Maximum Depth

Find the longest path from root to any reachable node using DFS

Return Height

Return the maximum depth found, representing the tree's height

Key Takeaway

🎯 Key Insight: The special property creates circular references between leaves, requiring cycle detection during traversal to find the true maximum depth without infinite loops.

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses DFS with cycle detection to handle the circular leaf references. Key insight: use a visited set to prevent infinite loops when leaves reference each other, and optionally add memoization to cache subtree heights for better performance. Time complexity: O(n), Space complexity: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Optimized DFS with Memoization	O(n)	O(n)	Use memoization to cache results and avoid recalculating subtree heights

Optimized DFS with Memoization — Algorithm Steps

Initialize memoization cache for subtree heights
Perform DFS with visited set for cycle detection
Before calculating subtree height, check cache
Store calculated heights in cache for future use
Return maximum height found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Cache

Start with empty memoization cache

Check Cache

Before calculating, check if result is already cached

Calculate & Store

Calculate height and store in cache for future use

Reuse Results

Use cached results for previously computed subtrees

Code -

solution.c — C

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

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

int memo[1001];
bool memoSet[1001];

int dfs(struct TreeNode* node, bool* visited) {
    if (!node) return 0;
    
    if (visited[node->val]) return 0;
    
    if (!visited[node->val] && memoSet[node->val]) {
        return memo[node->val];
    }
    
    visited[node->val] = true;
    int leftHeight = dfs(node->left, visited);
    int rightHeight = dfs(node->right, visited);
    visited[node->val] = false;
    
    int result = 1 + (leftHeight > rightHeight ? leftHeight : rightHeight);
    memo[node->val] = result;
    memoSet[node->val] = true;
    return result;
}

int heightOfSpecialBinaryTree(struct TreeNode* root) {
    if (!root) return 0;
    
    for (int i = 0; i <= 1000; i++) {
        memoSet[i] = false;
    }
    
    bool visited[1001] = {false};
    return dfs(root, visited) - 1;
}

int main() {
    printf("%d\n", heightOfSpecialBinaryTree(root));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is processed at most once due to memoization

✓ Linear Growth

Space Complexity

O(n)

Memoization cache plus recursion stack space

⚡ Linearithmic Space

24.7K Views

Medium Frequency

~25 min Avg. Time

892 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

Optimized DFS with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler