Data Structures. Motivation

Transcription

1 Data Structures B Trees Motivation When data is too large to fit in main memory, it expands to the disk. Disk access is highly expensive compared to a typical computer instruction The number of disk accesses will dominate the running time. Our goal is to devise a search tree that will minimize disk accesses. 1

2 Typical Disk Drive B Tree A balanced search tree designed to work well on direct access secondary storage devices. A generalize search tree. 2

3 B Tree Each node corresponds to a block of data on the disk. Minimizes disk accesses. Tree of height 2 containing over one billion keys. Definition A B tree T is a rooted tree (at root[t]) having the following properties: 1. Every node x has the following fields: a. n[x], the number of keys currently stored in node x, b. the n[x] keys themselves, stored in non decreasing order, so that key 1 [x] key 2 [x] key n[x] [x], c. leaf[x], a Boolean value that t is TRUE if x is a leaf and FALSE if x is an internal node. 3

4 Definition 2. Each internal node x also contains n[x]+ 1 pointers c 1 [x], c 2 [x],..., c n[x]+1 [x] to its children. Leaf nodes have no children, so their c i fields are undefined. 3. The keys key i [x] separate the ranges of keys stored in each sub tree: if k i is any key stored in the sub tree with root c i i[ [x], then k 1 key 1 [x] k 2 key 2 [x] key n[x] [x] k n[x] All leaves have the same depth, which is the tree's height h. Definition 5. There are lower and upper bounds on the number ofkeys a node can contain. These bounds can be expressed in terms of a fixed integer t 2 called the minimum degree of the B tree: a. Every node other than the root must have at least t 1 keys. Every internal node thus has at least t children. If the tree is nonempty, the root must have at least one key. b. Every nodecan contain at most2t 1 keys. Therefore, an internal node can have at most 2t children. We say that a node is full if it contains exactly 2t 1 keys. 4

5 2 3 4 Tree The simplest B tree occurs when t = 2. Every internal node then has either 2, 3, or 4 children, and we have a tree. In practice, however, much larger values of t are typically used. Height Theorem: If n 1, then for any n key B tree T of height h and minimum degree t 2, Proof: If a B tree has height h, the number of its nodes is minimized when the root contains one key and all other nodes contain t 1 keys. In this case, there are 1 node at the root 2 nodes at depth 1, 2t nodes at depth 2, 2t 2 nodes at depth 3, and so on, until at depth h there are 2t h 1 nodes 5

6 Height Thus, the number n of keys satisfies the inequality: which implies Basic Operations We always keep the root in main memory, so that t a DISK READ on the root is never required Any nodes that are passed as parameters must already have had a DISK READ. Any changed node must have DISK WRITE. 6

7 Searching search (x, k) i = 1 while (i n[x] & k > key i [x]) do i =i + 1 if (i n[x] & k = key i [x]) then return (x, i) if (leaf [x]) then return null else diskread(c i [x]) return search(c i [x], k) CPU time is O(th) = O(t log t n). Disk access is O(h) = O(log t n) Insertion 7

8 create (T) Creating an Empty B tree x = ALLOCATE NODE() leaf[x] = TRUE n[x] = 0 diskwrite(x) root[t] [] = x CPU time is O(1). Disk access is O(1) Splitting a Node 8

9 Splitting a Node splitchild (x, i, y) z = allocatenode(), leaf[z] leaf[y], n[z] t 1 for (j = 1 to t 1) do key j [z] key j+t [y] if (not leaf[y]) then for (j = 1 to t) do c j [z] c j+t [y] n[y] = t 1 for (j = n[x] + 1 downto i+ 1) do c j+1 [x] c j [x] c i+1[ [x] z for (j = n[x] downto i) do key j+1 [x] key j [x] key i [x] key t [y], n[x] n[x] + 1 diskwrite(y), diskwrite(z), diskwrite(x) CPU time is O(t). Disk access is O(1) Insertion insert (T, k) r = root[t] if (n[r] = 2t 1) then s = allocatenode(), root[t] = s, leaf[s] = false, n[s] = 0, c 1 [s] = r splitchild(s, 1, r) r = s insertnonfull(r, k) 9

10 Insertion insertnonfull (x, k) CPU time is O(th) = O(t log t n). i= n[x] Disk access is O(h) = O(log t n) if (leaf[x]) then while (i 1 & k < key i [x]) do key i+1 [x] = key i [x], i= i 1 key i+1 [x] k n[x] n[x] + 1 diskwrite(x) else while (i 1 & k < key i [x]) do i =i 1 i= i+ 1 diskread(c i [x]) if (n[c i [x]] = 2t 1) then splitchild (x, i, ci[x]) if (k > key i [x]) then i= i+ 1 insertnonfull (ci[x], k) Deletion delete (x, k) (1) if (the key k is in node x & x is a leaf) delete the key k from x. (2a) else if (k is in x & x is internal & the child y that precedes k has at least t keys) recursively delete the predecessor k of k, replace k by k in x (2b) Symmetrically, if (k is in x & x is internal & the child z that follows k has at least t keys) (2c) else if (k is in x & x is internal) delete k and merge its children 10

11 Deletion CPU time is O(th) = O(t log t n). Disk access is O(h) = O(log t n) else if (k is not present in internal node x) determine the root r of the appropriate subtree that must contain k (3a) if (r has only t 1 keys but has an immediate sibling with at least t keys) give r an extra key by shifting (3b) else if (r and both of r's rsimmediate siblings have t 1 keys) merge r with one sibling finish by recurring on the appropriate child of x 11