1. Multi-Way search Trees
1. 2-3 Trees:
a. Nodes may contain 1 or 2 items.
b. A node with k items has k + 1 children
c. All leaves are on same level.

2. Example
• A 2-3 tree storing 18 items.
20 80
30 70
5
2 4
10
25
40 50 75
90 100
85
95 110 120

3. Updating
• Insertion:
• Find the appropriate leaf. If there is only
one item, just add to leaf.
• Insert(23); Insert(15)
• If no room, move middle item to parent and
split remaining two items among two
children.
• Insert(3);

4. Insertion
• Insert(3);
20 80
5
2 3 4
10 15
30 70
23 25 40 50 75
90 100
85
95 110 120

5. Insert(3);
• In mid air…
20 80
5
30 70
90 100
3
2
4
10 15 23 25 40 50 75
85
95 110 120

6. Done….
20 80
3 5
2
30 70
4 10 15 23 25
40 50 75
90 100
85
95 110 120

7. Tree grows at the root…
• Insert(45);
20 80
3 5
2
4
30 70
10
25 40 45 50 75
90 100
85
95 110 120

8. • New root:
45
20
3 5
2
4
80
30
10
25 40
70
50
90 100
75
85
95 110 120

9. Delete
• If item is not in a leaf exchange with inorder successor.
• If leaf has another item, remove item.
• Examples: Remove(110);
• (Insert(110); Remove(100); )
• If leaf has only one item but sibling has two
items: redistribute items. Remove(80);

10. Remove(80);
• Step 1: Exchange 80 with in-order
successor.
45
20
3 5
2
4
85
30
10
25 40
70
50
90 100
75
80
95
110 120

11. • RedistributeRemove(80);
45
20
3 5
2
4
85
30
10
25 40
70
50
95 110
75
90
100
120

12. Some more removals…
• Remove(70);
Swap(70, 75);
Remove(70);
“Merge” Empty node with sibling;
Join parent with node;
Now every node has k+1 children except that one
node has 0 items and one child.
Sibling 95 110 can spare an item: redistribute.

13. Delete(70)
45
20
3 5
2
4
85
30
10
25 40
75
50
95 110
90
100
120

14. New tree:
• Delete(85) will “shrink” the tree.
45
20
3 5
2
4
95
30
10
85
25 40 50
110
90
100
120

15. Details
•
•
•
•
•
1. Swap(85, 90) //inorder successor
2. Remove(85) //empty node created
3. Merge with sibling
4. Drop item from parent// (50,90) empty Parent
5. Merge empty node with sibling, drop item from
parent (95)
• 6. Parent empty, merge with sibling drop item.
Parent (root) empty, remove root.

16. “Shorter” 2-3 Tree
20 45
3 5
2
4
30
10
25 40
95 110
50 90
100
120

17. Deletion Summary
• If item k is present but not in a leaf, swap
with inorder successor;
• Delete item k from leaf L.
• If L has no items: Fix(L);
• Fix(Node N);
• //All nodes have k items and k+1 children
• // A node with 0 items and 1 child is
possible, it will have to be fixed.

18. Deletion (continued)
• If N is the root, delete it and return its child
as the new root.
• Example: Delete(8);
5
5
1
3
2
8
3
3
Return
35
35

19. Deletion (Continued)
• If a sibling S of N has 2 items distribute
items among N, S and the parent P; if N is
internal, move the appropriate child from S
to N.
• Else bring an item from P into S;
• If N is internal, make its (single) child the
child of S; remove N.
• If P has no items Fix(P) (recursive call)

20. (2,4) Trees
• Size Property: nodes may have 1,2,3 items.
• Every node, except leaves has size+1
children.
• Depth property: all leaves have the same
depth.
• Insertion: If during the search for the leaf
you encounter a “full” node, split it.

21. (2,4) Tree
10
3 8
45
25
60
50 55
70 90 100

22. Insert(38);
Insert(38);
45
10
60
3 8
25 38
50 55
70 90 100

23. Insert(105)
• Insert(105);
45
10
3 8
25 38
60 90
50 55
70
100 105

24. Removal
• As with BS trees, we may place the node to
be removed in a leaf.
• If the leaf v has another item, done.
• If not, we have an UNDERFLOW.
• If a sibling of v has 2 or 3 items, transfer an
item.
• If v has 2 or 3 siblings we perform a
transfer

25. Removal
• If v has only one sibling with a single item
we drop an item from the parent to the
sibling, remove v. This may create an
underflow at the parent. We “percolate” up
the underflow. It may reach the root in
which case the root will be discarded and
the tree will “shrink”.

26. Delete(15)
35
20
6
60
15
40 50
70 80 90

27. Delete(15)
35
20
6
60
40 50
70 80 90

28. Continued
• Drop item from parent
35
60
6 20
40 50
70 80 90

29. Fuse
35
60
6 20
40 50
70 80 90

30. Drop item from root
• Remove root, return the child.
35 60
6 20
40 50
70 80 90

31. Summary
• Both 2-3 trees and 2-4 trees make it very
easy to maintain balance.
• Insertion and deletion easier for 2-4 tree.
• Cost is waste of space in each node. Also
extra comparison inside each node.
• Does not “extend” binary trees.

32. Red-Black Trees
• Root property: Root is BLACK.
• External Property: Every external node is
BLACK (external nodes: null nodes)
• Internal property: Children of a RED node
are BLACK.
• Depth property: All external nodes have the
same BLACK depth.

33. A RedBlack tree.
Black depth 3.
30
15
10
70
20
85
60
5
50
40
65
55
80
90

34. RedBlack
Insertion

35. Red Black Trees, Insertion
1. Find proper external node.
2. Insert and color node red.
3. No black depth violation but may violate
the red-black parent-child relationship.
4. Let: z be the inserted node, v its parent
and u its grandparent. If v is red then u
must be black.

36. Color adjustments.
• Red child, red parent. Parent has a black
sibling (Zig-Zag).
a
b
u
w
v
z
Vl
Zl
Zr

37. Rotation
• Z-middle key. Black height does not
change! No more red-red.
a
b
z
u
v
Vl
Zl
Zr
w

38. Color adjustment II
a
b
u
w
v
Vr
z
Zl
Zr

39. Rotation II
• v-middle key
a
b
v
u
z
Zl
Zr
Vr
w

40. Recoloring
• Red child, red parent. Parent has a red
sibling.
a
b
u
w
v
z
Vl
Zr

41. Color adjustment
• Red-red may move up…
a
b
u
w
v
z
Vl
Zl
Zr

42. Red Black Tree
• Insert 10 – root
10

43. Red Black Tree
• Insert 10 – root (external nodes not shown)
10

44. Red Black Tree
• Insert 85
10
85

45. Red Black Tree
• Insert 15
10
85
15

46. Red Black Tree
• Rotate – Change colors
15
10
85

47. Red Black Tree
• Insert 70
15
10
85
70

48. Red Black Tree
• Change Color
15
10
85
70

49. Red Black Tree
• Insert 20 (sibling of parent is black)
15
10
85
70
20

50. Red Black Tree
• Rotate
15
10
70
20
85

51. Red Black Tree
• Insert 60 (sibling of parent is red)
15
10
70
85
20
60

52. Red Black Tree
• Change Color
15
10
70
85
20
60

53. Red Black Tree
• Insert 30 (sibling of parent is black)
15
10
70
85
20
60
30

54. Red Black Tree
• Rotate
15
10
70
85
30
20
60

55. Red Black Tree
• Insert 50 (sibling ?)
15
10
70
85
30
20
60
50

56. Red Black Tree
• Insert 50 (sibling of 70 is black!)
15
gramps 15
10
70
Child  30
Oops, red-red.
ROTATE!
85
30
20
60
50
 Parent 70

57. Red Black Tree
• Double Rotate – Adjust colors
30
15
10
Child-Parent-Gramps
70
20
60
50
Middle goes to “top”
Previous top becomes child. Its right
85

58. Red Black Tree
• Insert 65
30
15
10
70
20
85
60
50
65

59. Red Black Tree
• Insert 80
30
15
10
70
20
85
60
50
65
80

60. Red Black Tree
• Insert 90
30
15
10
70
20
85
60
50
65
80
90

61. Red Black Tree
• Insert 40
30
15
10
70
20
85
60
50
40
65
80
90

62. Red Black Tree
• Adjust color
30
15
10
70
20
85
60
50
40
65
80
90

63. Red Black Tree
• Insert 5
30
15
10
70
20
85
60
5
50
40
65
80
90

64. Red Black Tree
• Insert 55
30
15
10
70
20
85
60
5
50
40
65
55
80
90

65. Delete
• We first note that a red node is either a leaf or
must have two children.
• Also, if a black node has a single child it must be a
red leaf.
• Swap X with inorder successor.
• If inorder successor is red, (must be a leaf) delete.
If it is a single child parent, delete and change its
child color to black. In both cases the resulting
tree is a legit red-black tree.

66. Delete demo
• Delete 30: Swap with 40 and delete red leaf.
30
15
10
70
20
85
60
5
50
40
65
55
80
90

67. 40
15
10
5
70
20
85
60
50
65
55
80
90

68. Inorder successor is Black
Change colors along the traverse path so that the leaf to
be deleted is RED.
Delete 15.
30
15
10
70
20
85
60
5
50
40
65
55
80
90

69. General strategy
• As you traverse the tree to locate the
inorder successor let X be the current node,
T its sibling and P the parent.
• Color the root red.
• Retain: “the color of P is red.”
• If all children of X and T are black:
• P  Black, X  Red, T  Red

70. P
X
A
Both children of X and T are black:
P  Black X  Red, T  Red
T
B

71. P
X
A
T
B
If X is a leaf we are done. Recall: x is the inorder
successor!

72. Even though we
Even though we
want to proceed
want to proceed
with X we have aa
with X we have
red-red violation
red-red violation
that needs to be
that needs to be
fixed.
fixed.
P
T has aared child.
T has red child.
X
T
C1
A
D
B
Zig-Zag, C1 Middle key.
C

73. Note: black
Note: black
depth remains
depth remains
unchanged!
unchanged!
C1
P
T
X
A
B
C
D

74. B will become P’s
B will become P’s
right child. No
right child. No
change in depth.
change in depth.
Third case
P
X
T
C1
A
B
C
T middle key.
D

75. T
C1
P
X
A
B
C
D

76. • If both children of T are red select one of
the two rotations.
• If the right child of X is red make it the new
parent (it is on the inorder-successor path).
• If the left child of X is red:

77. Root of C is black
Root of C is black
Otherwise, continue
Otherwise, continue
X has aared child
X has red child
P
X
C1
C
B
Y
A
B
Left as a drill.
T
E

78. P
C1
T
X
E
Y
A
B
C

79. 30
Delete 15
15
10
70
20
85
60
5
50
40
65
55
80
90

80. 60
Delete 15
30
70
15
10
50
20
40
80
55
30
70
20
10
5
50
15
90
60
Swap (15, 20)
5
85
65
40
85
65
55
80
90

81. 60
Delete 15
30
70
20
10
50
15
40
85
65
55
80
90
5
Third case: (mirror image) X (15) has two black children (Nulls)
Sibling has one red and one black child.

82. 60
Delete 15
30
70
10
5
50
20
40
85
65
55
80
90