Tree Height and Depth - Problem

Given a binary tree and a target node value, calculate two important tree properties:

1. Height of the tree: The maximum distance from the root to any leaf node

2. Depth of the target node: The distance from the root to the node with the given value

Return an array [height, depth] where height is the tree height and depth is the depth of the target node. If the target node is not found, return [-1, -1].

Note: The root node is at depth 0. A single node tree has height 0.

Input & Output

Example 1 — Basic Binary Tree

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

› Output: [2,2]

💡 Note: Tree height is 2 (root to leaf nodes 15 or 7). Target node 15 is at depth 2 (root→20→15).

Example 2 — Target at Root

$ Input: root = [1,2,3], target = 1

› Output: [1,0]

💡 Note: Tree height is 1 (root to leaves 2 or 3). Target node 1 is the root at depth 0.

Example 3 — Target Not Found

$ Input: root = [5,3,8,1,4], target = 10

› Output: [-1,-1]

💡 Note: Target node 10 does not exist in the tree, so return [-1,-1].

Constraints

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

Visualization

Tap to expand

Asked in

G Google 28 a Amazon 22 M Microsoft 15 f Facebook 12

The key insight is that both tree height and target node depth can be calculated in a single DFS traversal. The optimal approach uses one recursive pass to track the maximum depth reached (height) while simultaneously searching for the target node. Time: O(n), Space: O(h).

Common Approaches

✓ Single DFS Traversal

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

Use a single depth-first search to calculate both the tree height and find the target node's depth simultaneously. More efficient approach that minimizes tree traversals.

Two Separate Traversals

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

First traverse the entire tree to find the maximum height, then traverse again to find the depth of the target node. Two complete tree traversals are performed.

Single DFS Traversal — Algorithm Steps

Start DFS from root with depth 0
Track maximum depth reached (height) and target node depth
Return both values when traversal completes

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin traversal from root, tracking depth

Track Info

Update max height and check for target at each node

Result

Return both height and target depth from single pass

Code -

solution.c — C

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

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

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;
}

static int maxHeight = 0;
static int targetDepth = -1;

void dfs(struct TreeNode* node, int target, int depth) {
    if (!node) return;
    
    if (depth > maxHeight) {
        maxHeight = depth;
    }
    
    if (node->val == target) {
        targetDepth = depth;
    }
    
    dfs(node->left, target, depth + 1);
    dfs(node->right, target, depth + 1);
}

int* solution(struct TreeNode* root, int target, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    
    if (!root) {
        result[0] = -1;
        result[1] = -1;
        return result;
    }
    
    maxHeight = 0;
    targetDepth = -1;
    
    dfs(root, target, 0);
    
    if (targetDepth != -1) {
        result[0] = maxHeight;
        result[1] = targetDepth;
    } else {
        result[0] = -1;
        result[1] = -1;
    }
    
    return result;
}

int main() {
    struct TreeNode* root = createNode(3);
    root->left = createNode(9);
    root->right = createNode(20);
    root->right->left = createNode(15);
    root->right->right = createNode(7);
    
    int target = 15;
    int returnSize;
    int* result = solution(root, target, &returnSize);
    
    printf("[%d,%d]\n", result[0], result[1]);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single tree traversal visiting each node once

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

25.6K Views

Medium Frequency

~15 min Avg. Time

847 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

Tree Height and Depth - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Single DFS Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler