CSE 326: Data Structures Lecture #11 B-Trees

Transcription

1 CSE 326: Data Structures Lecture #11 B-Trees Alon Halevy Spring Quarter 2001 B-Tree Properties Properties maximum branching factor of M the root has between 2 and M children other internal nodes have between!m/2" and M children internal nodes contain only search keys (no data) smallest datum between search keys x and y equals x each (non-root) leaf contains between!l/2" and L keys all leaves are at the same depth Result tree is (log M/2 n/(l/2)) +/- 1 deep Θ(log n) all operations run in time proportional to depth operations pull in at least M/2 or L/2 items at a time

2 When Big-O is Not Enough B-Tree is about log M/2 n/(l/2) deep = log M/2 n - log M/2 L/2 = O(log M/2 n) = O(log n) steps per operation (same as BST!) Where s the beef?! log 2 ( 10,000,000 ) = 24 disk accesses log 200/2 ( 10,000,000 ) < 4 disk accesses k 1 k 2 B-Tree Nodes Internal node i search keys; i+1 subtrees; M - i - 1 inactive entries k i Leaf j data keys; L - j inactive entries k 1 k 2 k j 1 2 i M j L

3 Example B-Tree with M = 4 and L = Making a B-Tree The empty B-Tree Insert(3) 3 Insert() 3 M = 3 L = 2 Now, Insert(1)?

4 Splitting the Root Too many keys in a leaf! 3 Insert(1) And create a new root 1 3 So, split the leaf. Insertions and Split Ends Too many keys in a leaf! 1 3 Insert(59) Insert(26) So, split the leaf And add a new child

5 Propagating Splits Insert(5) Add new child Too many keys in an internal node! Create a new root So, split the node. Insertion in Boring Text Insert the key in its leaf If the leaf ends up with L+1 items, overflow! Split the leaf into two nodes: original with!(l+1)/2" items new one with $(L+1)/2% items Add the new child to the parent If the parent ends up with M+1 items, overflow! If an internal node ends up with M+1 items, overflow! Split the node into two nodes: original with!(m+1)/2" items new one with $(M+1)/2% items Add the new child to the parent If the parent ends up with M+1 items, overflow! Split an overflowed root in two and hang the new nodes under a new root This makes the tree deeper!

6 Deletion in B-trees Come to section tomorrow. Slides follow. After More Routine Inserts 5 59 Insert() Insert(79)

7 Deletion 5 59 Delete(59) Deletion and Adoption A leaf has too few keys! 5 79 Delete(5)? So, borrow from a neighbor

8 Deletion with Propagation A leaf has too few keys! 3 79 Delete(3)? And no neighbor with surplus! But now a node has too few subtrees! 79 So, delete the leaf Finishing the Propagation (More Adoption) Adopt a neighbor

9 A Bit More Adoption Delete(1) (adopt a neighbor) Pulling out the Root A leaf has too few keys! And no neighbor with surplus! Delete(26) So, delete the leaf But now the root has just one subtree! 79 Delete the leaf A node has too few subtrees and no neighbor with surplus!

10 Pulling out the Root (continued) The root has just one subtree! 79 Just make the one child the new root! 79 But that s silly! Deletion in Two Boring Slides of Text Remove the key from its leaf If the leaf ends up with fewer than!l/2" items, underflow! Adopt data from a neighbor; update the parent If borrowing won t work, delete node and divide keys between neighbors If the parent ends up with fewer than!m/2" items, underflow! Why will dumping keys always work if borrowing doesn t?

11 Deletion Slide Two If a node ends up with fewer than!m/2" items, underflow! Adopt subtrees from a neighbor; update the parent If borrowing won t work, delete node and divide subtrees between neighbors If the parent ends up with fewer than!m/2" items, underflow! If the root ends up with only one child, make the child the new root of the tree This reduces the height of the tree! Thinking about B-Trees B-Tree insertion can cause (expensive) splitting and propagation B-Tree deletion can cause (cheap) borrowing or (expensive) deletion and propagation Propagation is rare if M and L are large (Why?) Repeated insertions and deletion can cause thrashing If M = L = 128, then a B-Tree of height 4 will store at least 30,000,000 items height 5: 2,000,000,000!

12 Tree Summary BST: fast finds, inserts, and deletes O(log n) on average (if data is random!) AVL trees: guaranteed O(log n) operations B-Trees: also guaranteed O(log n), but shallower depth makes them better for disk-based databases What would be even better? How about: O(1) finds and inserts? Hash Table Approach Zasha Steve Nic Brad Ed f(x) But is there a problem in this pipe-dream?

13 Hash Table Dictionary Data Structure Hash function: maps keys to integers result: can quickly find the right spot for a given entry Unordered and sparse table result: cannot efficiently list all entries, Cannot find min and max efficiently, Cannot find all items within a specified range efficiently. Zasha Steve Nic Brad Ed f(x) Hash Table Terminology Zasha Steve Nic Brad Ed hash function f(x) collision keys load factor λ = # of entries in table tablesize

14 Hash Table Code First Pass Value & find(key & key) { int index = hash(key) % tablesize; return Table[index]; } What should the hash function be? How should we resolve collisions? What should the table size be? A Good Hash Function is easy (fast) to compute (O(1) and practically fast). distributes the data evenly (hash(a) hash(b) ). uses the whole hash table (for all 0 k < size, there s an i such that hash(i) % size = k).

15 Good Hash Function for Integers Choose tablesize is prime hash(n) = n % tablesize Example: tablesize = 7 insert(4) insert(17) find(12) insert(9) delete(17) Good Hash Function for Strings? Ideas?

16 Good Hash Function for Strings? Sum the ASCII values of the characters. Consider only the first 3 characters. Uses only 2871 out of 17,576 entries in the table on English words. Let s = s 1 s 2 s 3 s 4 s 5 : choose hash(s) = s 1 + s s s s n 128 n Think of the string as a base 128 number. Problems: hash( really, really big ) = well something really, really big hash( one thing ) % 128 = hash( other thing ) % 128 Making the String Hash Easy to Compute Use Horner s Rule int hash(string s) { h = 0; for (i = s.length() - 1; i >= 0; i--) { h = (s i + 128*h) % tablesize; } return h; }

17 Universal Hashing For any fixed hash function, there will be some pathological sets of inputs everything hashes to the same cell! Solution: Universal Hashing Start with a large (parameterized) class of hash functions No sequence of inputs is bad for all of them! When your program starts up, pick one of the hash functions to use at random (for the entire time) Now: no bad inputs, only unlucky choices! If universal class large, odds of making a bad choice very low If you do find you are in trouble, just pick a different hash function and re-hash the previous inputs Universal Hash Function: Random Vector Approach Parameterized by prime size and vector: a = <a 0 a 1 a r > where 0 <= a i < size Represent each key as r + 1 integers where k i < size size = 11, key = ==> <3,9,7,5,2> size = 29, key = hello world ==> <8,5,12,12,15,23,15,18,12,4> r # h a (k) = $ & aiki! mod size % i= 0 " dot product with a random vector!

18 Universal Hash Function Strengths: works on any type as long as you can form k i s if we re building a static table, we can try many a s a random a has guaranteed good properties no matter what we re hashing Weaknesses must choose prime table size larger than any k i Hash Function Summary Goals of a hash function reproducible mapping from key to table entry evenly distribute keys across the table separate commonly occurring keys (neighboring keys?) complete quickly Hash functions h(n) = n % size h(n) = string as base 128 number % size Universal hash function #1: dot product with random vector

19 How to Design a Hash Function Know what your keys are Study how your keys are distributed Try to include all important information in a key in the construction of its hash Try to make neighboring keys hash to very different places Prune the features used to create the hash until it runs fast enough (very application dependent) Collisions Pigeonhole principle says we can t avoid all collisions try to hash without collision m keys into n slots with m > n try to put 6 pigeons into 5 holes What do we do when two keys hash to the same entry? open hashing: put little dictionaries in each entry closed hashing: pick a next entry to try