Delete Node in a BST - Problem

Given a root node reference of a BST and a key, delete the node with the given key in the BST. Return the root node reference (possibly updated) of the BST.

Basically, the deletion can be divided into two stages:

Search for a node to remove
If the node is found, delete the node

There are three cases to consider when deleting a node:

Node has no children (leaf node): Simply remove it
Node has one child: Replace the node with its child
Node has two children: Replace the node with its inorder successor (or predecessor)

Input & Output

Example 1 — Node with Two Children

$ 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). Replace it with inorder successor 4, then delete original 4.

Example 2 — Leaf Node

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

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

💡 Note: Node 2 is a leaf node (no children), so simply remove it from the tree.

Example 3 — Root Node Deletion

$ Input: root = [7], key = 7

› Output: []

💡 Note: Deleting the only node in the tree results in an empty tree.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 A Apple 28

The optimal approach uses BST properties for efficient deletion with O(log n) time complexity. It handles three cases: leaf nodes (return null), single child (return the child), and two children (replace with inorder successor). This preserves tree structure while avoiding the overhead of complete reconstruction used by brute force methods.

Common Approaches

✓ BST Property Search with Recursive Deletion

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

This optimal approach leverages BST properties to efficiently locate and delete the target node. It handles three cases: leaf nodes, nodes with one child, and nodes with two children using inorder successor replacement.

Brute Force Traversal

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

This approach performs an inorder traversal to collect all values except the target key, then rebuilds a balanced BST from the sorted array. While conceptually simple, it doesn't leverage BST properties efficiently.

Hash-based Tree Reconstruction

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

This approach uses a hash table to store all tree nodes, removes the target node, then reconstructs the BST from the remaining nodes. It provides O(1) lookup but requires rebuilding the entire tree structure.

BST Property Search with Recursive Deletion — Algorithm Steps

Use BST property to navigate: go left if key < node.val, right if key > node.val
Handle leaf node: simply return null to remove it
Handle one child: return the non-null child to replace current node
Handle two children: replace with inorder successor, then delete successor

Visualization

Tap to expand

Step-by-Step Walkthrough

Search Phase

Navigate BST: 3 < 5, go left. Found target node 3

Two Children Case

Node 3 has children 2 and 4. Find inorder successor (4)

Replace & Clean

Replace 3 with 4, then delete original 4 from right subtree

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.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* solution(struct TreeNode* root, int key) {
    if (root == NULL) return NULL;
    
    if (key < root->val) {
        root->left = solution(root->left, key);
    } else if (key > root->val) {
        root->right = solution(root->right, key);
    } else {
        // Node to delete found
        if (root->left == NULL) {
            return root->right;
        } else if (root->right == NULL) {
            return root->left;
        } else {
            // Node has two children - find inorder successor
            struct TreeNode* minNode = root->right;
            while (minNode->left != NULL) {
                minNode = minNode->left;
            }
            root->val = minNode->val;
            root->right = solution(root->right, minNode->val);
        }
    }
    
    return root;
}

static int parseValues[10000];
static int isNullValues[10000];

int parseArray(char* data) {
    int size = 0;
    if (strcmp(data, "[]") == 0) return 0;
    
    int len = strlen(data);
    if (len < 2 || data[0] != '[' || data[len-1] != ']') return 0;
    
    int i = 1;
    while (i < len - 1) {
        while (i < len - 1 && (data[i] == ' ' || data[i] == ',')) i++;
        if (i >= len - 1) break;
        
        if (data[i] == 'n' && strncmp(data + i, "null", 4) == 0) {
            isNullValues[size] = 1;
            parseValues[size] = 0;
            i += 4;
        } else {
            isNullValues[size] = 0;
            char* endptr;
            parseValues[size] = (int)strtol(data + i, &endptr, 10);
            i = endptr - data;
        }
        size++;
    }
    return size;
}

struct TreeNode* deserialize(char* data) {
    int size = parseArray(data);
    if (size == 0 || isNullValues[0]) return NULL;
    
    struct TreeNode* root = createNode(parseValues[0]);
    static struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        if (i < size && !isNullValues[i]) {
            node->left = createNode(parseValues[i]);
            queue[rear++] = node->left;
        }
        i++;
        if (i < size && !isNullValues[i]) {
            node->right = createNode(parseValues[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

void serialize(struct TreeNode* root, char* result) {
    if (root == NULL) {
        strcpy(result, "[]");
        return;
    }
    
    static struct TreeNode* queue[10000];
    static int values[10000];
    static int isNull[10000];
    int front = 0, rear = 0, size = 0;
    
    queue[rear++] = root;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        if (node != NULL) {
            values[size] = node->val;
            isNull[size] = 0;
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        } else {
            isNull[size] = 1;
        }
        size++;
    }
    
    while (size > 0 && isNull[size-1]) size--;
    
    strcpy(result, "[");
    for (int i = 0; i < size; i++) {
        if (i > 0) strcat(result, ",");
        if (isNull[i]) {
            strcat(result, "null");
        } else {
            char num[20];
            sprintf(num, "%d", values[i]);
            strcat(result, num);
        }
    }
    strcat(result, "]");
}

int main() {
    char rootInput[10000];
    int key;
    fgets(rootInput, sizeof(rootInput), stdin);
    rootInput[strcspn(rootInput, "\n")] = 0;
    scanf("%d", &key);
    
    struct TreeNode* root = deserialize(rootInput);
    struct TreeNode* result = solution(root, key);
    
    char output[10000];
    serialize(result, output);
    printf("%s\n", output);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Navigate tree height to find node, O(log n) average, O(n) worst case

✓ Linear Growth

Space Complexity

O(log n)

Recursion stack depth equals tree height

⚡ Linearithmic Space

87.7K Views

High Frequency

~25 min Avg. Time

3.4K Likes

Ln 1, Col 1

💡 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

Delete Node in a BST - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BST Property Search with Recursive Deletion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler