Find Distance in a Binary Tree

Find Distance in a Binary Tree - Problem

Given the root of a binary tree and two integers p and q, return the distance between the nodes of value p and q in the tree.

The distance between two nodes is the number of edges on the path from one to the other.

Note: You can assume that both values p and q exist in the tree and all node values are unique.

Input & Output

Example 1 — Basic Distance

$ Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1

› Output: 2

💡 Note: The path from node 5 to node 1 is: 5 → 3 → 1, which has 2 edges. So the distance is 2.

Example 2 — Same Subtree

$ Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4

› Output: 2

💡 Note: The path from node 5 to node 4 is: 5 → 2 → 4, which has 2 edges. So the distance is 2.

Example 3 — Adjacent Nodes

$ Input: root = [1,2,3], p = 2, q = 3

› Output: 2

💡 Note: The path from node 2 to node 3 is: 2 → 1 → 3, which has 2 edges. So the distance is 2.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
0 ≤ Node.val ≤ 10⁴
All Node.val are unique
p ≠ q
p and q exist in the tree

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is that the shortest path between two nodes in a binary tree always passes through their lowest common ancestor (LCA). The optimal approach uses DFS to find the LCA first, then calculates distances from LCA to both target nodes. Time: O(n), Space: O(h).

Common Approaches

✓ Brute Force Path Finding

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

First traverse the tree to find the complete path from root to node p, then find the path from root to node q. Compare paths to find the lowest common ancestor and calculate total distance.

DFS with LCA Finding

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

Perform a single DFS traversal to find the lowest common ancestor (LCA) of the two target nodes. Once LCA is found, calculate the distance from LCA to each target node and sum them.

Brute Force Path Finding — Algorithm Steps

Find complete path from root to node p
Find complete path from root to node q
Compare paths to find lowest common ancestor
Calculate distance as (path_p - lca) + (path_q - lca)

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Path to P

Traverse tree to find complete path from root to node p

Find Path to Q

Traverse tree to find complete path from root to node q

Calculate Distance

Compare paths to find LCA and sum distances

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 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* buildTree(int* arr, int size) {
    if (size == 0 || arr[0] == -1) return NULL;
    
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode* queue[10000];
    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] != -1) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && arr[i] != -1) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

int findPath(struct TreeNode* node, int target, int* path, int* pathLen) {
    if (!node) return 0;
    
    path[*pathLen] = node->val;
    (*pathLen)++;
    
    if (node->val == target) return 1;
    
    if (findPath(node->left, target, path, pathLen) || findPath(node->right, target, path, pathLen)) {
        return 1;
    }
    
    (*pathLen)--;
    return 0;
}

int solution(struct TreeNode* root, int p, int q) {
    int pathP[1000], pathQ[1000];
    int pathPLen = 0, pathQLen = 0;
    
    findPath(root, p, pathP, &pathPLen);
    findPath(root, q, pathQ, &pathQLen);
    
    int i = 0;
    while (i < pathPLen && i < pathQLen && pathP[i] == pathQ[i]) {
        i++;
    }
    
    return pathPLen - i + pathQLen - i;
}

int parseArray(char* input, int* arr) {
    int size = 0;
    char* ptr = input;
    
    // Skip to first '['
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) return 0;
    ptr++; // skip '['
    
    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas
        while (*ptr && (isspace(*ptr) || *ptr == ',')) ptr++;
        
        if (*ptr == ']') break;
        
        if (strncmp(ptr, "null", 4) == 0) {
            arr[size++] = -1; // Use -1 to represent null
            ptr += 4;
        } else if (isdigit(*ptr) || *ptr == '-') {
            arr[size++] = strtol(ptr, &ptr, 10);
        } else {
            ptr++;
        }
    }
    
    return size;
}

int main() {
    char line[10000];
    int arr[1000];
    int p, q;
    
    // Read tree array
    if (!fgets(line, sizeof(line), stdin)) return 1;
    int size = parseArray(line, arr);
    
    // Read p
    if (!fgets(line, sizeof(line), stdin)) return 1;
    p = atoi(line);
    
    // Read q
    if (!fgets(line, sizeof(line), stdin)) return 1;
    q = atoi(line);
    
    struct TreeNode* root = buildTree(arr, size);
    int result = solution(root, p, q);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three tree traversals in worst case - one for each path and one for comparison

✓ Linear Growth

Space Complexity

O(h)

Two arrays to store paths from root to target nodes, each of height h

✓ Linear Space

31.2K Views

Medium Frequency

~25 min Avg. Time

875 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

Brute Force Path Finding — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler