Binary Tree Longest Consecutive Sequence

Binary Tree Longest Consecutive Sequence - Problem

Given the root of a binary tree, return the length of the longest consecutive sequence path.

A consecutive sequence path is a path where the values increase by one along the path. Note that the path can start at any node in the tree, and you cannot go from a node to its parent in the path.

The path must be from parent to child (cannot go upward in paths).

Input & Output

Example 1 — Basic Tree

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

› Output: 3

💡 Note: Longest consecutive sequence path is 3-4-5, so return 3. The path goes: 3→4→5.

Example 2 — No Long Sequence

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

› Output: 2

💡 Note: Longest consecutive sequence path is 2-3, so return 2. Note that 3-2-1 is not a valid path since we must go from parent to child.

Example 3 — Single Node

$ Input: root = [1]

› Output: 1

💡 Note: Single node forms a sequence of length 1.

Constraints

The number of nodes in the tree is in the range [1, 3 × 10⁴]
-3 × 10⁴ ≤ Node.val ≤ 3 × 10⁴

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 32 M Microsoft 28 a Amazon 25

The key insight is to use DFS traversal while tracking consecutive sequences. During traversal, check if each node's value equals parent's value + 1. If so, extend the current sequence; otherwise, start a new sequence. Track the maximum sequence length found. Best approach is optimized DFS with Time: O(n), Space: O(h).

Common Approaches

✓ Brute Force - Check All Paths

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

For each node in the tree, start a DFS traversal to find the longest consecutive sequence starting from that node. This explores all possible starting points.

Optimized DFS

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

Perform one DFS traversal and at each node, check if it continues the consecutive sequence from its parent. Track the maximum length found during traversal.

Brute Force - Check All Paths — Algorithm Steps

Visit every node as potential starting point
For each starting node, perform DFS to find longest consecutive path
Track maximum length found across all starting points

Visualization

Tap to expand

Step-by-Step Walkthrough

Get All Nodes

Collect every node as potential starting point

DFS From Each

Start consecutive sequence search from each node

Track Maximum

Keep the longest 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;
};

char** result;
int resultSize;
int resultCapacity;

void dfs(struct TreeNode* node, char* path, int pathLen) {
    if (!node) return;
    
    char currentPath[1000];
    sprintf(currentPath, "%s%d", path, node->val);
    
    if (!node->left && !node->right) {
        if (resultSize >= resultCapacity) {
            resultCapacity *= 2;
            result = realloc(result, resultCapacity * sizeof(char*));
        }
        result[resultSize] = malloc(strlen(currentPath) + 1);
        strcpy(result[resultSize], currentPath);
        resultSize++;
        return;
    }
    
    char nextPath[1000];
    sprintf(nextPath, "%s->", currentPath);
    
    if (node->left) {
        dfs(node->left, nextPath, strlen(nextPath));
    }
    if (node->right) {
        dfs(node->right, nextPath, strlen(nextPath));
    }
}

char** solution(struct TreeNode* root, int* returnSize) {
    result = malloc(1000 * sizeof(char*));
    resultSize = 0;
    resultCapacity = 1000;
    
    if (!root) {
        *returnSize = 0;
        return result;
    }
    
    dfs(root, "", 0);
    *returnSize = resultSize;
    return result;
}

struct TreeNode* buildTree(char* input) {
    if (strcmp(input, "[]") == 0 || strcmp(input, "null") == 0) return NULL;
    
    // Remove brackets
    int len = strlen(input);
    char* values_str = malloc(len + 1);
    strncpy(values_str, input + 1, len - 2);
    values_str[len - 2] = '\0';
    
    char** values = malloc(1000 * sizeof(char*));
    int valuesCount = 0;
    
    char* token = strtok(values_str, ",");
    while (token != NULL) {
        values[valuesCount] = malloc(strlen(token) + 1);
        strcpy(values[valuesCount], token);
        valuesCount++;
        token = strtok(NULL, ",");
    }
    
    if (valuesCount == 0) {
        free(values_str);
        free(values);
        return NULL;
    }
    
    struct TreeNode* root = malloc(sizeof(struct TreeNode));
    root->val = atoi(values[0]);
    root->left = NULL;
    root->right = NULL;
    
    struct TreeNode** queue = malloc(1000 * sizeof(struct TreeNode*));
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    for (int i = 1; i < valuesCount; i += 2) {
        struct TreeNode* parent = queue[front++];
        
        if (strcmp(values[i], "null") != 0) {
            parent->left = malloc(sizeof(struct TreeNode));
            parent->left->val = atoi(values[i]);
            parent->left->left = NULL;
            parent->left->right = NULL;
            queue[rear++] = parent->left;
        }
        
        if (i + 1 < valuesCount && strcmp(values[i + 1], "null") != 0) {
            parent->right = malloc(sizeof(struct TreeNode));
            parent->right->val = atoi(values[i + 1]);
            parent->right->left = NULL;
            parent->right->right = NULL;
            queue[rear++] = parent->right;
        }
    }
    
    free(values_str);
    for (int i = 0; i < valuesCount; i++) {
        free(values[i]);
    }
    free(values);
    free(queue);
    
    return root;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = '\0';
    
    struct TreeNode* root = buildTree(input);
    int returnSize;
    char** paths = solution(root, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", paths[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

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

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth is limited by tree height h

✓ Linear Space

89.0K Views

Medium Frequency

~15 min Avg. Time

1.5K 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 - Check All Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler