Chapter 6: Multiway Trees

• Tree whose outdegree is not restricted to 2

while retaining the general properties of
binary search trees.

Cao Hoang Tru 1

CSE Faculty - HCMUT 17 November 2008
 M-Way Search Trees
• Each node has m - 1 data entries and m subtree
pointers.
• The key values in a subtree such that:
– >= the key of the left data entry
– < the key of the right data entry.
K1 K2 K3

keys < K1 K1<= keys < K2 K2<= keys < K3 K3<= keys
Cao Hoang Tru 2
CSE Faculty - HCMUT 17 November 2008
 M-Way Search Trees

50 100 150

35 45 85 95 125 135 175

60 70 90 110 120

75

Cao Hoang Tru 3

CSE Faculty - HCMUT 17 November 2008
 M-Way Node Structure

entry
key <key type>
key data data <data type>
rightPtr <pointer>
end entry

node
num firstPtr <pointer>
entries ...
numEntries <integer>
entries <array[1 .. m-1] of entry>
end node

Cao Hoang Tru 4

CSE Faculty - HCMUT 17 November 2008
 B-Trees
• M-way trees are unbalanced.
• Bayer, R. & McCreight, E. (1970) created
B-Trees.

Cao Hoang Tru 5

CSE Faculty - HCMUT 17 November 2008
 B-Trees
• A B-tree is an m-way tree with the following
additional properties (m >= 3):
– The root is either a leaf or has at least 2 subtrees.
– All other nodes have at least ⎡m/2⎤ - 1 entries.
– All leaf nodes are at the same level.

Cao Hoang Tru 6

CSE Faculty - HCMUT 17 November 2008
 B-Trees

42

16 21 58 76 81 93

11 14 17 19 20 21 22 23 24 45 52 63 65 74 78 79 85 87 94 97

m=5
Cao Hoang Tru 7
CSE Faculty - HCMUT 17 November 2008
 B-Tree Insertion
• Insert the new entry into a leaf node.
• If the leaf node is overflow, then split it
and insert its median entry into its parent.

Cao Hoang Tru 8

CSE Faculty - HCMUT 17 November 2008
 B-Tree Insertion
Insert 78, 21, 14, 11 11 14 21 78

21
Insert 97
11 14 21 78 97 11 14 78 97
overflow

Insert 85, 74, 63

21 21 78

11 14 63 74 78 85 97 11 14 63 74 85 97
overflow

Insert 45, 42, 57

21 78 21 57 78

11 14 42 45 57 63 74 85 97 11 14 42 45 63 74 85 97
overflow
Cao Hoang Tru 9
CSE Faculty - HCMUT 17 November 2008
 B-Tree Insertion
Insert 20, 16, 19
21 57 78 16 21 57 78

11 14 16 19 20 63 74 85 97 11 14 19 20 63 74 85 97
overflow 42 45 42 45

42
Insert 52, 30, 21
16 21 57 78 16 21 57 78

11 14 19 20 63 74 85 97 11 14 21 30 45 52 85 97

21 30 42 45 52 19 20 63 74

overflow

Cao Hoang Tru 10

CSE Faculty - HCMUT 17 November 2008
 B-Tree Insertion
Algorithm BTreeInsert (val root <pointer>, val data <record>)
Inserts data into B-tree. Equal keys placed on right branch.
Pre root is a pointer to the B-tree. May be null.
Post data inserted.
Return pointer to B-tree root.
1 taller = insertNode(root, data, upEntry)
2 if (taller true)
Tree has grown. Create new root.
1 allocate (newPtr)
2 newPtr −> entries[1] = upEntry
3 newPtr −> firstPtr = root
4 newPtr −> numEntries = 1
5 root = newPtr
3 return root
End BTreeInsert
Cao Hoang Tru 11
CSE Faculty - HCMUT 17 November 2008
 B-Tree Insertion
Algorithm insertNode (val root <pointer>, val data <record>,
ref upEntry <entry>)
Recursively searches tree to locate leaf for data. If node overflow, inserts median
key's data into parent.
Pre root is a pointer to tree or subtree. May be null.
Post data inserted.
upEntry is overflow entry to be inserted into parent.
Return tree taller <boolean>.
1 if (root null)
1 upEntry.data = data
2 upEntry.rightPtr = null
3 taller = true
2 else

Cao Hoang Tru 12

CSE Faculty - HCMUT 17 November 2008
 B-Tree Insertion
2 else
1 entryNdx = searchNode (root, data.key)
2 if (entryNdx > 0)
1 subTree = root −> entries[entryNdx].rightPtr
3 else
1 subTree = root −> firstPtr
4 taller = insertNode(subTree, data, upEntry)
5 if (taller)
1 if (node full)
1 splitNode (root, entryNdx, upEntry)
2 taller = true
2 else
1 insertEntry (root, entryNdx, upEntry)
2 taller = false
3 root −> numEntries = root −> numEntries + 1
3 return taller
End insertNode
Cao Hoang Tru 13
CSE Faculty - HCMUT 17 November 2008
 B-Tree Insertion
Algorithm searchNode (val nodePtr <pointer>, val target <key>)
Search B-tree node for data entry containing key <= target.
Pre nodePtr is pointer to non-null node.
target is key to be located.
Return index to entry with key <= target.
0 if key < first entry in node
1 if (target < nodePtr −> entry[1].data.key)
1 walker = 0
2 else
1 walker = nodePtr −> numEntries
2 loop (target < nodePtr −> entries[walker].data.key)
1 walker = walker - 1
3 return walker
End searchNode
Cao Hoang Tru 14
CSE Faculty - HCMUT 17 November 2008
 B-Tree Insertion
Algorithm splitNode (val node <pointer>, val entryNdx <index>,
ref upEntry <entry>)
Node has overflowed. Split node. No duplicate keys allowed.
Pre node is pointer to node that overflowed.
entryNdx contains index location of parent.
upEntry contains entry being inserted into split node.
Post upEntry now contains entry to be inserted into parent.
1 minEntries = minimum number of entries
2 allocate (rightPtr)
Build right subtree node
3 if (entryNdx <= minEntries)
1 fromNdx = minEntries + 1
4 else
Cao Hoang Tru 15
CSE Faculty - HCMUT 17 November 2008
 B-Tree Insertion
4 else
1 fromNdx = minEntries + 2
5 toNdx = 1
6 rightPtr -> numEntries = node -> numEntries – fromNdx + 1
7 loop (fromNdx <= node -> numEntries)
1 rightPtr -> entries[toNdx] = node -> entries[fromNdx]
2 fromNdx = fromNdx + 1
3 toNdx = toNdx + 1
8 node -> numEntries = node -> numEntries − rightPtr -> numEntries
9 if (entryNdx <= minEntries)
1 insertEntry (node, entryNdx, upEntry)
10 else

Cao Hoang Tru 16

CSE Faculty - HCMUT 17 November 2008
 B-Tree Insertion
11 else
1 insertEntry (rightPtr, entryNdx − minEntries, upEntry)
2 node -> numEntries = node -> numEntries − 1
3 rightPtr -> numEntries = rightPtr -> numEntries + 1
Build entry for parent
12 medianNdx = minEntries + 1
13 upEntry.data = node -> entries[medianNdx].data
14 upEntry.rightPtr = rightPtr
15 rightPtr -> firstPtr = node -> entries[medianNdx]. rightPtr
16 return
End splitNode

Cao Hoang Tru 17

CSE Faculty - HCMUT 17 November 2008
 B-Tree Insertion
Algorithm insertEntry (val node <pointer>, val entryNdx <index>,
val newEntry <entry>)
Inserts one entry into a node by shifting nodes to make room.
Pre node is pointer to node to contain data.
newEntry contains data to be inserted.
entryNdx is index to location for new data.
Post data have been inserted in sequence.
1 shifter = node -> numEntries + 1
2 loop (shifter > entryNdx + 1)
1 node -> entries[shifter] = node -> entries[shifter - 1]
2 shifter = shifter - 1
3 node -> entries[shifter] = newEntry
4 node -> numEntries = node -> numEntries + 1
5 return
End insertEntry
Cao Hoang Tru 18
CSE Faculty - HCMUT 17 November 2008
 B-Tree Deletion
• It must take place at a leaf node.
• If the data to be deleted are not in a leaf
node, then replace that entry by the largest
entry on its left subtree.

Cao Hoang Tru 19

CSE Faculty - HCMUT 17 November 2008
 B-Tree Deletion
Delete 78
63 63

11 14 21 74 78 85 11 14 21 74 85

Delete 63
63 21

11 14 21 74 85 11 14 74 85

Cao Hoang Tru 20

CSE Faculty - HCMUT 17 November 2008
 B-Tree Deletion
Delete 85
21 21

11 14 74 85 11 14 74

underflow
(node has fewer than the
min num of entries)
Delete 21
21 14

11 14 74 85 11 74 85

Cao Hoang Tru 21

CSE Faculty - HCMUT 17 November 2008
 Reflow
• For each node to have sufficient number of
entries:
– Balance: shift data among nodes.
– Combine: join data from nodes.

Cao Hoang Tru 22

CSE Faculty - HCMUT 17 November 2008
 Balance
Borrow from right ... 21 ...

Original node 14 42 45 63

21
Rotate parent
data down 14 21 42 45 63

42
Rotate data to
parent
14 21 42 45 63

42
Shift entries
left 14 21 45 63
Cao Hoang Tru 23
CSE Faculty - HCMUT 17 November 2008
 Balance
Borrow from left ... 78 ...

Original node 45 63 74 85

... 78 ...
Shift entries
right 45 63 74 85

... 78 ...
Rotate parent
data down 45 63 74 78 85

... 74 ...
Rotate data
up 45 63 78 85
Cao Hoang Tru 24
CSE Faculty - HCMUT 17 November 2008
 Combine
21 57 78 21 57 78

42 45 63 42 45 57 63

59 61 65 71 59 61 65 71

1. After underflow 2. After moving root to subtree

21 57 78 21 78

42 45 57 63 42 45 57 63

59 61 65 71 59 61 65 71

3. After moving right entries 4. After shifting root

Cao Hoang Tru 25

CSE Faculty - HCMUT 17 November 2008
 B-Tree Traversal

21 58

11 14 19 20 42 45 63 74 87

Cao Hoang Tru 26

CSE Faculty - HCMUT 17 November 2008
 B-Tree Traversal
Algorithm BTreeTraversal (val root <pointer>)
Processes tree using inorder traversal
Pre root is a pointer to B-tree
Post Every entry has been processed in order
1 scanCount = 0
2 ptr = root −> firstPtr
3 loop (scanCount <= root −> numEntries)
1 if (ptr not null)
1 BTreeTraversal (ptr)
2 scanCount = scanCount + 1
3 if (scanCount <= root −> numEntries)
1 process (root −> entries[scanCount].data)
2 ptr = root −> entries[scanCount].rightPtr
4 return
End
Cao Hoang BTreeTraversal
Tru 27
CSE Faculty - HCMUT 17 November 2008
 B-Tree Search
Algorithm BTreeSearch (val root <pointer>, val target <key>,
ref node <pointer>, ref entryNo <index>)
Recursively searches a B-tree for the target key
Pre root is a pointer to a tree or subtree
target is the data to be located
Post if found --
node is pointer to located node
entryNo is entry within node
if not found --
node is null and entryNo is zero
Return found <boolean>

Cao Hoang Tru 28

CSE Faculty - HCMUT 17 November 2008
 B-Tree Search
1 if (empty tree)
1 node = null
2 entryNo = 0
3 found = false
2 else
1 if (target < first entry)
1 return BTreeSearch (root −> firstPtr, target, node, entryNo)
2 else
1 entryNo = root −> numEntries
2 loop (target < root −> entries[entryNo].data.key)
1 entryNo = entryNo - 1
3 if (target = root −> entries[entryNo].data.key)
1 found = true
2 node = root
4 else
1 return BTreeSearch (root −> entries[entryNo].rightPtr, target, node, entryNo)
4 return found
End BTreeTraversal
Cao Hoang Tru 29
CSE Faculty - HCMUT 17 November 2008
 B-Tree Variations
• B*Tree: the minimum number of (used)
entries is two thirds.
• B+Tree:
– Each data entry must be represented at the leaf level.
– Each leaf node has one additional pointer to move to
the next leaf node.

Cao Hoang Tru 30

CSE Faculty - HCMUT 17 November 2008
 Reading
• Pseudo code of algorithms for B-Tree Insertion

Cao Hoang Tru 31

CSE Faculty - HCMUT 17 November 2008