CompSci 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 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 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 Rules of B-Trees  Rules 1. 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, sorted 4. 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 Example Example B Tree (MAX = 2) [6] * * [2 4] [9] * * * * * [1] [3] [5] [7 8] [10]

CompSci 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 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 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 Insertion Fix  ( MAX = 4 ) Fixing Child with Excess Entry [9 28] BEFORE * * * [3 4] [ ] [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] [ ] 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 Insertion Fix (MAX= 2) Another Fix [6 17] BEFORE * * * [4] [12] [ ] [ ] STEP 2 * [ ] * * * * [4] [12] [18] [22] [ ] STEP 1 * * * * [4] [12] [18] [22] [17] AFTER * * [6] [19] * * * * [4] [12] [18] [22]

CompSci B-Tree Removal  Remove  Loose Remove  If rules violated: Fix o Borrow (rotation) o Join  Examples left to the “reader”

CompSci 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 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 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 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 AVL Trees  Single Rotation  An insertion into the left subtree of the left child of tree  Adapted from Weiss, pp // 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 AVL Trees  Single Rotation

CompSci AVL Trees k2 k1 k2 C A A B BC  Single Rotation  Also: mirror image before after

CompSci 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 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 AVL Tree  Double Rotation

CompSci AVL Trees k3 k1 k3 D A A B B C  Double Rotation  Also: mirror image before after k2 C D

CompSci 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 AVL Trees  Deletions can also cause imbalance  Use similar rotations to restore balance  Big Oh?