Delete Node in a BST - Practice Coding Problems

Delete Node in a BST - Problem

You are given the root of a Binary Search Tree (BST) and a key value to delete. Your task is to remove the node with the given key while maintaining the BST property.

The deletion process involves two main phases:

Search for the node containing the key
Delete the node if found, ensuring the tree remains a valid BST

Return the root of the modified BST. Note that the root itself might change if it's the node being deleted.

BST Property: For any node, all values in the left subtree are smaller, and all values in the right subtree are larger than the node's value.

Input & Output

example_1.py — Delete leaf node

$ Input: root = [5,3,6,2,4,null,7], key = 4

› Output: [5,3,6,2,null,null,7]

💡 Note: Node 4 is a leaf node (no children), so we simply remove it. The tree structure remains unchanged except for the deleted node.

example_2.py — Delete node with one child

$ Input: root = [5,3,6,2,4,null,7], key = 3

› Output: [5,4,6,2,null,null,7]

💡 Note: Node 3 has two children (2 and 4). We replace it with its inorder successor, which is 4. Then we delete the original position of 4.

example_3.py — Delete root node

$ Input: root = [5,3,6,2,4,null,7], key = 5

› Output: [6,3,7,2,4]

💡 Note: Root node 5 has two children. We replace it with its inorder successor (6), then delete the original position of 6 in the right subtree.

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-10⁵ ≤ Node.val ≤ 10⁵
Each node value is unique
root is a valid binary search tree
-10⁵ ≤ key ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Locate the Book

Use the ordering system to quickly find the book to remove

Assess the Situation

Check if other books depend on this book's position

Smart Replacement

If needed, find the next book in sequence to fill the gap

Key Takeaway

🎯 Key Insight: Like a skilled librarian, the optimal BST deletion algorithm knows exactly how to maintain order with minimal disruption by using the inorder successor as a smart replacement strategy.

Asked in

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

The optimal approach uses recursive BST deletion with O(h) time complexity. It efficiently handles three cases: leaf nodes (simple removal), single-child nodes (replacement), and two-children nodes (inorder successor replacement). This preserves the BST structure while minimizing changes to the original tree.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive BST Deletion (Optimal)	O(h)	O(h)	Use BST properties to find and delete node efficiently with proper successor replacement
Brute Force (Convert to Array)	O(n)	O(n)	Convert BST to array, remove element, rebuild BST from scratch

Recursive BST Deletion (Optimal) — Algorithm Steps

Search for the node using BST properties (go left if key < node.val, right if key > node.val)
If node not found, return the original tree unchanged
Case 1: Node is leaf (no children) - simply remove it
Case 2: Node has one child - replace node with its child
Case 3: Node has two children - replace with inorder successor and delete successor

Visualization

Tap to expand

Step-by-Step Walkthrough

Search for Node

Use BST properties to locate the target node

Identify Case

Determine deletion case: leaf, one child, or two children

Handle Deletion

Apply appropriate deletion strategy based on the case

Code -

solution.c — C

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

struct TreeNode* deleteNode(struct TreeNode* root, int key) {
    if (!root) return NULL;
    
    // Search phase: navigate to the target node
    if (key < root->val) {
        root->left = deleteNode(root->left, key);
    } else if (key > root->val) {
        root->right = deleteNode(root->right, key);
    } else {
        // Found the node to delete - handle three cases
        
        // Case 1: Node is a leaf (no children)
        if (!root->left && !root->right) {
            free(root);
            return NULL;
        }
        
        // Case 2: Node has only one child
        if (!root->left) {
            struct TreeNode* temp = root->right;
            free(root);
            return temp;
        }
        if (!root->right) {
            struct TreeNode* temp = root->left;
            free(root);
            return temp;
        }
        
        // Case 3: Node has two children
        // Find inorder successor (smallest node in right subtree)
        struct TreeNode* successor = root->right;
        while (successor->left) {
            successor = successor->left;
        }
        
        // Replace current node's value with successor's value
        root->val = successor->val;
        
        // Delete the successor (which has at most one child)
        root->right = deleteNode(root->right, successor->val);
    }
    
    return root;
}

// Helper function to print tree in inorder
void inorderPrint(struct TreeNode* root) {
    if (root) {
        inorderPrint(root->left);
        printf("%d ", root->val);
        inorderPrint(root->right);
    }
}

int main() {
    int key;
    printf("Enter key to delete: ");
    scanf("%d", &key);
    
    // Create a sample tree for demonstration
    struct TreeNode* root = createNode(5);
    root->left = createNode(3);
    root->right = createNode(6);
    root->right->right = createNode(7);
    
    printf("Original tree (inorder): ");
    inorderPrint(root);
    printf("\n");
    
    struct TreeNode* result = deleteNode(root, key);
    
    printf("After deleting %d: ", key);
    inorderPrint(result);
    printf("\n");
    
    printf("Root value: %d\n", result ? result->val : -1);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(h)

O(h) where h is height of tree. O(log n) for balanced tree, O(n) for skewed tree

✓ Linear Growth

Space Complexity

O(h)

O(h) space for recursion call stack, where h is the height of the tree

✓ Linear Space

52.3K Views

High Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Recursive BST Deletion (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler