Trees and Balanced Search Structures · Balanced Trees

Deletion From a Red-Black Tree

Deletion is the most complex red-black operation because removing a black node can disturb the black-height rule.

Enroll Now Text Us Contact Code Scholars Full DSA Course

Student Focus

This topic is reserved for advanced students who need college-level balanced-tree detail.

Guided Lesson Notes

Understanding Deletion From a Red-Black Tree

Deletion From a Red-Black Tree focuses on hierarchical relationships, recursive subproblems, and shape rules that control performance. Deletion is the most complex red-black operation because removing a black node can disturb the black-height rule.

Model: draw nodes as parent-child relationships; every node is the root of a smaller tree with the same rules.

Invariant: the shape or ordering rule must hold at every node, not just near the root.

Implementation: recursive traversal, iterative queues for levels, search paths, rotations, splits, merges, or range-query recursion.

Use Deletion From a Red-Black Tree when the problem describes hierarchy, ancestry, subtrees, intervals, prefixes, sorted dynamic data, or range queries.

Visual Model

A small picture for Deletion From a Red-Black Tree

Key Ideas

BST deletion foundation
Double-black intuition
Sibling cases

Practice Prompts

Compare ordinary BST deletion with red-black deletion repair.
Explain why deletion has more cases than insertion.

Vocabulary

Terms students should be able to say clearly

Root

The top node where tree reasoning begins.

Leaf

A node with no children.

Height

The length of the longest downward path from a node.

Subtree

A node together with all descendants below it.

Traversal

A systematic order for visiting nodes.

Balance

A shape condition that keeps paths from becoming too long.

Worked Example

Worked example: tracing Deletion From a Red-Black Tree

Trace a small input, focusing on bst deletion foundation.

1Write a small input where Deletion From a Red-Black Tree is clearly useful.
2Label the part of the input related to BST deletion foundation.
3Perform one operation and explain which invariant is still true afterward.
4Run a second operation that touches an edge case, such as an empty side, duplicate value, boundary index, disconnected vertex, or tie.
5Finish by saying which operation dominates the runtime and why.

Complexity Check

Costs students should be able to explain

Operation	Typical Cost	Reason
Traversal	O(n)	Visiting every node takes time proportional to the number of nodes.
Balanced search	O(log n)	Balanced height keeps search paths short.
Unbalanced search	O(n)	A poor shape can behave like a linked list.

Common Mistakes

What to watch while practicing

Coding before drawing the structure or state changes.
Forgetting the invariant that makes the algorithm correct.
Testing only the sample input and skipping boundary cases.
Giving Big-O without explaining which operation dominates the work.

Interview-Style Coding Problem

Deletion From a Red-Black Tree interview problem: Diameter of a Tree

Interview medium

Problem

Given an undirected tree, find the number of edges on the longest path between any two nodes.

Input

The first line contains n. The next n - 1 lines contain edges u v using 1-based node labels.

Output

Print the tree diameter in edges.

Sample Input

Sample Output

Why the sample works

One longest path is 3-2-4-5-6, which uses four edges.

Approach

1Run BFS from any node to find a farthest endpoint.
2Run BFS again from that endpoint.
3The largest distance in the second BFS is the diameter.
4This works because a farthest node from any start is an endpoint of a longest path.

O(n) time and O(n) extra space.

Java Solution

import java.util.*;

public class Main {
  static int[] bfs(List<Integer>[] graph, int start) {
    int n = graph.length - 1;
    int[] dist = new int[n + 1];
    Arrays.fill(dist, -1);

    Queue<Integer> q = new ArrayDeque<>();
    q.add(start);
    dist[start] = 0;

    while (!q.isEmpty()) {
      int node = q.remove();
      for (int next : graph[node]) {
        if (dist[next] == -1) {
          dist[next] = dist[node] + 1;
          q.add(next);
        }
      }
    }

    int farthest = start;
    for (int i = 1; i <= n; i++) {
      if (dist[i] > dist[farthest]) farthest = i;
    }

    return new int[] {farthest, dist[farthest]};
  }

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    List<Integer>[] graph = new ArrayList[n + 1];
    for (int i = 1; i <= n; i++) graph[i] = new ArrayList<>();

    for (int i = 0; i < n - 1; i++) {
      int u = sc.nextInt();
      int v = sc.nextInt();
      graph[u].add(v);
      graph[v].add(u);
    }

    int endpoint = bfs(graph, 1)[0];
    int diameter = bfs(graph, endpoint)[1];
    System.out.println(diameter);
  }
}

Python Solution

from collections import deque

n = int(input())
graph = [[] for _ in range(n + 1)]
for _ in range(n - 1):
    u, v = map(int, input().split())
    graph[u].append(v)
    graph[v].append(u)

def bfs(start):
    dist = [-1] * (n + 1)
    dist[start] = 0
    q = deque([start])
    while q:
        node = q.popleft()
        for nxt in graph[node]:
            if dist[nxt] == -1:
                dist[nxt] = dist[node] + 1
                q.append(nxt)
    farthest = max(range(1, n + 1), key=lambda x: dist[x])
    return farthest, dist[farthest]

endpoint, _ = bfs(1)
_, diameter = bfs(endpoint)
print(diameter)

Practice Challenge

Make the idea your own

Create a two-minute explanation of Deletion From a Red-Black Tree: define it, trace one example, name one edge case, and give the runtime of the main operation.

Tutoring Connection

Need help with this topic?

Bring a question or code attempt to a tutoring session.

Reserve a Free Session Text Us Open Online Compiler