ECE250: Algorithms and Data Structures B-Trees (Part A)

Transcription

1 ECE250: Algorithms and Data Structures B-Trees (Part A) Ladan Tahvildari, PEng, SMIEEE Associate Professor Software Technologies Applied Research (STAR) Group Dept. of Elect. & Comp. Eng. University of Waterloo Materials from CLRS: Chapter 18.1, 18.2

2 Acknowledgements v The following resources have been used to prepare materials for this course: Ø MIT OpenCourseWare Ø Introduction To Algorithms (CLRS Book) Ø Data Structures and Algorithm Analysis in C++ (M. Wiess) Ø Data Structures and Algorithms in C++ (M. Goodrich) v Thanks to many people for pointing out mistakes, providing suggestions, or helping to improve the quality of this course over the last ten years: Ø Lecture 15 ECE250 2

3 Disk Based Data Structures v So far search trees were limited to main memory structures Ø Assumption: the dataset organized in a search tree fits in main memory (including the tree overhead) v Counter-example: transaction data of a bank > 1 GB per day Ø increase main memory (power failure?) Ø use secondary storage media (hard disks, magnetic disks, etc.) v Consequence: make a search tree structure secondarystorage-enabled Lecture 15 ECE250 3

4 Algorithm Analysis v The running time of disk-based algorithms is measured in terms of Ø computing time (CPU) Ø number of disk accesses sequential reads random reads Lecture 15 ECE250 4

5 Principles v Pointers in data structures are no longer addresses in main memory v If x is a pointer to an object Ø if x is in main memory key[x] refers to it Ø otherwise DiskRead(x) reads the object from disk into main memory (DiskWrite(x) writes it back to disk) Lecture 15 ECE250 5

6 Principles (2) v A typical working pattern x a pointer to some object 03 DiskRead(x) 04 operations that access and/or modify x 05 DiskWrite(x) //omitted if nothing changed 06 other operations, only access no modify 07 Lecture 15 ECE250 6

7 Binary-trees vs. B-trees v Size of B-tree nodes is determined by the page size. One page one node. v A B-tree of height 2 containing > 1 Billion keys! v Heights of Binary-tree and B-tree are logarithmic Ø B-tree: logarithm of base, e.g., 1000 Ø Binary-tree: logarithm of base node 1000 keys 1001 nodes, 1,001,000 keys 1,002,001 nodes, 1,002,001,000 keys Lecture 15 ECE250 7

8 B-tree Definitions v Node x has fields Ø n[x]: the number of keys of that the node Ø key 1 [x] key n[x] [x]: the keys in ascending order Ø leaf[x]: true if leaf node, false if internal node Ø if internal node, then c 1 [x],, c n[x]+1 [x]: pointers to children Ø leaf nodes have no children v Keys separate the ranges of keys in the sub-trees. If k i is an arbitrary key in the subtree c i [x] then k i key i [x] k i+1 Lecture 15 ECE250 8

9 B-tree Definitions (2) v Every leaf has the same depth which is the tree s height h. v In a B-tree of a degree t: Ø Every node other than the root must have at least t-1 keys. Every internal node other than the root thus has at least t children. Ø Every node may contain at most 2t-1 keys. Therefore, an internal node may have at most 2t children Ø The root node has between 0 and 2t children (i.e. between 0 and 2t-1 keys) Lecture 15 ECE250 9

10 Height of a B-tree v B-tree T of height h, containing n 1 keys and minimum degree t 2, the following restriction on the height holds: 1 h log t n depth 0 1 #of nodes t t - 1 t - 1 t - 1 t - 1 t - 1 h i 1 h 1 ( 1) n + t t = t Lecture 15 i= 1 ECE t t - 1 t - 1 t t

11 B-tree Operations v An implementation needs to support the following B-tree operations Ø Searching (simple) Ø Creating an empty tree (trivial) Ø Insertion (complex) Ø Deletion (complex) Lecture 15 ECE250 11

12 Searching v Straightforward generalization of tree search (e.g., binary search trees) BTreeSearch(x,k) 01 i 1 02 while i n[x] and k > key i [x] 03 i i+1 04 if i n[x] and k = key i [x] then 05 return(x,i) 06 if leaf[x] then 08 return NIL 09 else DiskRead(c i [x]) 10 return BTtreeSearch(c i [x],k) Lecture 15 ECE250 12

13 Creating an Empty Tree v Empty B-tree = create a root v & write it to disk! BTreeCreate(T) 01 x AllocateNode(); 02 leaf[x] TRUE; 03 n[x] 0; 04 DiskWrite(x); 05 root[t] x Lecture 15 ECE250 13

14 B-tree Operations v An implementation needs to support the following B-tree operations Ø Searching (simple) Ø Creating an empty tree (trivial) Ø Insertion (complex) Ø Deletion (complex) Lecture 15 ECE250 14

15 Splitting Nodes v Nodes fill up and reach their maximum capacity 2t 1 v Before we can insert a new key, we have to make room, i.e., split nodes Lecture 15 ECE250 15

16 Splitting Nodes (cont ) v Result: one key of y moves up to parent + 2 nodes with t-1 keys x... N W... y = c i [x] P Q R S T V W x... N S W... y = c i [x] z = c i+1 [x] P Q R T V W T 1... T 8 Lecture 15 ECE250 16

17 Splitting Nodes (cont ) BTreeSplitChild(x,i,y) 01 z AllocateNode() 02 leaf[z] leaf[y] 03 n[z] t-1 04 for j 1 to t-1 05 key j [z] key j+t [y] 06 if not leaf[y] then 07 for j 1 to t 08 c j [z] c j+t [y] 09 n[y] t-1 10 for j n[x]+1 downto i+1 11 c j+1 [x] c j [x] 12 c i+1 [x] z 13 for j n[x] downto i 14 key j+1 [x] key j [x] 15 key i [x] key t [y] 16 n[x] n[x]+1 17 DiskWrite(y) 18 DiskWrite(z) 19 DiskWrite(x) x: parent node y: node to be split and child of x i: index in x z: new node x y = c i [x]... N W... P Q R S T V W T 1... T 8 Lecture 15 ECE250 17

18 Split: Running Time v A local operation that does not traverse the tree v Θ(t) CPU-time, since two loops run t times v 3 I/Os Lecture 15 ECE250 18

19 Inserting Keys v Done recursively, by starting from the root and recursively traversing down the tree to the leaf level v Before descending to a lower level in the tree, make sure that the node contains < 2t 1 keys Lecture 15 ECE250 19

20 Inserting Keys (cont ) v Special case: root is full (BtreeInsert) BTreeInsert(T,k) 01 r root[t] 02 if n[r] = 2t 1 then 03 s AllocateNode() 04 root[t] s 05 leaf[s] FALSE 06 n[s] 0 07 c 1 [s] r 08 BTreeSplitChild(s,1,r) 09 BTreeInsertNonFull(s,k) 10 else BTreeInsertNonFull(r,k) Lecture 15 ECE250 20

21 Splitting the Root v Splitting the root requires the creation of new nodes root[t] A D F H L N P T 1... T 8 r root[t] A D F L N P v The tree grows at the top instead of the bottom r H s Lecture 15 ECE250 21

22 Insertion: Example initial tree (t = 3) G M P X A C D E J K N O R S T U V B inserted G M P X Y Z A B C D E J K N O R S T U V Y Z Q inserted G M P T X A B C D E J K N O Q R S U V Y Z Lecture 15 ECE250 22

23 Insertion: Example (cont ) L inserted P G M T X A B C D E J K L N O Q R S U V Y Z F inserted P C G M T X A B D E F J K L N O Q R S U V Y Z Lecture 15 ECE250 23

24 Inserting Keys v BtreeInsertNonFull tries to insert a key k into a node x, which is assumed to be nonfull when the procedure is called v BTreeInsert and the recursion in BTreeInsertNonFull guarantee that this assumption is true! Lecture 15 ECE250 24

25 Inserting Keys: Pseudo Code BTreeInsertNonFull(x,k) 01 i n[x] 02 if leaf[x] then 03 while i 1 and k < key i [x] 04 key i+1 [x] key i [x] 05 i i key i+1 [x] k 07 n[x] n[x] DiskWrite(x) 09 else while i 1 and k < key i [x] 10 do i i i i DiskRead c i [x] 13 if n[c i [x]] = 2t 1 then 14 BTreeSplitChild(x,i,c i [x]) 15 if k > key i [x] then 16 i i BTreeInsertNonFull(c i [x],k) leaf insertion internal node: traversing tree Lecture 15 ECE250 25

26 Insertion: Running Time v Disk I/O: O(h), since only O(1) disk accesses are performed during recursive calls of BTreeInsertNonFull v CPU: O(th) = O(t log t n) v At any given time there are O(1) number of disk pages in main memory Lecture 15 ECE250 26