B-Trees This presentation shows you the potential problem of unbalanced tree and show one way to fix it This lecture introduces heaps, which are used in the Priority Queue project of Chapter 11. The lecture includes the algorithms for adding to a heap (including reheapification upward), removing the top of a heap (including reheapification downward), and implementing a heap in a partially-filled array. Prior to this lecture, the students need a good understanding of complete binary trees. It would also help if they have seen binary search trees and the priority queue class. Data Structures and Other Objects Using C++

The problems of Unbalanced Trees Solution: 1. Periodically balance the tree (Project 9 in Chapter 10 on page 538) 2. Leaves cannot become too deep --- B-tree 1 2 3 4 5

B-Tree Differences compared to BST: 1. B-tree nodes have many more than two children 2. Each node contains more than just a single entry 3. Rules ensure that leaves do not become too deap

B-Tree Rules 1. Root may have as few as 1 entry – every other node has MINIMUM entries 2. Maximum number of entries in a node is twice MINIMUM 3. Entries of each B-tree node are stored in a partially filled array – sorted in increasing order 4. Number of subtrees below a nonleaf node is 1 more than the number of entries in the node

B-Tree Rules 5. For any nonleaf node a. An entry at index i is greater than all the entries in subtree number i of the node b. An entry at entry i is less than all the entries in subtree i+1 of the node 6. Every leaf in a B-tree has the same depth

B-Tree Example B-tree of 10 integers (with MINIMUM set to 1) 6 2 and 4 9 1 3 5 7 and 8 10

B-Tree Illustrations https://www.youtube.com/watch?v=coRJrcIYbF4 https://www.cs.usfca.edu/~galles/visualization/BT ree.html

Set Example Author uses a set implemented as a B-tree as an example

Class Invariant Items in the set are stored in a B-tree Number of entries in root – stored in member variable data_count & number of subtrees stored in member variable child_count root's entries are stored in data[0] through data[data_count - 1] If root has sub-trees – subtrees are stored in sets pointed to by subset[0] through subset[child_count - 1]

Searching Make a local variable i equal to the first index such that data[i] is not less than the target – if no such index exists, then set i equal to data_count, indicating that all of the entries are less than the target if (we found the target at data[i]) return 1; else if (the root has no children) return 0; else return subset[i]->count(target)

Searching Example

Inserting Loose insertion Fix Loose insertion problem later might result in MAXIMUM + 1 entries in the nodes Fix Loose insertion problem later 6, 17 6, 17 4 12 19, 22 4 12 18, 19, 22

Loose Inserting Make a local variable i equal to first index such that data[i] is not less than entry – if no such index exists, then set i to data_count if (we found the new entry at data[i]) 2a. Return false with no further work (since the new entry is already in the set). else if (the root has no children) { 2b. Add the new entry to the root at data[i]. (The original entries at data[i] and afterwards must be shifted right to make room for the new entry.) Return true to indicate that we added the entry. else { 2c. Save the value from this recursive call: subset[i]->loose_insert(entry); Then check whether the root of subset[i] now has an excess entry; if so, then fix that problem. Return the saved value from the recursive call. }

Loose Inserting Example 6, 17 4 12 19, 22 MINIMUM = 1 18 ? 6, 17 6, 17, 19 4 12 18, 19, 22 4 12 18 22

Inserting Example 17 6, 17, 19 4 12 18 22 6, 19 4 12, 18 22

Fixing Child with Excess Entry Split child node into nodes containing MINIMUM entries Pass median entry up to parent 3, 6 33, 40 9, 28 13, 16, 19, 22, 25 1, 2 7, 8 4, 5 11, 12 17, 18 14, 15 20, 21 26, 27 23, 24 31, 32 50, 51 34, 35 MINIMUM = 2 9, 19, 28 3, 6 13, 16 22, 25 33, 40 1, 2 4, 5 7, 8 11, 12 14, 15 17, 18 20, 21 23, 24 26, 27 31, 32 34, 35 50, 51

Deleting From B-Tree Loose erase Fix the problem later might leave the root of an internal subtree with fewer than MINIMUM entries Fix the problem later

Loose Erase From B-Tree Make a local variable i equal to the first index such that data[i] is not less than target. If there is no such index, then set i equal to data_count 4 possibilities: Root has no children & did not find entry Done – entry not in tree Root has no children & found entry Remove the entry and return true Root has children & did not find target Recursive call to subtree[i] Root has children & found the target Replace the target by the largest item from subtree[i]

Loose Erase Example ? 28 MINIMUM = 2 2, 5 33, 40 10, 28 13, 16, 19, 22 0, 1 6, 7, 8 3, 4 11, 12 17, 18 14, 15 20, 21 23, 24, 26 31, 32 50, 51 34, 35 MINIMUM = 2 ? 28 2, 5 33, 40 10, 26 13, 16, 19, 22 0, 1 6, 7, 8 3, 4 11, 12 17, 18 14, 15 20, 21 23, 24 31, 32 50, 51 34, 35

Fix Shortage in Child Case 1: Transfer an extra entry from subtree[i-1] - subset[i-1] has more than MINIMUM number of entries Transfer data[i-1] down to front of subset[i] Transfer final item of subtree[i-1] up to replace data[i- 1] If subtree[i-1] has children, transfer final child of subset[i-1] to front of subtree[i] Case 2: Transfer extra entry from subtree[i+1]- Similar to Case 1

Fix Shortage Example ? 40 MINIMUM = 2 2, 5 33 10, 28 13, 16, 19, 22 0, 1 6, 7, 8 3, 4 11, 12 17, 18 14, 15 20, 21 23, 24, 26 31, 32 34, 35 MINIMUM = 2 ? 40 2. The 22 has come up from the middle child. 1. The 28 has come down from the root. 2, 5 28, 33 10, 22 13, 16, 19 0, 1 6, 7, 8 3, 4 11, 12 17, 18 14, 15 20, 21 23, 24, 26 31, 32 34, 35 3. This child has been moved over.

Fix Shortage in Child Case 3: Combine subtree[i]with subtree[i- 1] Transfer data[i-1] down to end of subtree[i-1] Transfer all items & children from subtree[i] to end of subtree[i-1] Delete node subtree[i] & shift subtree[i+1] leftward to fill gap Case 4: Combine subtree[i]with subtree[i+1]- Similar to Case 3

Fix Shortage Example ? 40 MINIMUM = 2 2, 5 33 10, 28 16, 19 0, 1 6, 7, 8 3, 4 17, 18 14, 15 20, 21 31, 32 34, 35 MINIMUM = 2 ? 40 10 2, 5 16, 19, 28, 33 0, 1 3, 4 6, 7, 8 14, 15 17, 18 20, 21 31, 32 34, 35

Time analysis Insert, remove and search times are roughly proportional to the depth of a tree in binary search trees, heaps and B-trees. Binary search trees suffer, since a tree of n entries could have depth n. Heaps and B-trees have depth proportional to log(n), so the operations for a heap or a B-tree is O(log(n)).

Summary A B-tree is a tree for storing entries in a manner that follows six rules. The tree algorithms that we have seen for binary search trees, heaps, and B-trees all have worse- case time complexity of O(d), where d is the depth of the tree. The depth of a heap or B-tree is never more than O(log n), where n is the number of nodes. A quick summary . . .