Recover Binary Search Tree - Practice Coding Problems

Recover Binary Search Tree - Problem

Recover Binary Search Tree is a fascinating tree problem that tests your understanding of BST properties and traversal techniques.

You're given the root of a binary search tree (BST) where exactly two nodes have been swapped by mistake. Your task is to identify and fix these two nodes without changing the tree's structure - only swap their values back to restore the BST property.

🎯 Goal: Detect the two incorrectly placed nodes and swap their values
📥 Input: Root of a BST with exactly 2 nodes swapped
📤 Output: Fix the tree in-place (no return value needed)

The challenge lies in efficiently identifying which two nodes are out of place using the BST's inherent ordering property.

Input & Output

example_1.py — Basic Swap Case

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

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

💡 Note: The tree has nodes 1 and 3 swapped. In a valid BST, we should have 3 at root with 1 and 2 as children. After swapping values of nodes with values 1 and 3, the tree becomes a valid BST.

example_2.py — Adjacent Nodes Swapped

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

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

💡 Note: Two adjacent nodes in inorder traversal are swapped. Original inorder: [1,3,2,4]. After swapping nodes 3 and 2, inorder becomes [1,2,3,4] which is correctly sorted.

example_3.py — Non-Adjacent Nodes

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

› Output: root = [2,1,3]

💡 Note: Nodes 1 and 3 are swapped. In the corrected BST, left child should be smaller than root, and right child should be larger than root.

Visualization

Tap to expand

Understanding the Visualization

Understand the Crime Scene

A valid BST has the property that inorder traversal gives sorted sequence. Two swapped nodes disrupt this order.

Look for Evidence

In the inorder sequence, violations occur where prev > current. This gives us clues about swapped nodes.

Identify Suspects

First violation: previous node is likely first suspect. Second violation: current node is likely second suspect.

Make the Arrest

Swap the values of the two identified nodes to restore the BST property.

Key Takeaway

🎯 Key Insight: Morris traversal allows us to detect BST violations during inorder traversal using only O(1) extra space, making it the optimal solution for space-constrained environments.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all nodes using Morris traversal

✓ Linear Growth

Space Complexity

O(1)

Only constant extra space for pointers, no recursion stack

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [2, 1000]
Node values are in the range [-2³¹, 2³¹ - 1]
Exactly two nodes are swapped - no more, no less
The tree structure remains unchanged, only values are swapped

Asked in

⊞ Microsoft 45 a Amazon 38 G Google 32 f Meta 28

The optimal solution uses Morris Traversal to achieve O(1) space complexity while detecting BST violations in a single pass. The key insight is that exactly two swapped nodes create at most two violation points in the inorder sequence, which Morris traversal can identify without using recursion stack or additional data structures.

Common Approaches

Approach	Time	Space	Notes
✓ Morris Traversal (Optimal Space)	O(n)	O(1)	Use Morris inorder traversal to detect violations in O(1) space
Inorder Traversal + Array Comparison	O(n log n)	O(n)	Get inorder traversal, sort it, find two differences by comparison
Brute Force (All Pairs)	O(n³)	O(n)	Try swapping every pair of nodes and check if BST property is restored

Morris Traversal (Optimal Space) — Algorithm Steps

Initialize pointers for the two swapped nodes and previous node
Use Morris traversal to visit nodes in inorder without extra space
For each node, check if previous node value > current node value (violation)
First violation: record the previous node as first swapped node
Second violation: record current node as second swapped node
After traversal, swap the values of the two identified nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Morris Setup

Create threading to enable O(1) space inorder traversal

Detect First Violation

prev.val > current.val: first violation found

Detect Second Violation

Another violation or end of traversal

Swap and Clean

Swap the two nodes and remove threading

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

void recoverTree(struct TreeNode* root) {
    struct TreeNode *first = NULL, *second = NULL, *prev = NULL;
    struct TreeNode *current = root;
    
    while (current) {
        if (!current->left) {
            // Process current node
            if (prev && prev->val > current->val) {
                if (!first) {
                    first = prev;
                }
                second = current;
            }
            prev = current;
            current = current->right;
        } else {
            // Find inorder predecessor
            struct TreeNode *predecessor = current->left;
            while (predecessor->right && predecessor->right != current) {
                predecessor = predecessor->right;
            }
            
            if (!predecessor->right) {
                // Create threaded link
                predecessor->right = current;
                current = current->left;
            } else {
                // Remove threaded link and process current
                predecessor->right = NULL;
                if (prev && prev->val > current->val) {
                    if (!first) {
                        first = prev;
                    }
                    second = current;
                }
                prev = current;
                current = current->right;
            }
        }
    }
    
    // Swap the values
    if (first && second) {
        int temp = first->val;
        first->val = second->val;
        second->val = temp;
    }
}

int main() {
    printf("Tree recovered\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all nodes using Morris traversal

✓ Linear Growth

Space Complexity

O(1)

Only constant extra space for pointers, no recursion stack

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [2, 1000]
Node values are in the range [-2³¹, 2³¹ - 1]
Exactly two nodes are swapped - no more, no less
The tree structure remains unchanged, only values are swapped

89.0K Views

Medium-High Frequency

~25 min Avg. Time

2.2K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Morris Traversal (Optimal Space) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler