Delete Node in a BST

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 key insight is to leverage the BST property for efficient O(log n) search and handle three deletion cases: no children (remove directly), one child (replace with child), and two children (replace with inorder successor). Best approach uses recursive BST deletion with Time: O(log n), Space: O(log n).

Common Approaches

✓ One Pass Hash

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

BST Property Search with Recursive Deletion

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

Leverage the BST property to search for the target node in O(log n) time, then handle the three deletion cases: leaf node, node with one child, and node with two children using inorder successor.

Brute Force Traversal

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

Traverse the entire tree to collect all values, remove the target key, and rebuild a new BST from remaining values. This ignores the BST property for searching.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_TASKS 10000
#define MAX_USERS 1000
#define MAX_TAGS 10
#define MAX_DESC_LEN 100
#define MAX_TAG_LEN 50
#define HASH_SIZE 10007

typedef struct {
    int id;
    int userId;
    char description[MAX_DESC_LEN];
    int dueDate;
    char tags[MAX_TAGS][MAX_TAG_LEN];
    int tagCount;
    bool completed;
} Task;

typedef struct TaskRef {
    int dueDate;
    int taskId;
    struct TaskRef* next;
} TaskRef;

typedef struct {
    Task tasks[MAX_TASKS];
    TaskRef* userTasks[MAX_USERS];
    TaskRef* tagTasks[HASH_SIZE];
    int taskCount;
    int nextId;
} TodoList;

unsigned int hash(const char* str) {
    unsigned int hash = 5381;
    int c;
    while ((c = *str++))
        hash = ((hash << 5) + hash) + c;
    return hash % HASH_SIZE;
}

TodoList* todoListCreate() {
    TodoList* obj = (TodoList*)calloc(1, sizeof(TodoList));
    obj->nextId = 1;
    return obj;
}

TaskRef* createTaskRef(int dueDate, int taskId) {
    TaskRef* ref = (TaskRef*)malloc(sizeof(TaskRef));
    ref->dueDate = dueDate;
    ref->taskId = taskId;
    ref->next = NULL;
    return ref;
}

void addTaskRef(TaskRef** head, int dueDate, int taskId) {
    TaskRef* ref = createTaskRef(dueDate, taskId);
    ref->next = *head;
    *head = ref;
}

int todoListAddTask(TodoList* obj, int userId, char* taskDescription, int dueDate, char** tags, int tagsSize) {
    int taskId = obj->nextId++;
    Task* task = &obj->tasks[obj->taskCount];
    
    task->id = taskId;
    task->userId = userId;
    strcpy(task->description, taskDescription);
    task->dueDate = dueDate;
    task->tagCount = tagsSize;
    task->completed = false;
    
    for (int i = 0; i < tagsSize; i++) {
        strcpy(task->tags[i], tags[i]);
    }
    
    // Add to user's task list
    addTaskRef(&obj->userTasks[userId], dueDate, taskId);
    
    // Add to tag-based indexes
    for (int i = 0; i < tagsSize; i++) {
        char key[100];
        sprintf(key, "%d:%s", userId, tags[i]);
        unsigned int hashIndex = hash(key);
        addTaskRef(&obj->tagTasks[hashIndex], dueDate, taskId);
    }
    
    obj->taskCount++;
    return taskId;
}

Task* findTask(TodoList* obj, int taskId) {
    for (int i = 0; i < obj->taskCount; i++) {
        if (obj->tasks[i].id == taskId) {
            return &obj->tasks[i];
        }
    }
    return NULL;
}

int compareTasksByDueDate(const void* a, const void* b) {
    Task* taskA = (Task*)a;
    Task* taskB = (Task*)b;
    return taskA->dueDate - taskB->dueDate;
}

char** todoListGetAllTasks(TodoList* obj, int userId, int* returnSize) {
    static Task incompleteTasks[MAX_TASKS];
    int count = 0;
    
    TaskRef* ref = obj->userTasks[userId];
    while (ref != NULL) {
        Task* task = findTask(obj, ref->taskId);
        if (task != NULL && !task->completed) {
            incompleteTasks[count++] = *task;
        }
        ref = ref->next;
    }
    
    qsort(incompleteTasks, count, sizeof(Task), compareTasksByDueDate);
    
    static char* result[MAX_TASKS];
    for (int i = 0; i < count; i++) {
        result[i] = incompleteTasks[i].description;
    }
    
    *returnSize = count;
    return result;
}

char** todoListGetTasksForTag(TodoList* obj, int userId, char* tag, int* returnSize) {
    char key[100];
    sprintf(key, "%d:%s", userId, tag);
    unsigned int hashIndex = hash(key);
    
    static Task incompleteTasks[MAX_TASKS];
    int count = 0;
    
    TaskRef* ref = obj->tagTasks[hashIndex];
    while (ref != NULL) {
        Task* task = findTask(obj, ref->taskId);
        if (task != NULL && !task->completed && task->userId == userId) {
            // Verify tag match
            bool hasTag = false;
            for (int i = 0; i < task->tagCount; i++) {
                if (strcmp(task->tags[i], tag) == 0) {
                    hasTag = true;
                    break;
                }
            }
            if (hasTag) {
                incompleteTasks[count++] = *task;
            }
        }
        ref = ref->next;
    }
    
    qsort(incompleteTasks, count, sizeof(Task), compareTasksByDueDate);
    
    static char* result[MAX_TASKS];
    for (int i = 0; i < count; i++) {
        result[i] = incompleteTasks[i].description;
    }
    
    *returnSize = count;
    return result;
}

void todoListCompleteTask(TodoList* obj, int userId, int taskId) {
    Task* task = findTask(obj, taskId);
    if (task != NULL && task->userId == userId && !task->completed) {
        task->completed = true;
    }
}

void todoListFree(TodoList* obj) {
    // Free all TaskRef linked lists
    for (int i = 0; i < MAX_USERS; i++) {
        TaskRef* ref = obj->userTasks[i];
        while (ref != NULL) {
            TaskRef* temp = ref;
            ref = ref->next;
            free(temp);
        }
    }
    
    for (int i = 0; i < HASH_SIZE; i++) {
        TaskRef* ref = obj->tagTasks[i];
        while (ref != NULL) {
            TaskRef* temp = ref;
            ref = ref->next;
            free(temp);
        }
    }
    
    free(obj);
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

87.6K Views

High Frequency

~25 min Avg. Time

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