CompSci 100 27.1

Memory Model For this course: Assume Uniform Access Time

All elements in an array accessible with same time cost

Reality is somewhat different Memory Hierarchy (in order of decreasing speed)

Registers On (cpu) chip cache memory Off chip cache memory Main memory Virtual memory (automatically managed use of disk) Explicit disk I/O

All but last managed by system Need to be aware, but can do little to manipulate

others directly Promote locality?

CompSci 100 27.2

Cost of Disk I/O

Disk access 10,000 to 100,000 times slower than memory access Do almost anything (almost!) in terms of

computation to avoid an extra disk access Performance penalty is huge

B-Trees designed to be used with disk storage Typically used with database application Many different variations Will present basic ideas here

Want broad, not deep trees Even log N disk accesses can be too many

CompSci 100 27.3

External Methods

Disk use requires special consideration Timing Considerations (already mentioned) Writing pointers to disk? What do values mean when read in at a

different time/different machine? General Properties of B-Trees

All Leaves Have Same Depth Degree of Node > 2 (maybe hundreds or thousands)

Not a Binary Tree, but is a Search Tree There are many implementations... Will use examples with artificially small

numbers to illustrate

CompSci 100 27.4

Rules of B-Trees

Rules1. Every node (except root) has at least MINIMUM

entries 2. The MAXIMUM number of node entries is 2*MINIMUM 3. The entries of each B-tree are stored, sorted4. The number of sub-trees below a non-leaf node is

one greater than the number of node entries 5. For non leaves:

Entry at index k is greater than all entries in sub-tree k

Entry at index k is less than all entries in sub-tree k+1

6. Every leaf in a B-tree has the same depth

CompSci 100 27.5

Example

Example B Tree (MAX = 2) [6]

* *

* *

* *

[2 4] [9]

* * * * *

* * * * *

* * * * *

[1] [3] [5] [7 8] [10]

CompSci 100 27.6

Search in B-Tree Every Child is Also the Root of a Smaller B-Tree Possible internal node implementation

class BTNode { //ignoring ref on disk issue

int myDataCount;

int myChildCount;

KeyType[] myKeys[MAX+1];

BTNode[] myChild[MAX+2]

} Search:

boolean isInBTree(BTNode t, KeyType key); 1. Search through myKeys until myKeys[k] >= key 2. If t.myData[k] == key, return true 3. If isLeaf(t) return false 4. return isInBtree(t.myChild[k])

CompSci 100 27.7

Find Example

Example Find in B-Tree (MAX = 2) Finding 10

[6 17] * * * * * * * * * * * * * * * [4] [12] [19 22] * * * * * * * * * * * * * * * * * * * * * [2 3] [5] [10] [16] [18] [20] [25]

CompSci 100 27.8

B-Tree Insertion

Insertion Gets a Little Messy Insertion may cause rule violation “Loose” Insertion (leave extra space) (+1) Fixing Excess Entries

Insert Fix Split Move up middle Height gained only at root

Look at some examples

CompSci 100 27.9

Insertion Fix (MAX = 4) Fixing Child with Excess Entry [9 28] BEFORE * * * * * * * * * * * * [3 4] [13 16 19 22 25] [33 40] * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * [2 3][4 5][7 8][11 12][14 15][17 18][20 21][23 24][26 27][31 32][34 35][50 51]

[9 19 28] AFTER * * * * * * * * * * * * * * * * [3 4] [13 16] [22 25] [33 40] * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *[2 3][4 5][7 8][11 12][14 15][17 18][20 21][23 24][26 27][31 32][34 35][50 51]

CompSci 100 27.10

Insertion Fix (MAX= 2) Another Fix

[6 17] BEFORE * * * * * * * * *[4] [12] [18 19 22]

[ ] STEP 2 * * [6 17 19] * * * * * * * * * * * * [4] [12] [18] [22]

[6 17 19] STEP 1

* * * *

* * * *

* * * *

[4] [12] [18] [22]

[17] AFTER

* *

* *

[6] [19]

* * * *

* * * *

* * * *

[4] [12] [18] [22]

CompSci 100 27.11

B-Tree Removal

Remove Loose Remove If rules violated: Fix

o Borrow (rotation) o Join

Examples left to the “reader”

CompSci 100 27.12

B-Trees

Many variations Leaf node often different from internal node Only leaf nodes carry all data (internal nodes:

keys only) Examples didn’t distinguish keys from data Design to have nodes fit disk block

The Big Picture Details can be worked out Can do a lot of computation to avoid a disk

access

CompSci 100 27.13

Balanced Binary Search Trees

Pathological BST Insert nodes from ordered list Search: O(___) ?

The Balanced Tree Binary Tree is balanced if height of left and

right subtree differ by no more than one, recursively for all nodes.

(Height of empty tree is -1) Examples

CompSci 100 27.14

Balanced Binary Search Trees

Keeping BSTrees Balanced Keeps find, insert, delete O(log(N)) worst case. Pay small extra amount at each insertion (and

deletion) to keep it balanced Several Well-known Systems Exist for

This AVL Trees Red-Black Trees . . .

Will look at AVL Trees

CompSci 100 27.15

AVL Trees

AVL Trees Adelson-Velskii and Landis Discovered ways to keep BSTrees

Balanced Insertions

Insert into BST in normal way If tree no longer balanced, perform a

“rotation” Rotations restore balance to the tree

CompSci 100 27.16

AVL Trees Single Rotation

An insertion into the left subtree of the left child of tree

Adapted from Weiss, pp 567-568// Used if it has caused loss of balance)

// (Also used as part of double rotation operations)

Tnode rotateWithLeftChild(TNode k2)

//post: returns root of adjusted tree

{

TNode k1 = k2.left;

k2.left = k1.right;

k1.right = k2;

return k1;

}

CompSci 100 27.17

AVL Trees

Single Rotation

CompSci 100 27.18

AVL Trees

k2

k1

k1

k2

C

A

A BB C

Single Rotation

Also: mirror image

before after

CompSci 100 27.19

AVL Trees

Single Rotation Mirror image case

TNode rotateWithRightChild(TNode k2)

//post: returns root of adjusted tree

{

TNode k1 = k2.right;

k2.right = k1.left;

k1.left = k2;

return k1;

}

CompSci 100 27.20

AVL Tree

Double Rotation An insertion into the right subtree of the left

child of tree Adapted from Weiss, p 57

// Used after insertion into right subtree, k2,

// of left child, k1, of k3 (if it has caused

// loss of balance)

TNode doubleRotateWithLeftChild(TNode k3)

//post: returns root of adjusted tree

{

k3.left = rotateWithRightChild(k3.left);

return rotateWithLeftChild(k3);

}

CompSci 100 27.21

AVL Tree

Double Rotation

CompSci 100 27.22

AVL Trees

k3k1k1

k3

DA

AB

B

C

Double Rotation

Also: mirror image

before after

k2

k2

C

D

CompSci 100 27.23

AVL Tree

Double Rotation An insertion into the right subtree of the left

child of tree Adapted from Weiss, p 571

// Mirror Image

TNode doubleRotateWithRightChild(TNode k3)

//post: returns root of adjusted tree

{

k3.right = rotateWithLeftChild(k3.right);

return rotateWithRightChild(k3);

}

CompSci 100 27.24

AVL Trees Deletions can also cause imbalance Use similar rotations to restore balance Big Oh?