chapter 12: multi-way search trees

Addison Wesley is an imprint of

CHAPTER 12: Multi-way Search Trees

Java Software Structures:Designing and Using Data Structures

Third Edition

John Lewis & Joseph Chase

Chapter Objectives

• Examine 2-3 and 2-4 trees• Introduce the generic concept of a B-tree• Examine some specialized

implementations of B-trees

Multi-way Search Trees

• In a multi-way search tree, – each node may have more than two child nodes– there is a specific ordering relationship among the

• In this chapter, we examine three forms of multi-way search trees– 2-3 trees– 2-4 trees– B-trees

2-3 Trees

• A 2-3 tree is a multi-way search tree in which each node has zero, two, or three children

• A node with zero or two children is called a 2-node• A node with zero or three children is called a 3-node• A 2-node contains one element and either has no

children or two children– Elements of the left sub-tree less than the element– Elements of the right sub-tree greater than or equal to the

element

2-3 Trees

• A 3-node contains two elements, one designated as the smaller and one as the larger

• A 3-node has either no children or three children• If a 3-node has children then

– Elements of the left sub-tree are less than the smaller element– The smaller element is less than or equal to the elements of the

middle sub-tree– Elements of the middle sub-tree are less then the larger element– The larger element is less than or equal to the elements of the

right sub-tree

2-3 Trees

• All of the leaves of a 2-3 tree are on the same level

• Thus a 2-3 tree maintains balance

A 2-3 tree

Inserting Elements into a 2-3 Tree

• All insertions into a 2-3 tree occur at the leaves– The tree is searched to find the proper leaf for the new

element

• Insertion has three cases– Tree is empty (in which case the new element

becomes the root of the tree)– Insertion point is a 2-node– Insertion point is a 3-node

Inserting Elements into a 2-3 Tree

• The first of these cases is trivial with the element inserted into a new 2-node that becomes the root of the tree

• The second case occurs when the new element is to be inserted into a 2-node

• In this case, we simply add the element to the leaf and make it a 3-node

Inserting 27

Insertion into a 2-3 Tree

• The third case occurs when the insertion point is a 3-node

• In this case – the 3 elements (the two old ones and the new one) are

ordered– the 3-node is split into two 2-nodes, one for the

smaller element and one for the larger element– the middle element is promoted (or propagated) up a

• The promotion of the middle element creates two additional cases:– The parent of the 3-node is a 2-node– The parent of the 3-node is a 3-node

• If the parent of the 3-node being split is a 2-node then it becomes a 3-node by adding the promoted element and references to the two resulting two nodes

Inserting 32

• If the parent of the 3-node is itself a 3-node then it also splits into two 2-nodes and promotes the middle element again

Inserting 57

Inserting 25

Removing Elements from a 2-3 Tree

• Removal of elements is also made up of three cases:– The element to be removed is in a leaf that is

a 3-node– The element to be removed is in a leaf that is

a 2-node– The element to be removed is in an internal

• The simplest case is that the element to be removed is in a leaf that is a 3-node

• In this case the element is simply removed and the node is converted to a 2-node

Removal from a 2-3 tree (case 1)

• The second case is that the element to be removed is in a leaf that is a 2-node

• This creates a situation called underflow• We must rotate the tree and/or reduce the

tree’s height in order to maintain the properties of the 2-3 tree

• This case can be broken down into four subordinate cases

• The first of these subordinate cases (2.1) is that the parent of the 2-node has a right child that is a 3-node

• In this case, we rotate the smaller element of the 3-node around the parent

Removal from a 2-3 tree (case 2.1)

• The second of these subordinate cases (2.2) occurs when the underflow cannot be fixed through a local rotation but there are 3-node leaves in the tree

• In this case, we rotate prior to removal of the element until the right child of the parent is a 3-node

• Then we follow the steps for our previous case (2.1)

Removal of Elements from a 2-3 Tree

• The third of these subordinate cases (2.3) occurs when none of the leaves are 3-nodes but there are 3-node internal nodes

• In this case, we can convert an internal 3-node to a 2-node and rotate the appropriate element from that node to rebalance the tree

• The fourth subordinate case (2.4) occurs when there not any 3-nodes in the tree

• This case forces us to reduce the height of the tree

• To accomplish this, we combine each the leaves with their parent and siblings in order

• If any of these combinations produce more than two elements, we split into two 2-nodes and promote the middle element

• The third of our original cases is that the element to be removed is in an internal node

• As we did with binary search trees, we can simply replace the element to be removed with its inorder successor

Removal from a 2-3 tree (case 3)

2-4 Trees

• 2-4 Trees are very similar to 2-3 Trees adding the characteristic that a node can contain three elements

• A 4-node contains three elements and has either no children or 4 children

• The same ordering property applies as 2-3 trees• The same cases apply to both insertion and

removal of elements as illustrated on the following slides

Insertions into a 2-4 tree

Removals from a 2-4 tree

B-Trees

• Both 2-3 trees and 2-4 trees are examples of a larger class of multi-way search trees called B-trees

• We refer to the maximum number of children of each node as the order of a B-Tree

• Thus 2-3 trees are 3 B-trees and 2-4 trees are 4 B-trees

B-Trees

• B-trees of order m have the following properties:

A B-tree of order 6

Motivation for B-trees

• B-trees were created to make the most efficient use possible of the relationship between main memory and secondary storage

• For all of the collections we have studied thus far, our assumption has been that the entire collections exists in memory at once

• Consider the case where the collection is too large to exist in primary memory at one time

• Depending upon the collection, the overhead associated with reading and writing from files and/or swapping large segments of memory in and out could be devastating

• B-trees were designed to flatten the tree structure and to allow for larger blocks of data that could then be tuned so that the size of a node is the same size as a block on secondary storage

• This reduces the number of nodes and/or blocks that must be accessed, thus improving performance

B*-trees

• A variation of B-trees called B*-trees were created to solve the problem that the B-tree could be half empty at any given time

• B*-trees have all of the same properties as B-trees except that, instead of each node having k children where m/2 ≤ k ≤ m, in a B*-tree, each node has k children where (2m–1)/3 ≤ k ≤ m

• This means that each non-root node is at least two-thirds full

B+-trees

• Another potential problem for B-trees is sequential access

• B+-trees provide a solution to this problem by requiring that each element appear in a leaf regardless of whether it appears in an internal node

• By requiring this and then linking the leaves together, B+-trees provide very efficient sequential access while maintaining many of the benefits of a tree structure

A B+-tree of order 6

Implementation Strategies for B-trees

• A good implementation strategy for B-trees is to think of each node as a pair of arrays– An array of m-1 elements– An array of m children

• Then, if we think of the tree itself as one large array of nodes, then the elements stored in the array of children would simply be integer indexes into the array of nodes

chapter 12: multi-way search trees

Documents

csci 104 binary search trees and balanced binary search...

trees by charl du plessis. contents basic terminology basic...

search, trees, games, backtracking search, backtracking...

multiway search trees

binary trees, binary search trees and avl trees

search trees

balanced search trees avl trees 2-3 trees 2-4 trees

binary search trees - inf.usi.ch filebinary search trees -...

binary search trees

multi-dimensional search trees cs302 data structures...

succinct representations of trees - ut · - search trees...

1 unbalanced binary search trees balanced search trees 2-3-4...

cse 326 multi-dimensional search trees david kaplan dept of...

1 binary trees binary trees binary search trees binary...

trees data structures trees data structures trees trees ...

tddb56 dalgopt-d tddb57 dalg-c lecture 6 jan maluszynski -...

trees general trees binary trees binary search trees avl...

cse 4101/5101 prof. andy mirzaian. lists move-to-front...

nwsc.gov.npnwsc.gov.np/download/computerengineer.pdf ·...

(2019 batch onwards) · unit 2: trees: binary search trees,...