1. Data Structures and Algorithms
Course’s slides: Hierarchical data structures

2. Trees Linear access time of linked lists is prohibitive
Does there exist any simple data structure for which the running time of most operations (search, insert, delete) is O(log N)?

3. Trees A tree is a collection of nodes The collection can be empty
(recursive definition) If not empty, a tree consists of a distinguished node r (the root), and zero or more nonempty subtrees T1, T2, ...., Tk, each of whose roots are connected by a directed edge from r

4. Some Terminologies Child and parent Leaves Sibling
Every node except the root has one parent 
A node can have an arbitrary number of children
Leaves
Nodes with no children
Sibling
nodes with same parent

5. Some Terminologies Path Length Depth of a node Height of a node
number of edges on the path
Depth of a node
length of the unique path from the root to that node
The depth of a tree is equal to the depth of the deepest leaf
Height of a node
length of the longest path from that node to a leaf
all leaves are at height 0
The height of a tree is equal to the height of the root
Ancestor and descendant
Proper ancestor and proper descendant

6. Example: UNIX Directory

7. Binary Trees A tree in which no node can have more than two children
The depth of an “average” binary tree is considerably smaller than N, eventhough in the worst case, the depth can be as large as N – 1.

8. Example: Expression Trees
Leaves are operands (constants or variables)
The other nodes (internal nodes) contain operators
Will not be a binary tree if some operators are not binary

9. Tree traversal Used to print out the data in a tree in a certain order
Pre-order traversal
Print the data at the root
Recursively print out all data in the left subtree
Recursively print out all data in the right subtree

10. Preorder, Postorder and Inorder
Preorder traversal
node, left, right
prefix expression
++a*bc*+*defg

11. Preorder, Postorder and Inorder
Postorder traversal
left, right, node
postfix expression
abc*+de*f+g*+
Inorder traversal
left, node, right.
infix expression
a+b*c+d*e+f*g

12. Preorder, Postorder and Inorder

13. Binary Trees Possible operations on the Binary Tree ADT Implementation
parent
left_child, right_child
sibling
root, etc
Implementation
Because a binary tree has at most two children, we can keep direct pointers to them

14. Compare: Implementation of a general tree

15. Binary Search Trees
Stores keys in the nodes in a way so that searching, insertion and deletion can be done efficiently.
Binary search tree property
For every node X, all the keys in its left subtree are smaller than the key value in X, and all the keys in its right subtree are larger than the key value in X

16. Binary Search Trees
A binary search tree
Not a binary search tree

17. Binary search trees
Two binary search trees representing
the same set:
Average depth of a node is O(log N); maximum depth of a node is O(N)

18. Searching BST If we are searching for 15, then we are done.
If we are searching for a key < 15, then we should search in the left subtree.
If we are searching for a key > 15, then we should search in the right subtree.

19. Inorder traversal of BST
Print out all the keys in sorted order
Inorder: 2, 3, 4, 6, 7, 9, 13, 15, 17, 18, 20

20. findMin/findMax
Return the node containing the smallest element in the tree
Start at the root and go left as long as there is a left child. The stopping point is the smallest element
Similarly for findMax
Time complexity = O(height of the tree)

21. Insert Proceed down the tree as you would with a find
If X is found, do nothing (or update something)
Otherwise, insert X at the last spot on the path traversed
Time complexity = O(height of the tree)

22. Delete
When we delete a node, we need to consider how we take care of the children of the deleted node.
This has to be done such that the property of the search tree is maintained.

23. Delete Three cases: (1) the node is a leaf Delete it immediately
(2) the node has one child
Adjust a pointer from the parent to bypass that node

24. Delete (3) the node has 2 children
replace the key of that node with the minimum element at the right subtree
delete the minimum element
Has either no child or only right child because if it has a left child, that left child would be smaller and would have been chosen. So invoke case 1 or 2
Time complexity = O(height of the tree)

25. Binary search tree – best time
All BST operations are O(d), where d is tree depth
minimum d is for a binary tree with N nodes
What is the best case tree?
What is the worst case tree?
So, best case running time of BST operations is O(log N)
AVL Trees - Lecture 8
12/26/03

26. Binary Search Tree - Worst Time
Worst case running time is O(N)
What happens when you insert elements in ascending order?
Insert: 2, 4, 6, 8, 10, 12 into an empty BST
Problem: Lack of “balance”:
compare depths of left and right subtree
Unbalanced degenerate tree
AVL Trees - Lecture 8
12/26/03

27. Balanced and unbalanced BST1 4 2 2 5 3 1 3 4 4
Is this “balanced”? 5 2 6 6 1 3 5 7 7
AVL Trees - Lecture 8
12/26/03

28. Approaches to balancing trees
Don't balance
May end up with some nodes very deep
Strict balance
The tree must always be balanced perfectly
Pretty good balance
Only allow a little out of balance
Adjust on access
Self-adjusting
AVL Trees - Lecture 8
12/26/03

29. Balancing binary search trees
Many algorithms exist for keeping binary search trees balanced
Adelson-Velskii and Landis (AVL) trees (height- balanced trees)
Splay trees and other self-adjusting trees
B-trees and other multiway search trees
AVL Trees - Lecture 8
12/26/03

30. Perfect balance Want a complete tree after every operation
tree is full except possibly in the lower right
This is expensive
For example, insert 2 in the tree on the left and then rebuild as a complete tree 6 5
Insert 2 &
complete tree 4 9 2 8 1 5 8 1 4 6 9
AVL Trees - Lecture 8
12/26/03

31. AVL - good but not perfect balance
AVL trees are height-balanced binary search trees
Balance factor of a node
height(left subtree) - height(right subtree)
An AVL tree has balance factor calculated at every node
For every node, heights of left and right subtree can differ by no more than 1
Store current heights in each node
AVL Trees - Lecture 8
12/26/03

32. Height of an AVL tree
N(h) = minimum number of nodes in an AVL tree of height h.
Basis
N(0) = 1, N(1) = 2
Induction
N(h) = N(h-1) + N(h-2) + 1
Solution (recall Fibonacci analysis)
N(h) > h (  1.62) h
h-2
h-1
AVL Trees - Lecture 8
12/26/03

33. Height of an AVL Tree N(h) > h (  1.62)
Suppose we have n nodes in an AVL tree of height h.
n > N(h) (because N(h) was the minimum)
n > h hence log n > h (relatively well balanced tree!!)
h < 1.44 log2n (i.e., Find takes O(logn))
AVL Trees - Lecture 8
12/26/03

34. Node Heights 6 6 4 9 4 9 1 5 1 5 8 height of node = h
Tree A (AVL)
Tree B (AVL)
height=2 BF=1-0=1 2 6 6 1 1 1 4 9 4 9 1 5 1 5 8
height of node = h
balance factor = hleft-hright
empty height = -1
AVL Trees - Lecture 8
12/26/03

35. Node heights after insert 7
Tree A (AVL)
Tree B (not AVL)
balance factor
1-(-1) = 2 2 3 6 6 1 1 1 2 4 9 4 9 -1 1 1 5 7 1 5 8 7
height of node = h
balance factor = hleft-hright
empty height = -1
AVL Trees - Lecture 8
12/26/03

36. Insert and rotation in AVL trees
Insert operation may cause balance factor to become 2 or – 2 for some node
only nodes on the path from insertion point to root node have possibly changed in height
So after the Insert, go back up to the root node by node, updating heights
If a new balance factor (the difference hleft-hright) is 2 or –2, adjust tree by rotation around the node
AVL Trees - Lecture 8
12/26/03

37. Single Rotation in an AVL Tree2 2 6 6 1 2 1 1 4 9 4 8 1 1 5 8 1 5 7 9 7
AVL Trees - Lecture 8
12/26/03

38. Insertions in AVL trees
Let the node that needs rebalancing be .
There are 4 cases:
Outside Cases (require single rotation) :
1. Insertion into left subtree of left child of .
2. Insertion into right subtree of right child of .
Inside Cases (require double rotation) :
3. Insertion into right subtree of left child of .
4. Insertion into left subtree of right child of .
The rebalancing is performed through four separate rotation algorithms.
AVL Trees - Lecture 8
12/26/03

39. AVL insertion: outside casej
Consider a valid
AVL subtree k h Z h h X Y
AVL Trees - Lecture 8
12/26/03

40. AVL Insertion: Outside Casej
Inserting into X
destroys the AVL
property at node j k h Z
h+1 h Y X
AVL Trees - Lecture 8
12/26/03

41. AVL Insertion: Outside Casej
Do a “right rotation” k h Z
h+1 h Y X
AVL Trees - Lecture 8
12/26/03

42. j k Z Y X Single right rotation Do a “right rotation” h h+1 h
AVL Trees - Lecture 8
12/26/03

43. Outside Case Completedk
“Right rotation” done!
(“Left rotation” is mirror
symmetric) j
h+1 h h X Z Y
AVL property has been restored!
AVL Trees - Lecture 8
12/26/03

44. AVL Insertion: Inside Casej
Consider a valid
AVL subtree k h Z h h X Y
AVL Trees - Lecture 8
12/26/03

45. AVL Insertion: Inside Casej
Inserting into Y
destroys the
AVL property
at node j
Does “right rotation”
restore balance? k h Z h
h+1 X Y
AVL Trees - Lecture 8
12/26/03

46. AVL Insertion: Inside Casek
“Right rotation”
does not restore
balance… now k is
out of balance j h X h
h+1 Z Y
AVL Trees - Lecture 8
12/26/03

47. AVL Insertion: Inside Casej
Consider the structure
of subtree Y… k h Z h
h+1 X Y
AVL Trees - Lecture 8
12/26/03

48. AVL Insertion: Inside Casej
Y = node i and
subtrees V and W k h Z i h
h+1 X
h or h-1 V W
AVL Trees - Lecture 8
12/26/03

49. AVL Insertion: Inside Casej
We will do a left-right
“double rotation” . . . k Z i X V W
AVL Trees - Lecture 8
12/26/03

50. Double rotation : first rotationj
left rotation complete i Z k W V X
AVL Trees - Lecture 8
12/26/03

51. Double rotation : second rotationj
Now do a right rotation i Z k W V X
AVL Trees - Lecture 8
12/26/03

52. Double rotation : second rotation
right rotation complete
Balance has been
restored i k j h h
h or h-1 V X W Z
AVL Trees - Lecture 8
12/26/03

53. Implementation
balance (1,0,-1)
key
left
right
No need to keep the height; just the difference in height, i.e. the balance factor; this has to be modified on the path of insertion even if you don’t perform rotations
Once you have performed a rotation (single or double) you won’t need to go back up the tree
AVL Trees - Lecture 8
12/26/03

54. Single Rotation RotateFromRight(n : reference node pointer) {
p : node pointer;
p := n.right;
n.right := p.left;
p.left := n;
n := p } n X
You also need to modify the heights or balance factors of n and p Y Z
Insert
AVL Trees - Lecture 8
12/26/03

55. Double Rotation Implement Double Rotation in two lines.
DoubleRotateFromRight(n : reference node pointer) {
???? } n X Z V W
AVL Trees - Lecture 8
12/26/03

56. Insertion in AVL Trees Insert at the leaf (as for all BST)
only nodes on the path from insertion point to root node have possibly changed in height
So after the Insert, go back up to the root node by node, updating heights
If a new balance factor (the difference hleft-hright) is 2 or –2, adjust tree by rotation around the node
AVL Trees - Lecture 8
12/26/03

57. Insert in BST
Insert(T : reference tree pointer, x : element) : integer {
if T = null then
T := new tree; T.data := x; return 1;//the links to //children are null
case
T.data = x : return 0; //Duplicate do nothing
T.data > x : return Insert(T.left, x);
T.data < x : return Insert(T.right, x);
endcase }
AVL Trees - Lecture 8
12/26/03

58. Insert in AVL trees
Insert(T : reference tree pointer, x : element) : {
if T = null then
{T := new tree; T.data := x; height := 0; return;}
case
T.data = x : return ; //Duplicate do nothing
T.data > x : Insert(T.left, x);
if ((height(T.left)- height(T.right)) = 2){
if (T.left.data > x ) then //outside case
T = RotatefromLeft (T);
else //inside case
T = DoubleRotatefromLeft (T);}
T.data < x : Insert(T.right, x);
code similar to the left case
Endcase
T.height := max(height(T.left),height(T.right)) +1;
return; }
AVL Trees - Lecture 8
12/26/03

59. Example of Insertions in an AVL Tree2 20
Insert 5, 40 1 10 30 25 35
AVL Trees - Lecture 8
12/26/03

60. Example of Insertions in an AVL Tree2 3 20 20 1 1 1 2 10 30 10 30 1 5 25 35 5 25 35 40
Now Insert 45
AVL Trees - Lecture 8
12/26/03

61. Single rotation (outside case)3 3 20 20 1 2 1 2 10 30 10 30 2 1 5 25 35 5 25 40 35 45 40 1
Imbalance 45
Now Insert 34
AVL Trees - Lecture 8
12/26/03

62. Double rotation (inside case)3 3 20 20 1 3 1 2 10 30 10 35 2 1 1 5
Imbalance 25 40 5 30 40 25 34 1 45 35 45
Insertion of 34 34
AVL Trees - Lecture 8
12/26/03

63. AVL Tree Deletion Similar but more complex than insertion
Rotations and double rotations needed to rebalance
Imbalance may propagate upward so that many rotations may be needed.
AVL Trees - Lecture 8
12/26/03

64. Pros and Cons of AVL Trees
Arguments for AVL trees:
Search is O(log N) since AVL trees are always balanced.
Insertion and deletions are also O(logn)
The height balancing adds no more than a constant factor to the speed of insertion.
Arguments against using AVL trees:
Difficult to program & debug; more space for balance factor.
Asymptotically faster but rebalancing costs time.
Most large searches are done in database systems on disk and use other structures (e.g. B-trees).
May be OK to have O(N) for a single operation if total run time for many consecutive operations is fast (e.g. Splay trees).
AVL Trees - Lecture 8
12/26/03

65. Double Rotation Solution
DoubleRotateFromRight(n : reference node pointer) {
RotateFromLeft(n.right);
RotateFromRight(n); } n X Z V W
AVL Trees - Lecture 8
12/26/03

66. Outline
Balanced Search Trees
2-3 Trees
2-3-4 Trees
Red-Black Trees

67. Why care about advanced implementations?
Same entries, different insertion sequence:
 Not good! Would like to keep tree balanced.

68. 2-3 Trees each internal node has either 2 or 3 children
Features
each internal node has either 2 or 3 children
all leaves are at the same level

69. 2-3 Trees with Ordered Nodes
leaf node can be either a 2-node or a 3-node

70. Example of 2-3 Tree

71. Traversing a 2-3 Tree inorder(in ttTree: TwoThreeTree)
if(ttTree’s root node r is a leaf)
visit the data item(s)
else if(r has two data items) {
inorder(left subtree of ttTree’s root)
visit the first data item
inorder(middle subtree of ttTree’s root)
visit the second data item
inorder(right subtree of ttTree’s root) }
else
visit the data item

72. Searching a 2-3 tree retrieveItem(in ttTree: TwoThreeTree,
in searchKey:KeyType,
out treeItem:TreeItemType):boolean
if(searchKey is in ttTree’s root node r) {
treeItem = the data portion of r
return true }
else if(r is a leaf)
return false
else
return retrieveItem( appropriate subtree,
searchKey, treeItem)

73. What did we gain?
What is the time efficiency of searching for an item?

74. Gain: Ease of Keeping the Tree Balanced
Binary Search
Tree
both trees after
inserting items
39, 38,
2-3 Tree

75. Inserting Items
Insert 39

76. Inserting Items Insert 38 divide leaf and move middle result
value up to parent
insert in leaf
result

77. Inserting Items
Insert 37

78. Inserting Items Insert 36 divide leaf and move middle
value up to parent
insert in leaf
overcrowded
node

79. Inserting Items ... still inserting 36 divide overcrowded node,
move middle value up to parent,
attach children to smallest and largest
result

80. Inserting Items
After Insertion of 35, 34, 33

81. Inserting so far

82. Inserting so far

83. Inserting Items
How do we insert 32?

84. Inserting Items creating a new root if necessary
tree grows at the root

85. Inserting Items
Final Result

86. Deleting Items
Delete 70 70 80

87. Deleting Items
Deleting 70: swap 70 with inorder successor (80)

88. Deleting Items
Deleting 70: ... get rid of 70

89. Deleting Items
Result

90. Deleting Items
Delete 100

91. Deleting Items
Deleting 100

92. Deleting Items
Result

93. Deleting Items
Delete 80

94. Deleting Items
Deleting

95. Deleting Items
Deleting

96. Deleting Items
Deleting

97. Deleting Items
Final Result
comparison with
binary search tree

98. Deletion Algorithm I Locate node n, which contains item I
Deleting item I:
Locate node n, which contains item I
If node n is not a leaf  swap I with inorder successor
deletion always begins at a leaf
If leaf node n contains another item, just delete item I else try to redistribute nodes from siblings (see next slide) if not possible, merge node (see next slide)

99. Deletion Algorithm II Redistribution A sibling has 2 items:
redistribute item between siblings and parent
Merging
No sibling has 2 items:
merge node
move item from parent to sibling

100. Deletion Algorithm III
Redistribution
Internal node n has no item left
redistribute
Merging
Redistribution not possible:
merge node
move item from parent to sibling
adopt child of n
If n's parent ends up without item, apply process recursively

101. Deletion Algorithm IV
If merging process reaches the root and root is without item
 delete root

102. Operations of 2-3 Trees
all operations have time complexity of log n

103. 2-3-4 Trees similar to 2-3 trees
4-nodes can have 3 items and 4 children
4-node

104. 2-3-4 Tree example

105. 2-3-4 Tree: Insertion Insertion procedure:
similar to insertion in 2-3 trees
items are inserted at the leafs
since a 4-node cannot take another item, 4-nodes are split up during insertion process
Strategy
on the way from the root down to the leaf: split up all 4-nodes "on the way"
 insertion can be done in one pass (remember: in 2-3 trees, a reverse pass might be necessary)

106. 2-3-4 Tree: Insertion
Inserting 60, 30, 10, 20, 50, 40, 70, 80, 15, 90, 100

107. 2-3-4 Tree: Insertion
Inserting 60, 30, 10,
... 50,

108. 2-3-4 Tree: Insertion
Inserting 50,
... 70, ...

109. 2-3-4 Tree: Insertion
Inserting
... 80,

110. 2-3-4 Tree: Insertion
Inserting 80,

111. 2-3-4 Tree: Insertion
Inserting

112. 2-3-4 Tree: Insertion
Inserting

113. 2-3-4 Tree: Insertion Procedure
Splitting 4-nodes during Insertion

114. 2-3-4 Tree: Insertion Procedure
Splitting a 4-node whose parent is a 2-node during insertion

115. 2-3-4 Tree: Insertion Procedure
Splitting a 4-node whose parent is a 3-node during insertion

116. 2-3-4 Tree: Deletion Deletion procedure:
similar to deletion in 2-3 trees
items are deleted at the leafs  swap item of internal node with inorder successor
note: a 2-node leaf creates a problem
Strategy (different strategies possible)
on the way from the root down to the leaf: turn 2-nodes (except root) into 3-nodes
 deletion can be done in one pass (remember: in 2-3 trees, a reverse pass might be necessary)

117. 2-3-4 Tree: Deletion Case 1: an adjacent sibling has 2 or 3 items
Turning a 2-node into a 3-node ...
Case 1: an adjacent sibling has 2 or 3 items
"steal" item from sibling by rotating items and moving subtree
30 50
10 20 40 25
20 50 10
30 40 25
"rotation"

118. 2-3-4 Tree: Deletion Turning a 2-node into a 3-node ...
Case 2: each adjacent sibling has only one item
 "steal" item from parent and merge node with sibling (note: parent has at least two items, unless it is the root)
30 50 50 10 40
merging 25 35 25 35

119. 2-3-4 Tree: Deletion Practice
Delete 32, 35, 40, 38, 39, 37, 60

120. Red-Black Tree binary-search-tree representation of 2-3-4 tree
3- and 4-nodes are represented by equivalent binary trees
red and black child pointers are used to distinguish between original 2-nodes and 2-nodes that represent 3- and 4-nodes

121. Red-Black Representation of 4-node

122. Red-Black Representation of 3-node

123. Red-Black Tree Example

124. Red-Black Tree Example

125. Red-Black Tree Operations
Traversals
same as in binary search trees
Insertion and Deletion
analog to tree
need to split 4-nodes
need to merge 2-nodes

126. Splitting a 4-node that is a root

127. Splitting a 4-node whose parent is a 2-node

128. Splitting a 4-node whose parent is a 3-node

129. Splitting a 4-node whose parent is a 3-node

130. Splitting a 4-node whose parent is a 3-node

131. Motivation for B-Trees
So far we have assumed that we can store an entire data structure in main memory
What if we have so much data that it won’t fit?
We will have to use disk storage but when this happens our time complexity fails
The problem is that Big-Oh analysis assumes that all operations take roughly equal time
This is not the case when disk access is involved

132. Motivation (cont.) Assume that a disk spins at 3600 RPM
In 1 minute it makes 3600 revolutions, hence one revolution occurs in 1/60 of a second, or 16.7ms
On average what we want is half way round this disk – it will take 8ms
This sounds good until you realize that we get 120 disk accesses a second – the same time as 25 million instructions
In other words, one disk access takes about the same time as 200,000 instructions
It is worth executing lots of instructions to avoid a disk access

133. Motivation (cont.)
Assume that we use an Binary tree to store all the details of people in Canada (about 32 million records)
We still end up with a very deep tree with lots of different disk accesses; log2 20,000,000 is about 25, so this takes about seconds (if there is only one user of the program)
We know we can’t improve on the log n for a binary tree
But, the solution is to use more branches and thus less height!
As branching increases, depth decreases

134. Definition of a B-tree
A B-tree of order m is an m-way tree (i.e., a tree where each node may have up to m children) in which:
1. the number of keys in each non-leaf node is one less than the number of its children and these keys partition the keys in the children in the fashion of a search tree
2. all leaves are on the same level
3. all non-leaf nodes except the root have at least m / 2 children
4. the root is either a leaf node, or it has from two to m children
5. a leaf node contains no more than m – 1 keys
The number m should always be odd

135. An example B-Tree A B-tree of order 5 containing 26 items 26 6 12 4251 62 1 2 4 7 8 13 15 18 25 27 29 45 46 48 53 55 60 64 70 90
Note that all the leaves are at the same level

136. Constructing a B-tree
Suppose we start with an empty B-tree and keys arrive in the following order:
We want to construct a B-tree of order 5
The first four items go into the root:
To put the fifth item in the root would violate condition 5
Therefore, when 25 arrives, pick the middle key to make a new root 1 2 8 12

137. Constructing a B-tree 1 2 8 12 25 Add 25 to the tree
Exceeds Order. Promote middle and split. 1 2 8 12 25

138. Constructing a B-tree (contd.)8 1 2 12 25
6, 14, 28 get added to the leaf nodes: 8 1 2 1 6 2 12 14 25 28

139. Constructing a B-tree (contd.)
Adding 17 to the right leaf node would over-fill it, so we take the middle key, promote it (to the root) and split the leaf 8 1 2 6 2 12 14 17 25 28 28

140. Constructing a B-tree (contd.)
7, 52, 16, 48 get added to the leaf nodes 8 17 1 2 7 6 12 14 16 25 28 48 52

141. Constructing a B-tree (contd.)
Adding 68 causes us to split the right most leaf, promoting 48 to the root 8 17 1 2 6 7 12 14 16 25 28 48 52 68

142. Constructing a B-tree (contd.)
Adding 3 causes us to split the left most leaf 8 17 48 1 3 2 6 7 7 12 14 16 25 28 52 68

143. Constructing a B-tree (contd.)
Add 26, 29, 53, 55 then go into the leaves 3 8 17 48 1 2 6 7 12 14 16 25 26 28 29 52 53 68 55

144. Constructing a B-tree (contd.)
Add 45 increases the trees level
Exceeds Order. Promote middle and split.
Exceeds Order. Promote middle and split. 3 8 17 48 1 2 6 7 12 14 16 25 26 28 29 45 52 53 55 68

145. Inserting into a B-Tree
Attempt to insert the new key into a leaf
If this would result in that leaf becoming too big, split the leaf into two, promoting the middle key to the leaf’s parent
If this would result in the parent becoming too big, split the parent into two, promoting the middle key
This strategy might have to be repeated all the way to the top
If necessary, the root is split in two and the middle key is promoted to a new root, making the tree one level higher

146. Exercise in Inserting a B-Tree
Insert the following keys to a 5-way B-tree:
3, 7, 9, 23, 45, 1, 5, 14, 25, 24, 13, 11, 8, 19, 4, 31, 35, 56

147. Answer to Exercise
Java Applet Source

148. Removal from a B-tree
During insertion, the key always goes into a leaf. For deletion we wish to remove from a leaf. There are three possible ways we can do this:
1 - If the key is already in a leaf node, and removing it doesn’t cause that leaf node to have too few keys, then simply remove the key to be deleted.
2 - If the key is not in a leaf then it is guaranteed (by the nature of a B-tree) that its predecessor or successor will be in a leaf -- in this case can we delete the key and promote the predecessor or successor key to the non-leaf deleted key’s position.

149. Removal from a B-tree (2)
If (1) or (2) lead to a leaf node containing less than the minimum number of keys then we have to look at the siblings immediately adjacent to the leaf in question:
3: if one of them has more than the min’ number of keys then we can promote one of its keys to the parent and take the parent key into our lacking leaf
4: if neither of them has more than the min’ number of keys then the lacking leaf and one of its neighbours can be combined with their shared parent (the opposite of promoting a key) and the new leaf will have the correct number of keys; if this step leave the parent with too few keys then we repeat the process up to the root itself, if required

150. Type #1: Simple leaf deletion
Assuming a 5-way
B-Tree, as before... 12 29 52 2 7 9 15 22 56 69 72 31 43
Delete 2: Since there are enough
keys in the node, just delete it
Note when printed: this slide is animated

151. Type #2: Simple non-leaf deletion12 29 52 7 9 15 22 56 69 72 31 43 56
Delete 52
Borrow the predecessor
or (in this case) successor
Note when printed: this slide is animated

152. Type #4: Too few keys in node and its siblings
Join back together 12 29 56 7 9 15 22 69 72 31 43
Too few keys!
Delete 72
Note when printed: this slide is animated

153. Type #4: Too few keys in node and its siblings12 29 7 9 15 22 69 56 31 43
Note when printed: this slide is animated

154. Type #3: Enough siblings12 29
Demote root key and
promote leaf key 7 9 15 22 69 56 31 43
Delete 22
Note when printed: this slide is animated

155. Type #3: Enough siblings12 31 69 56 43 7 9 15 29
Note when printed: this slide is animated

156. Exercise in Removal from a B-Tree
Given 5-way B-tree created by these data (last exercise):
3, 7, 9, 23, 45, 1, 5, 14, 25, 24, 13, 11, 8, 19, 4, 31, 35, 56
Add these further keys: 2, 6,12
Delete these keys: 4, 5, 7, 3, 14

157. Answer to Exercise
Java Applet Source

158. Analysis of B-Trees
The maximum number of items in a B-tree of order m and height h:
root m – 1
level 1 m(m – 1)
level 2 m2(m – 1)
level h mh(m – 1)
So, the total number of items is (1 + m + m2 + m3 + … + mh)(m – 1) = [(mh+1 – 1)/ (m – 1)] (m – 1) = mh+1 – 1
When m = 5 and h = 2 this gives 53 – 1 = 124

159. Reasons for using B-Trees
When searching tables held on disc, the cost of each disc transfer is high but doesn't depend much on the amount of data transferred, especially if consecutive items are transferred
If we use a B-tree of order 101, say, we can transfer each node in one disc read operation
A B-tree of order 101 and height 3 can hold 1014 – 1 items (approximately 100 million) and any item can be accessed with 3 disc reads (assuming we hold the root in memory)
If we take m = 3, we get a 2-3 tree, in which non-leaf nodes have two or three children (i.e., one or two keys)
B-Trees are always balanced (since the leaves are all at the same level), so 2-3 trees make a good type of balanced tree