Recover Binary Search Tree

Recover Binary Search Tree - Problem

You are given the root of a binary search tree (BST), where the values of exactly two nodes of the tree were swapped by mistake. Recover the tree without changing its structure.

A binary search tree satisfies the property that for every node, all values in the left subtree are less than the node's value, and all values in the right subtree are greater than the node's value.

Your task is to identify the two swapped nodes and correct their values to restore the BST property.

Input & Output

Example 1 — Adjacent Swap

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

› Output: [3,1,null,null,2]

💡 Note: The values 1 and 3 were swapped. After correction: 3 should be root with 1 as left child and 2 as right child of 1.

Example 2 — Non-Adjacent Swap

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

› Output: [2,1,4,null,null,3]

💡 Note: Values 3 and 2 were swapped. The BST should have 2 as root, with 1 as left child and 4 as right child, and 3 as left child of 4.

Constraints

The number of nodes in the tree is in the range [2, 1000]
-2³¹ ≤ Node.val ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8

The key insight is that inorder traversal of a BST should give a sorted sequence. When two nodes are swapped, this sequence will have violations. The optimal approach uses a single DFS traversal to detect the violation points and swap the problematic nodes. Time: O(n), Space: O(h)

Common Approaches

✓ Inorder Traversal + Sorting

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

Perform inorder traversal to collect all node values, sort the values to get correct BST sequence, then traverse again to update each node with correct value from sorted array.

Two-Pass DFS (Morris-like)

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

Use inorder traversal to detect violations of BST property. In a BST, inorder gives sorted sequence. Find the two nodes that break this ordering - they are the swapped nodes.

Inorder Traversal + Sorting — Algorithm Steps

Step 1: Inorder traversal to collect all values
Step 2: Sort the collected values
Step 3: Inorder traversal again to assign sorted values back

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Values

Inorder traversal gives [1,3,2]

Sort Values

Sorted array becomes [1,2,3]

Update Tree

Assign sorted values back to nodes

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.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;
}

static int values[1000];
static int valueCount = 0;
static int updateIndex = 0;

void inorderCollect(struct TreeNode* node) {
    if (node) {
        inorderCollect(node->left);
        values[valueCount++] = node->val;
        inorderCollect(node->right);
    }
}

void inorderUpdate(struct TreeNode* node) {
    if (node) {
        inorderUpdate(node->left);
        node->val = values[updateIndex++];
        inorderUpdate(node->right);
    }
}

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

void solution(struct TreeNode* root) {
    if (!root) return;
    
    valueCount = 0;
    updateIndex = 0;
    
    // Step 1: Collect values
    inorderCollect(root);
    
    // Step 2: Sort values
    qsort(values, valueCount, sizeof(int), compare);
    
    // Step 3: Update tree
    inorderUpdate(root);
}

static struct TreeNode* nodeQueue[1000];
static int queueFront = 0;
static int queueRear = 0;

void enqueue(struct TreeNode* node) {
    nodeQueue[queueRear++] = node;
}

struct TreeNode* dequeue() {
    return nodeQueue[queueFront++];
}

int isQueueEmpty() {
    return queueFront >= queueRear;
}

struct TreeNode* buildTree(int* arr, int* isNull, int size) {
    if (size == 0 || isNull[0]) return NULL;
    
    struct TreeNode* root = createNode(arr[0]);
    queueFront = queueRear = 0;
    enqueue(root);
    int i = 1;
    
    while (!isQueueEmpty() && i < size) {
        struct TreeNode* node = dequeue();
        
        if (i < size && !isNull[i]) {
            node->left = createNode(arr[i]);
            enqueue(node->left);
        }
        i++;
        
        if (i < size && !isNull[i]) {
            node->right = createNode(arr[i]);
            enqueue(node->right);
        }
        i++;
    }
    
    return root;
}

void treeToArrayHelper(struct TreeNode* root, int* result, int* isNull, int* size) {
    if (!root) {
        *size = 0;
        return;
    }
    
    queueFront = queueRear = 0;
    enqueue(root);
    *size = 0;
    
    while (!isQueueEmpty()) {
        struct TreeNode* node = dequeue();
        if (node) {
            result[*size] = node->val;
            isNull[*size] = 0;
            enqueue(node->left);
            enqueue(node->right);
        } else {
            result[*size] = 0;
            isNull[*size] = 1;
        }
        (*size)++;
    }
    
    // Remove trailing nulls
    while (*size > 0 && isNull[*size - 1]) {
        (*size)--;
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    int len = strlen(line);
    if (line[len-1] == '\n') line[len-1] = '\0';
    
    // Parse array [1,3,null,null,2]
    int arr[1000];
    int isNull[1000];
    int size = 0;
    
    char* ptr = line + 1; // Skip '['
    char* end = line + strlen(line) - 1; // Skip ']'
    *end = '\0';
    
    if (strlen(ptr) > 0) {
        char* token = ptr;
        while (token && *token) {
            // Skip whitespace
            while (*token == ' ') token++;
            
            if (strncmp(token, "null", 4) == 0) {
                arr[size] = 0;
                isNull[size] = 1;
                token += 4;
            } else {
                arr[size] = strtol(token, &token, 10);
                isNull[size] = 0;
            }
            size++;
            
            // Skip to next comma or end
            while (*token && *token != ',') token++;
            if (*token == ',') token++;
        }
    }
    
    struct TreeNode* root = buildTree(arr, isNull, size);
    solution(root);
    
    int result[1000];
    int resultIsNull[1000];
    int resultSize;
    treeToArrayHelper(root, result, resultIsNull, &resultSize);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        if (resultIsNull[i]) {
            printf("null");
        } else {
            printf("%d", result[i]);
        }
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) for two traversals plus O(n log n) for sorting

⚡ Linearithmic

Space Complexity

O(n)

Array to store all n node values plus O(h) recursion stack

⚡ Linearithmic Space

182.0K Views

Medium Frequency

~25 min Avg. Time

2.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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Inorder Traversal + Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler