Chapter 9: Search Trees II

9.3 Multi-Way Search Trees

• A node v of an ordered tree is a d-node if v has d children.
  
• A multi-way search tree is an ordered tree such that:
• Each internal node v has at least two children (d-node with d >= 2 )
• v stores d − 1 key-element items (k_i, e_i)  (d is the number of children)
• For a node with children v₁, v₂, …, v_d storing keys k₁ < k_{2 <} … < k_d−1
• keys in the subtree of v₁ are less than k₁
• keys in the subtree of v_i are between k_i−1 and k_i (i = 2, …, d − 1)
• keys in the subtree of v_d are greater than k_d−1
• The leaves store no items and serve as placeholders

• We can extend the notion of inorder traversal from binary trees to multi-way search trees
• Namely, we visit item (k_i, e_i) of node v between the recursive traversals of the subtrees of v rooted at children v_i and v_i+1
• An inorder traversal of a multi-way search tree visits the keys in increasing order

Searching in a Multi-Way Tree
24Trees.pdf 5

• Similar to search in a binary search tree
• For each internal node with children v₁, v₂, …, v_d and keys k₁, k₂, …, k_d−1
• k = k_i (i = 1, …, d − 1): the search terminates successfully
• k < k₁: we continue the search in child v₁
• k_i−1 < k < k_i (i = 2, …, d − 1): we continue the search in child v_i
• k > k_d−1: we continue the search in child v_d
• Reaching an external node terminates the search unsuccessfully
• Example: search for 30

9.4 (2,4) Trees

• A (2,4) tree (also called 2-4 tree or 2-3-4 tree) is a multi-way search tree with the following properties
• Node-Size Property: every internal node has at most four children (and at least two)
  
• Depth Property: all the external nodes have the same depth
• Depending on the number of children, an internal node of a (2,4) tree is called a 2-node, 3-node or 4-node

• Theorem: A (2,4) tree storing n items has height O(log n)
• Proof:
• Let h be the height of a (2,4) tree with n items
• Since there are at least 2ⁱ items at depth i = 0, … , h −1 and no items at depth h, we have
  
  n ≥ 1 + 2 + 4 +… + 2^h−1 = 2^h − 1
• Thus, h ≤ log (n + 1)
• Searching in a (2,4) tree with n items takes O(log n) time

• We insert a new item (k, e) at the parent v of the leaf reached by searching for k
• We preserve the depth property but
• We may cause an overflow (i.e., node v may become a 5-node)
• Example: inserting key 30 causes an overflow

• We handle an overflowat a 5-node v with a split operation:
• let v₁, …, v₅ be the children of v and k₁, …, k₄ be the keys of v
• node v is replaced nodes v' and v"
• v' is a 3-node with keys k₁, k₂ and children v₁, v₂, v₃
• v" is a 2-node with key k₄ and children v₄, v₅
• key k₃ is inserted into the parent u of v (a new root may be created)
• The overflow may propagate to the parent node u

Algorithm insertItem(k, e) 1.We search for key k to locate the insertion node v 2.We add the new item (k, e) at node v 3. while overflow(v)         if isRoot(v)             create a new empty root above v         v ← split(v)

Analysis of Insertion in a (2,4) Tree
24Trees.pdf 10

• Let T be a (2,4) tree with n items
• Tree T has O(log n) height
• Searching takes O(log n) time because we visit O(log n) nodes
• Restoring Node-Size Property takes O(log n) time because each split takes O(1) time and we perform O(log n) splits
• Thus, an insertion in a (2,4) tree takes O(log n) time

• We reduce deletion of an item to the case where the item is at the node with leaf children
• Otherwise, we replace the item with its inorder successor (or, equivalently, with its inorder predecessor) and delete the latter item
• Example: to delete key 24, we replace it with 27 (inorder successor)

• Deleting an item from a node v may cause an underflow, where node v becomes a 1-node with one child and no keys
• To handle an underflow at node v with parent u, we consider two cases:
• Case 1: the adjacent siblings of v are 2-nodes
• Fusion operation:

1. we merge v with an adjacent sibling w
2. we move an item from u to the merged node v'

• Case 2: an adjacent sibling w of v is a 3-node or a 4-node
• Transfer operation:

1. we move a child of w to v
2. we move an item from u to v
3. we move an item from w to u

• Let T be a (2,4) tree with n items
• Tree T has O(log n) height
• In a deletion operation
• We visit O(log n) nodes to locate the node from which to delete the item
• We handle an underflow with a series of O(log n) fusions, followed by at most one transfer
• Each fusion and transfer takes O(1) time
• Thus, deleting an item from a (2,4) tree takes O(log n) time

9.5 Red-Black Trees

• A red-black tree is a representation of a (2,4) tree by means of a binary tree whose nodes are colored red or black
• In comparison with its associated (2,4) tree, a red-black tree has:
• same logarithmic time performance
• simpler implementation with a single node type

• A red-black tree can also be defined as a binary search tree that satisfies the following properties:
• Root Property: the root is black
• External Property: every leaf is black
• Internal Property: the children of a red node are black
• Depth Property: all the leaves have the same black depth

• Theorem: A red-black tree storing n items has height O(log n)
• Proof:
• The height of a red-black tree is at most twice the height of its associated (2,4) tree, which is O(log n)
• The search algorithm for a red-black tree is the same as that for a binary search tree
• By the above theorem, searching in a red-black tree takes O(log n) time

• To perform operation insertItem(k, e), we execute the insertion algorithm for binary search trees and color red the newly inserted node z unless it is the root
• We preserve the root, external, and depth properties
• If the parent v of z is black, we also preserve the internal property and we are done
• If the parent v of z is red, we have a double red (i.e., a violation of the internal property), which requires a reorganization of the tree
• Example where the insertion of 4 causes a double red:

• Consider a double red with child z and parent v, and let w be the sibling of v

	Case 1: w is black The double red is an incorrect replacement of a 4-node Restructuring: we change the 4-node replacement
	Case 2: w is red The double red corresponds to an overflow Recoloring: we perform the equivalent of a split

• Case 1: A restructuring remedies a child-parent double red when the parent red node has a black sibling
• It is equivalent to restoring the correct replacement of a 4-node
• The internal property is restored and the other properties are preserved

• There are four restructuring configurations depending on whether the double red nodes are left or right children

• Case 2: A recoloring remedies a child-parent double red when the parent red node has a red sibling:
• The parent v and its sibling w become black and the grandparent u becomes red, unless it is the root
• It is equivalent to performing a split on a 5-node
• The double red violation may propagate to the grandparent u

• Recall that a red-black tree has O(log n) height
• Step 1 takes O(log n) time because we visit O(log n) nodes
• Step 2 takes O(1) time
• Step 3 takes O(log n) time because we perform
• O(log n) recolorings, each taking O(1) time, and
• at most one restructuring taking O(1) time
• Thus, an insertion in a red-black tree takes O(log n) time

• To perform operation remove(k), we first execute the deletion algorithm for binary search trees
• Let v be the internal node removed, w the external node removed, and r the sibling of w
• If either v or r was red, we color r black and we are done
• If v and r were both black, we color r double black, which is a violation of the depth property requiring a reorganization of the tree
• Example where the deletion of 8 causes a double black:

• The algorithm for remedying a double black node r with sibling y considers three cases
• Case 1: y is black and has a red child
• We perform a restructuring, equivalent to a transfer, and we are done

• Case 2: y is black and its children are both black
• We perform a recoloring, equivalent to a fusion, which may propagate up the double black violation
• Case 3: y is red
• We perform an adjustment, equivalent to choosing a different representation of a 3-node, after which either Case 1 or Case 2 applies
• Deletion in a red-black tree takes O(log n) time