Inorder Successor in BST

Inorder Successor in BST - Problem

Given the root of a binary search tree and a node p in it, return the in-order successor of that node in the BST.

If the given node has no in-order successor in the tree, return null.

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

Input & Output

Example 1 — Node with Right Subtree

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

› Output: 2

💡 Note: Node 1 has no right child, so we look for the ancestor where 1 is in the left subtree. Starting from root 2, since 1 < 2, node 2 is the successor of 1.

Example 2 — Node without Right Subtree

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

› Output: null

💡 Note: Node 6 has no right child and is the largest node in the BST, so it has no inorder successor. Return null.

Example 3 — Leftmost in Right Subtree

$ Input: root = [5,3,6,2,4], p = 3

› Output: 4

💡 Note: Node 3 has a right child. The successor is the leftmost node in the right subtree of 3, which is node 4.

Constraints

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

Visualization

Tap to expand

Asked in

a Amazon 15 f Facebook 12 M Microsoft 10 G Google 8

The key insight is using BST properties to find successors efficiently. If the node has a right child, the successor is the leftmost node in the right subtree. Otherwise, it's the lowest ancestor where the node is in the left subtree. Best approach is BST optimization with Time: O(h), Space: O(1).

Common Approaches

✓ Hash Map

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

BST Property Optimization

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

Leverage the BST property: if p has a right child, successor is the leftmost node in right subtree. Otherwise, successor is the lowest ancestor where p is in the left subtree. This avoids visiting all nodes.

Brute Force Inorder Traversal

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

Visit all nodes in inorder sequence, store them in a list, then find the node that comes immediately after p in the sequence. This is straightforward but visits every node unnecessarily.

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

static struct TreeNode nodes[10001];
static int nodeCount = 0;

// Hash map to store parent relationships
static struct TreeNode* parentMap[10001];
static int parentKeys[10001];
static int parentSize = 0;

// Hash function for mapping node values to indices
int hash(int val) {
    return (val + 100000) % 10001;
}

void addParent(int childVal, struct TreeNode* parent) {
    int idx = hash(childVal);
    while (parentKeys[idx] != 0 && parentKeys[idx] != childVal) {
        idx = (idx + 1) % 10001;
    }
    parentKeys[idx] = childVal;
    parentMap[idx] = parent;
    if (parentKeys[idx] == childVal) parentSize++;
}

struct TreeNode* getParent(int val) {
    int idx = hash(val);
    while (parentKeys[idx] != 0) {
        if (parentKeys[idx] == val) {
            return parentMap[idx];
        }
        idx = (idx + 1) % 10001;
    }
    return NULL;
}

struct TreeNode* findNode(struct TreeNode* root, int val) {
    if (!root) return NULL;
    if (root->val == val) return root;
    
    struct TreeNode* left = findNode(root->left, val);
    if (left) return left;
    
    return findNode(root->right, val);
}

struct TreeNode* getLeftmost(struct TreeNode* node) {
    while (node && node->left) {
        node = node->left;
    }
    return node;
}

struct TreeNode* inorderSuccessor(struct TreeNode* root, struct TreeNode* p) {
    if (!p) return NULL;
    
    // Case 1: Node has right subtree
    if (p->right) {
        return getLeftmost(p->right);
    }
    
    // Case 2: Node has no right subtree - find ancestor
    struct TreeNode* successor = NULL;
    struct TreeNode* current = root;
    
    while (current) {
        if (p->val < current->val) {
            successor = current;
            current = current->left;
        } else if (p->val > current->val) {
            current = current->right;
        } else {
            break;
        }
    }
    
    return successor;
}

struct TreeNode* parseTree(char* str) {
    if (!str || strlen(str) < 3) return NULL;
    
    // Reset globals
    nodeCount = 0;
    parentSize = 0;
    memset(parentKeys, 0, sizeof(parentKeys));
    memset(parentMap, 0, sizeof(parentMap));
    
    char* ptr = str;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    // Parse values
    char* values[10000];
    int valueCount = 0;
    
    char* start = ptr;
    while (*ptr && *ptr != ']') {
        if (*ptr == ',' || *ptr == ']') {
            int len = ptr - start;
            char* val = malloc(len + 1);
            strncpy(val, start, len);
            val[len] = '\0';
            
            // Trim whitespace
            while (*val == ' ') val++;
            char* end = val + strlen(val) - 1;
            while (end > val && *end == ' ') *end-- = '\0';
            
            values[valueCount++] = val;
            
            if (*ptr == ',') ptr++;
            while (*ptr == ' ') ptr++;
            start = ptr;
        } else {
            ptr++;
        }
    }
    
    if (valueCount == 0) return NULL;
    
    // Create nodes using level-order traversal
    struct TreeNode** queue = malloc(valueCount * sizeof(struct TreeNode*));
    int front = 0, rear = 0;
    
    struct TreeNode* root = NULL;
    
    if (strcmp(values[0], "null") != 0) {
        root = &nodes[nodeCount++];
        root->val = atoi(values[0]);
        root->left = root->right = NULL;
        queue[rear++] = root;
    }
    
    int i = 1;
    while (front < rear && i < valueCount) {
        struct TreeNode* current = queue[front++];
        
        // Left child
        if (i < valueCount && strcmp(values[i], "null") != 0) {
            current->left = &nodes[nodeCount++];
            current->left->val = atoi(values[i]);
            current->left->left = current->left->right = NULL;
            queue[rear++] = current->left;
        }
        i++;
        
        // Right child
        if (i < valueCount && strcmp(values[i], "null") != 0) {
            current->right = &nodes[nodeCount++];
            current->right->val = atoi(values[i]);
            current->right->left = current->right->right = NULL;
            queue[rear++] = current->right;
        }
        i++;
    }
    
    free(queue);
    return root;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    struct TreeNode* root = parseTree(line);
    
    int pVal;
    scanf("%d", &pVal);
    
    struct TreeNode* p = findNode(root, pVal);
    struct TreeNode* successor = inorderSuccessor(root, p);
    
    if (successor) {
        printf("%d\n", successor->val);
    } else {
        printf("null\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

892 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