Algorithms and Data Structures

Transcription

1 Ordered Dictionaries and Binary Search Trees Page 1 BFH-TI: Softwareschule Schweiz Ordered Dictionaries and Binary Search Trees Dr. CAS SD01

2 Ordered Dictionaries and Binary Search Trees Page Outline Ordered Dictionaries Binary Search Trees AVL Trees

3 Ordered Dictionaries and Binary Search Trees Ordered Dictionaries Page 3 Outline Ordered Dictionaries Binary Search Trees AVL Trees

4 Ordered Dictionaries and Binary Search Trees Ordered Dictionaries Page 4 Ordered Dictionaries An ordered dictionary is a dictionary (searchable collection of items) with a total order over the keys To specify the key ordering, we use a comparator (see Topic 5) The main operations of an ordered dictionary ADT are the same as for an unordered dictionary Further operations: closestkeybefore(k): Returns the key of the item with the largest key less than or equal to k closestelementbefore(k): Returns the element of the item with the largest key less than or equal to k closestkeyafter(k): Returns the key of the item with the smallest key greater than or equal to k closestelementafter(k): Returns the element of the item with the smallest key greater than or equal to k

5 Ordered Dictionaries and Binary Search Trees Ordered Dictionaries Page 5 Lookup Tables A lookup table is an ordered dictionary implemented by means of a sorted array-based vector (similar to unsorted log files) Performance: findelement(k) runs in O(log n) time with binary search (see next slides) insertitem(k,e) runs in O(n) time since we need to shift n/ items in the worst case removeelement(k) runs in O(n) time since we need to shift n/ items in the worst case A lookup table is effective only for some particular situations: For dictionaries of small size When searches are the most common operations, while insertions and removals are rarely performed

6 Ordered Dictionaries and Binary Search Trees Ordered Dictionaries Page 6 Binary Search Binary search performs the operation findelement(k) in a lookup table as follows (divide-and-conquer): Get the key from the item stored in the middle of the vector If the middle key matches with k, return the element Otherwise, continue the search either in the first or in the second half of the vector Example: findelement(7) binarysearch(7,0,13) Step 1 Step Step 3 Step

7 Ordered Dictionaries and Binary Search Trees Ordered Dictionaries Page 7 Binary Search (cont.) Algorithm binarysearch(k, low, high) // runs in O(log n) time if low > high then return NO_SUCH_KEY mid (low + high)/ item V. elematrank(mid) if C. isequalto(k, item.key) then return item.element if C. islessthan(k, item.key) then return binarysearch(k, low, mid 1) return binarysearch(k, mid+1, high) Apply rule D1 (Topic, p.31) with q = 1, r = to get O(log n)

8 Ordered Dictionaries and Binary Search Trees Ordered Dictionaries Page 8 Ordered Dictionary: Performance Operation Log File Lookup Table isempty 1 1 size 1 1 findelement n log n insertitem 1 n removeelement n n findallelements n n removeallelements n n closestkeybefore n log n closestelementbefore n log n closestkeyafter n log n closestelementafter n log n

9 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page 9 Outline Ordered Dictionaries Binary Search Trees AVL Trees

10 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page 10 Binary Search Trees A binary search tree (BST) is a specialized binary tree storing keys at its nodes and satisfying the following properties: The keys in left subtree of a node are smaller (or equal) The keys in the right subtree of a node are greater (or equal) In other words, if p, q, and r are three nodes such that q is in the left subtree of p and r is in the right subtree of p, then element(q) element(p) element(r) BST operations (see demo): findkey(k): checks whether k is in the BST insertkey(k): inserts a new key k into the BST removekey(k): removes an existing key k from the BST removeallkeys(k): removes all keys k from the BST

11 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page 11 Binary Search Trees: Example Note that an inorder traversal visits the keys in increasing order

12 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page 1 Implementing Binary Search Trees An array-based implementation requires O( n ) space in the worst case (see Topic 4) Thus, binary search trees are usually implemented as linked structures A common trick to simplify the implementation is to add empty external nodes to all unassigned children, thus making it a proper binary tree

13 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page 13 BST Search To search for a key k in a BST, we trace a downward path starting at the root The next node visited depends on the outcome of the comparison of k with the key of the current node Example: findkey(10) > > < 1 If we reach a leaf, the key is not found and we return NO SUCH KEY

14 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page 14 BST Search (cont.) Algorithm findkey(k) // for a non empty tree p treesearch(k, T. root()) if T. isexternal(p) then return NO_SUCH_KEY return p. element() // usually equal to k Algorithm treesearch(k, p) // runs in O(h) time if T. isexternal(p) or C. isequalto(k, p. element()) then return p if C. islessthan(k, p. element()) then return treesearch(k, T. leftchild(p)) else return treesearch(k, T. rightchild(p))

15 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page 15 BST Insertion To insert a new key k in a BST, we search with treesearch for k, starting at the root If the returned node p is external, we insert k at p and expand p into an internal node (add two empty children) If the returned node p is internal, we continue to search with treesearch from the left (or right) child of p Example: insertkey(0) 5 1 > 1st stop > > nd stop 0

16 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page 16 BST Removal To remove a key k from a BST, we search with treesearch for k, starting at the root (unless the tree is empty) If the returned node p is external, we return NO SUCH KEY If the returned node p is internal, it depends on whether the children of p are external Case 1: If both children are external, we remove them with removechildren(p) and delete the reference to k Case : If one child is internal and one external, say q, we remove p and q with removeparent(q) Case 3: If both children are internal, we cannot simply remove p, since this would create a hole in the tree (solution discussed next)

17 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page 17 BST Removal: Case 1 Example: removekey(6) p

18 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page 18 BST Removal: Case Example: removekey(1) p q

19 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page 19 BST Removal: Case 3 Case 3: If both children are internal, we proceed as follows: Starting from the left (or right) child of p, we follow the path along the right (or left) children until an external node q is reached We move the key from parent(q) to p We remove q and parent(q) with with removeparent(q) Note that q is the right-most (or left-most) node in the inorder traversal of the left (or right) subtree of p The removal of a key with removekey(k) runs in O(h) time The removal of all s keys with removeallkeys(k) can be realized in O(h+s) time

20 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page 0 BST Removal: Case 3 Example: removekey(0) p q

21 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page 1 BST-Based Ordered Dictionaries We can use a BST to implement an ordered dictionary by storing (k, e)-items instead of simple keys For this to work, we need to extend the comparator from keys to items All operations run in O(h) respectively O(h+s) time Best case: h is O(log n) Worst case: h is O(n) Depending on how balanced the tree is, we obtain varying running times (between logarithmic and linear)

22 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page Ordered Dictionary: Performance (cont.) Operation Log File Lookup Table BST isempty size findelement n log n h insertitem 1 n h removeelement n n h findallelements (s items) n n h + s removeallelements (s items) n n h + s closestkeybefore n log n h closestelementbefore n log n h closestkeyafter n log n h closestelementafter n log n h

23 Ordered Dictionaries and Binary Search Trees Binary Search Trees Page 3 UML Diagram <<interface>> Comparator islessthan(x,y) isequalto(x,y) etc. <<interface>> Dictionary findelement(k) insertitem(k,e) removeelement(k) etc. <<interface>> Collection isempty() size() <<interface>> OrderedDictionary closestkeybefore(k) closestelementbefore(k) closestkeyafter(k) closestelementafter(k) <<interface>> BinarySearchTree findkey(k) insertkey(k) removekey(k) removeallkeys(k) LogFile S: Sequence C: Comparator LookupTable V: Vector C: Comparator BSTDictionary T: BinarySearchTree C: Comparator BinaryTreeBST T: BinaryTree C: Comparator

24 Ordered Dictionaries and Binary Search Trees AVL Trees Page 4 Outline Ordered Dictionaries Binary Search Trees AVL Trees

25 Ordered Dictionaries and Binary Search Trees AVL Trees Page 5 AVL Trees An interal node p in a proper binary tree is called balanced, if the heights of the subtrees of its children differ by at most 1 A binary search tree is called AVL tree, if all its internal nodes are balanced (height-balance property) The AVL tree is named after its two inventors Adelson-Velsky and Landis

26 Ordered Dictionaries and Binary Search Trees AVL Trees Page 6 Height of AVL Trees Theorem: The height of a AVL tree of size n is O(log n) Proof: Let n(h) denote the minimum number of internal nodes It s easy to see that n(1) = 1, n() = For n >, a minimal-sized AVL tree of height h contains a root, a subtree of height h 1 and a subtree of height h : n(h) = 1 + n(h 1) + n(h ) Knowing n(h 1) > n(h ), we get: n(h) > n(h ) > 4n(n 4) > 8n(h 6) > > i n(h i) Solving the base case h i = 1, we get: n(h) > h 1 Taking logarithms: h < log n(h) + 1, i.e. h is O(log n) Similar for the other base case h i =

27 Ordered Dictionaries and Binary Search Trees AVL Trees Page 7 AVL Trees Updates Initially, insertion and removal works as for binary search trees Insertion is always done by expanding an external node, possibly causing imbalanced predecessors Predecessors of deleted nodes may cause an imbalance 5 6 insertkey(3) 4 6 removekey(3) After adding or deleting nodes, a tree restructuring needs to take place to fix the imbalance (see demo)

28 Ordered Dictionaries and Binary Search Trees AVL Trees Page 8 Tree Restructuring Let z be the deepest unbalanced node in the tree, let y be the child of z with a higher subtree, and let x be the child of y with a higher subtree Up to symmetry, there are two cases (four cases in total): T 0 z y x single rotation z y x T 1 T T 3 T 0 T 1 T T 3 T 0 z x y double rotation z x y T 3 T 1 T T 0 T 1 T T 3

29 Ordered Dictionaries and Binary Search Trees AVL Trees Page 9 Tree Restructuring: Example single rotation double rotation

30 Ordered Dictionaries and Binary Search Trees AVL Trees Page 30 Tree Restructuring: Performance After insertion, a single tree restructuring fixes imbalances globally Rebalancing after insertion runs in O(1) time After removal, a single tree restructuring fixes imbalances only locally After rebalancing z, we need to continue looking for unbalanced predecessors of z Rebalancing after removal runs in O(log n) time Searching, inserting, and removing keys in a AVL tree run in O(log n) time If an ordered dictionary is implemented using a AVL tree, searching, inserting, and removing items run in O(log n) time

31 Ordered Dictionaries and Binary Search Trees AVL Trees Page 31 Ordered Dictionary: Performance (cont.) Operation Log F. Lookup T. BST AVL Tree isempty size findelement n log n h log n insertitem 1 n h log n removeelement n n h log n findallelements n n h + s log n + s removeallelements n n h + s log n + s closestkeybefore n log n h log n closestelementbefore n log n h log n closestkeyafter n log n h log n closestelementafter n log n h log n