Codestin Search App

Binary Tree Longest Consecutive Sequence - Problem

You're given the root of a binary tree and need to find the longest consecutive sequence path within it. Think of it as finding the longest chain of numbers that increase by exactly 1 at each step!

A consecutive sequence path is a path where:

Values increase by exactly 1 along the path (e.g., 1→2→3→4)
The path follows parent-to-child direction only (no going back up)
The path can start at any node in the tree

Goal: Return the length of the longest such consecutive sequence path.

For example, in a tree with nodes [1,null,3,2,4,null,null,null,5], the longest consecutive path is 3→4→5 with length 3.

Input & Output

example_1.py — Basic Tree

$ Input: [1,null,3,2,4,null,null,null,5]

› Output: 3

💡 Note: The longest consecutive sequence path is 3-4-5, so return 3. The tree structure shows 1 has right child 3, which has children 2 and 4, and 4 has right child 5.

example_2.py — Disconnected Sequences

$ Input: [2,null,3,2,null,1]

› Output: 2

💡 Note: The longest consecutive sequence path is 2-3, so return 2. Note that there are two separate nodes with value 2, but we can only follow parent-to-child paths.

example_3.py — Single Node

$ Input: [1]

› Output: 1

💡 Note: Single node tree has a consecutive sequence of length 1 (just the node itself).

Visualization

Tap to expand

Understanding the Visualization

Start the Family Tree Exploration

Begin at the root of the family tree with initial consecutive count of 1

Check Each Parent-Child Relationship

For each parent-child pair, check if child's number = parent's number + 1

Maintain the Consecutive Chain

If consecutive, extend the chain length; otherwise, start a new chain from this person

Track the Longest Dynasty

Keep track of the longest consecutive chain found throughout the exploration

Key Takeaway

🎯 Key Insight: By tracking consecutive length during a single tree traversal, we avoid redundant work and achieve optimal O(n) time complexity while finding the longest consecutive sequence path.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in the tree traversal

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h (O(log n) balanced, O(n) worst case)

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 3 × 10⁴]
-3 × 10⁴ ≤ Node.val ≤ 3 × 10⁴
Path direction: Can only go from parent to child (no backtracking)

Asked in

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

The optimal solution uses a single DFS traversal with O(n) time complexity. As we traverse down each path, we track the current consecutive sequence length, incrementing when a child's value equals parent + 1, and resetting to 1 otherwise. This eliminates the need to start fresh from every node like in the brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS from Every Node)	O(n²)	O(h)	Start DFS from every node to find longest consecutive path
Single Pass DFS (Optimal)	O(n)	O(h)	Traverse tree once using DFS, tracking consecutive length at each node

Brute Force (DFS from Every Node) — Algorithm Steps

Traverse the entire tree to visit each node
For each node, start a DFS to find longest consecutive path from that node
In DFS, explore children only if their value is exactly parent + 1
Track maximum length found across all starting nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Node 1

Begin DFS from node 1, looking for consecutive path 1→2→3...

Start from Node 3

Begin DFS from node 3, looking for consecutive path 3→4→5...

Continue for All Nodes

Repeat process for every node in the tree

Track Maximum

Keep track of the longest consecutive sequence found

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

void getAllNodes(struct TreeNode* node, struct TreeNode** nodes, int* count) {
    if (!node) return;
    nodes[(*count)++] = node;
    getAllNodes(node->left, nodes, count);
    getAllNodes(node->right, nodes, count);
}

int dfsFromNode(struct TreeNode* node, int target, int length) {
    if (!node) return length;
    
    if (node->val == target) {
        length++;
        int maxLength = length;
        
        if (node->left) {
            int leftMax = dfsFromNode(node->left, target + 1, length);
            if (leftMax > maxLength) maxLength = leftMax;
        }
        
        if (node->right) {
            int rightMax = dfsFromNode(node->right, target + 1, length);
            if (rightMax > maxLength) maxLength = rightMax;
        }
        
        return maxLength;
    }
    return length;
}

int longestConsecutive(struct TreeNode* root) {
    if (!root) return 0;
    
    struct TreeNode* allNodes[1000];
    int nodeCount = 0;
    getAllNodes(root, allNodes, &nodeCount);
    
    int maxLen = 0;
    for (int i = 0; i < nodeCount; i++) {
        int currentMax = dfsFromNode(allNodes[i], allNodes[i]->val, 0);
        if (currentMax > maxLen) maxLen = currentMax;
    }
    
    return maxLen;
}

int main() {
    // For simplicity, creating a sample tree [1,null,3,2,4,null,null,null,5]
    struct TreeNode* root = createNode(1);
    root->right = createNode(3);
    root->right->left = createNode(2);
    root->right->right = createNode(4);
    root->right->right->right = createNode(5);
    
    int result = longestConsecutive(root);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially traverse the entire subtree in worst case

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, plus space for tree traversal

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 3 × 10⁴]
-3 × 10⁴ ≤ Node.val ≤ 3 × 10⁴
Path direction: Can only go from parent to child (no backtracking)

42.5K Views

Medium-High Frequency

~18 min Avg. Time

1.3K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (DFS from Every Node) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler