Binary Tree Longest Consecutive Sequence II

Binary Tree Longest Consecutive Sequence II - Problem

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

A consecutive path is a path where the values of the consecutive nodes in the path differ by one. This path can be either increasing or decreasing. For example, [1,2,3,4] and [4,3,2,1] are both considered valid, but the path [1,2,4,3] is not valid.

The path can be in the child-Parent-child order, where not necessarily be parent-child order.

Input & Output

Example 1 — Path Through Root

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

› Output: 3

💡 Note: The longest consecutive path is 2→3→4 with length 3. This path goes through the right subtree.

Example 2 — Single Node

$ Input: root = [2]

› Output: 1

💡 Note: Tree has only one node, so the longest consecutive path has length 1.

Example 3 — No Consecutive Path

$ Input: root = [1,3,5]

› Output: 1

💡 Note: No consecutive path exists (values differ by more than 1), so return 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 25 F Facebook 18 A Amazon 15

The key insight is that the longest consecutive path can pass through any node, combining increasing and decreasing sequences from both subtrees. Best approach is single-pass DFS that tracks both directions simultaneously. Time: O(n), Space: O(h)

Common Approaches

✓ Stack

⏱️ Time: N/A Space: N/A

Brute Force DFS from Every Node

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

For each node in the tree, perform DFS to find the longest increasing and decreasing consecutive paths. This explores all possible starting points but with redundant work.

Optimized Single Pass DFS

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

Use DFS to compute for each node the longest increasing and decreasing consecutive sequences starting from that node. Then combine them to find the longest path passing through each node.

Algorithm Steps — Algorithm Steps

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 = malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int* solution(struct TreeNode* root, int* returnSize) {
    *returnSize = 0;
    if (!root) return NULL;
    
    struct TreeNode* stack[1000];
    int* result = malloc(1000 * sizeof(int));
    int top = 0;
    int idx = 0;
    struct TreeNode* lastVisited = NULL;
    struct TreeNode* current = root;
    
    while (top > 0 || current) {
        if (current) {
            stack[top++] = current;
            current = current->left;
        } else {
            struct TreeNode* peekNode = stack[top - 1];
            if (peekNode->right && lastVisited != peekNode->right) {
                current = peekNode->right;
            } else {
                result[idx++] = peekNode->val;
                lastVisited = peekNode;
                top--;
            }
        }
    }
    
    *returnSize = idx;
    return result;
}

struct TreeNode* buildTree(char* input) {
    if (strlen(input) <= 2) return NULL;
    
    input[strlen(input)-1] = '\0';
    input++;
    
    if (strlen(input) == 0) return NULL;
    
    char* token = strtok(input, ",");
    if (!token || strcmp(token, "null") == 0) return NULL;
    
    struct TreeNode* root = createNode(atoi(token));
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        
        token = strtok(NULL, ",");
        if (token && strcmp(token, "null") != 0) {
            node->left = createNode(atoi(token));
            queue[rear++] = node->left;
        }
        
        token = strtok(NULL, ",");
        if (token && strcmp(token, "null") != 0) {
            node->right = createNode(atoi(token));
            queue[rear++] = node->right;
        }
    }
    
    return root;
}

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

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

845 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