Inorder Successor in BST II

Inorder Successor in BST II - Problem

Given a node in a binary search tree, return the in-order successor of that node in the BST. If that node has no in-order successor, return null.

The successor of a node is the node with the smallest key greater than node.val.

You will have direct access to the node but not to the root of the tree. Each node will have a reference to its parent node.

The definition for Node is:

class Node {
    public int val;
    public Node left;
    public Node right;
    public Node parent;
}

Input & Output

Example 1 — Node with Right Subtree

$ Input: node = Node(3) in BST [2,3,4,5,6,7,8]

› Output: Node(5)

💡 Note: Node 3 has a right subtree starting with 5. The leftmost node in this right subtree is 5, so the successor is 5.

Example 2 — Node without Right Subtree

$ Input: node = Node(4) in BST [2,3,4,5,6,7,8]

› Output: Node(5)

💡 Note: Node 4 has no right subtree. We go up to parent 3, then to parent 5. Since 4→3→5 and we came from the left at 5, the successor is 5.

Example 3 — Rightmost Node

$ Input: node = Node(8) in BST [2,3,4,5,6,7,8]

› Output: null

💡 Note: Node 8 is the rightmost node in the BST, so it has no inorder successor. Return null.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-10⁵ ≤ Node.val ≤ 10⁵
All Node.val are unique

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 M Microsoft 18 a Amazon 15

The key insight is to use BST properties with parent pointers. If the node has a right subtree, find the leftmost node there. Otherwise, traverse up until finding an ancestor where we came from the left. Best approach uses BST Property Utilization with Time: O(h), Space: O(1).

Common Approaches

✓ Sliding Window

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

BST Property Utilization

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

Leverage the binary search tree property with parent pointers. If node has right subtree, find leftmost node there. Otherwise, go up until we find an ancestor where our path came from the left subtree.

Complete Tree Traversal

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

Navigate to root using parent pointers, perform inorder traversal to collect all nodes, then find the successor of the given node. This is inefficient but straightforward.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* bulbs, int bulbsSize, int k) {
    bool* lit = (bool*)calloc(bulbsSize + 1, sizeof(bool)); // 1-indexed
    
    for (int day = 0; day < bulbsSize; day++) {
        int pos = bulbs[day];
        lit[pos] = true;
        
        // Check if pos and pos+k+1 form a valid pair
        int right = pos + k + 1;
        if (right <= bulbsSize && lit[right]) {
            // Check if all bulbs between pos and right are off
            bool allOff = true;
            for (int m = pos + 1; m < right; m++) {
                if (lit[m]) {
                    allOff = false;
                    break;
                }
            }
            if (allOff) {
                free(lit);
                return day + 1;
            }
        }
        
        // Check if pos-k-1 and pos form a valid pair
        int left = pos - k - 1;
        if (left >= 1 && lit[left]) {
            // Check if all bulbs between left and pos are off
            bool allOff = true;
            for (int m = left + 1; m < pos; m++) {
                if (lit[m]) {
                    allOff = false;
                    break;
                }
            }
            if (allOff) {
                free(lit);
                return day + 1;
            }
        }
    }
    
    free(lit);
    return -1;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int bulbs[1000];
    int count = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            bulbs[count++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(bulbs, count, k);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

98.3K Views

Medium Frequency

~15 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