Find Distance in a Binary Tree - Practice Coding Problems

Find Distance in a Binary Tree - Problem

Imagine you're working with a family tree represented as a binary tree, where each person has a unique identifier. Your task is to find the shortest path between any two family members in the tree.

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

The distance is defined as the number of edges on the shortest path connecting the two nodes. This path always goes through their Lowest Common Ancestor (LCA) - think of it as the closest common relative that connects both family members.

Key insight: The distance between two nodes equals the sum of their depths from their LCA: distance = depth(p from LCA) + depth(q from LCA)

Input & Output

example_1.py — Basic Tree

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

› Output: 3

💡 Note: The shortest path from node 5 to node 1 goes through their LCA node 3. Path: 5 → 3 → 1, which has 2 edges, so distance = 2. Wait, let me recalculate: 5→3 (1 edge) + 3→1 (1 edge) = 2 total edges.

example_2.py — Deep Path

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

› Output: 4

💡 Note: Path from 6 to 8: 6 → 5 → 3 → 1 → 8. This path has 4 edges. The LCA of 6 and 8 is node 3. Distance from 6 to 3: 2 edges (6→5→3). Distance from 3 to 8: 2 edges (3→1→8). Total: 2 + 2 = 4.

example_3.py — Same Node

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

› Output: 0

💡 Note: When both nodes are the same, the distance is 0 as no traversal is needed.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Start DFS Journey

Begin traversing the family tree from the root ancestor

Find First Relative

When we encounter person P, we start counting distance

Find Second Relative

When we encounter person Q, we start counting from there too

Discover Common Ancestor

The node where both paths converge is the Lowest Common Ancestor

Calculate Total Distance

Sum the distances from LCA to both relatives

Key Takeaway

🎯 Key Insight: Every pair of nodes in a tree has exactly one path connecting them, and this path always passes through their Lowest Common Ancestor (LCA). The optimal solution finds the LCA while simultaneously calculating distances in a single traversal.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses a single DFS traversal that simultaneously finds the Lowest Common Ancestor (LCA) and calculates distances. When a node matches p or q, we return the distance from that node. When both left and right subtrees return positive distances, we've found the LCA and return the sum of distances. This achieves O(n) time and O(h) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Tree Traversals)	O(n)	O(h)	Find LCA, then calculate distances separately with multiple traversals
Two-Pass with Parent Pointers	O(n)	O(n)	Store parent pointers in hash map, then trace paths to find LCA and calculate distance
One-Pass DFS (Optimal)	O(n)	O(h)	Find LCA and calculate distances simultaneously in a single DFS traversal

Brute Force (Multiple Tree Traversals) — Algorithm Steps

Implement a helper function to find LCA of two nodes
Find LCA of nodes p and q
Perform DFS from LCA to find distance to node p
Perform DFS from LCA to find distance to node q
Return sum of both distances

Visualization

Tap to expand

Step-by-Step Walkthrough

Find LCA

First traversal to locate the Lowest Common Ancestor

Find distance to p

Second traversal from LCA to find distance to node p

Find distance to q

Third traversal from LCA to find distance to node q

Sum distances

Add both distances to get the final result

Code -

solution.c — C

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

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

struct TreeNode* findLCA(struct TreeNode* node, int p, int q) {
    if (!node || node->val == p || node->val == q) {
        return node;
    }
    struct TreeNode* left = findLCA(node->left, p, q);
    struct TreeNode* right = findLCA(node->right, p, q);
    if (left && right) return node;
    return left ? left : right;
}

int findDistanceFromNode(struct TreeNode* node, int target, int dist) {
    if (!node) return -1;
    if (node->val == target) return dist;
    int leftDist = findDistanceFromNode(node->left, target, dist + 1);
    if (leftDist != -1) return leftDist;
    return findDistanceFromNode(node->right, target, dist + 1);
}

int findDistance(struct TreeNode* root, int p, int q) {
    struct TreeNode* lca = findLCA(root, p, q);
    int distP = findDistanceFromNode(lca, p, 0);
    int distQ = findDistanceFromNode(lca, q, 0);
    return distP + distQ;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three separate DFS traversals: O(n) for LCA + O(n) for distance to p + O(n) for distance to q

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, where h can be n in worst case

✓ Linear Space

62.4K Views

Medium-High Frequency

~25 min Avg. Time

1.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

Brute Force (Multiple Tree Traversals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler