1 / 40

Analysis of Algorithms CS 477/677

Analysis of Algorithms CS 477/677. Instructor: Monica Nicolescu. The Heap Data Structure. Def: A heap is a nearly complete binary tree with the following two properties: Structural property: all levels are full, except possibly the last one, which is filled from left to right

kipling
Télécharger la présentation

Analysis of Algorithms CS 477/677

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Analysis of AlgorithmsCS 477/677 Instructor: Monica Nicolescu

  2. The Heap Data Structure • Def:A heap is a nearly complete binary tree with the following two properties: • Structural property: all levels are full, except possibly the last one, which is filled from left to right • Order (heap) property: for any node x Parent(x) ≥ x 8 It doesn’t matter that 4 in level 1 is smaller than 5 in level 2 7 4 5 2 Heap CS 477/677

  3. Array Representation of Heaps • A heap can be stored as an array A. • Root of tree is A[1] • Left child of A[i] = A[2i] • Right child of A[i] = A[2i + 1] • Parent of A[i] = A[ i/2 ] • Heapsize[A] ≤ length[A] • The elements in the subarray A[(n/2+1) .. n] are leaves • The root is the maximum element of the heap A heap is a binary tree that is filled in order CS 477/677

  4. Maintaining the Heap Property • Suppose a node is smaller than a child • Left and Right subtrees of i are max-heaps • Invariant: • the heap condition is violated only at that node • To eliminate the violation: • Exchange with larger child • Move down the tree • Continue until node is not smaller than children CS 477/677

  5. Convert an array A[1 … n] into a max-heap (n = length[A]) The elements in the subarray A[(n/2+1) .. n] are leaves Apply MAX-HEAPIFY on elements between 1 and n/2 1 4 2 3 1 3 4 5 6 7 2 16 9 10 8 9 10 14 8 7 Building a Heap A: CS 477/677

  6. Heapsort • Goal: • Sort an array using heap representations • Idea: • Build a max-heap from the array • Swap the root (the maximum element) with the last element in the array • “Discard” this last node by decreasing the heap size • Call MAX-HEAPIFY on the new root • Repeat this process until only one node remains CS 477/677

  7. O(n) n-1times O(lgn) Alg: HEAPSORT(A) • BUILD-MAX-HEAP(A) • for i ← length[A]downto 2 • do exchange A[1] ↔ A[i] • MAX-HEAPIFY(A, 1, i - 1) • Running time: O(nlgn) CS 477/677

  8. MAX-HEAPIFY(A, 1, 4) MAX-HEAPIFY(A, 1, 3) MAX-HEAPIFY(A, 1, 2) MAX-HEAPIFY(A, 1, 1) Example: A=[7, 4, 3, 1, 2] CS 477/677

  9. HEAP-MAXIMUM Goal: • Return the largest element of the heap Alg: HEAP-MAXIMUM(A) • return A[1] Running time:O(1) Heap A: Heap-Maximum(A) returns 7 CS 477/677

  10. Root is the largest element HEAP-EXTRACT-MAX Goal: • Extract the largest element of the heap (i.e., return the max value and also remove that element from the heap Idea: • Exchange the root element with the last • Decrease the size of the heap by 1 element • Call MAX-HEAPIFY on the new root, on a heap of size n-1 Heap A: CS 477/677

  11. HEAP-EXTRACT-MAX Alg: HEAP-EXTRACT-MAX(A, n) • if n < 1 • then error “heap underflow” • max ← A[1] • A[1] ← A[n] • MAX-HEAPIFY(A, 1, n-1) remakes heap • return max Running time:O(lgn) CS 477/677

  12. 16 14 1 14 10 14 8 10 10 8 7 9 3 4 8 7 7 9 9 3 3 2 4 1 2 2 1 4 Example: HEAP-EXTRACT-MAX max = 16 Heap size decreased with 1 Call MAX-HEAPIFY(A, 1, n-1) CS 477/677

  13. 16 14 10 8 7 9 3 i 2 4 1 HEAP-INCREASE-KEY • Goal: • Increases the key of an element i in the heap • Idea: • Increment the key of A[i] to its new value • If the max-heap property does not hold anymore: traverse a path toward the root to find the proper place for the newly increased key Key [i]← 15 CS 477/677

  14. 16 14 10 8 7 9 3 i 2 4 1 HEAP-INCREASE-KEY Alg: HEAP-INCREASE-KEY(A, i, key) • if key < A[i] • then error “new key is smaller than current key” • A[i] ← key • while i > 1 and A[PARENT(i)] < A[i] • do exchange A[i] ↔ A[PARENT(i)] • i ← PARENT(i) • Running time: O(lgn) Key [i]← 15 CS 477/677

  15. 16 16 Key [i ] ← 15 14 14 10 10 16 16 8 8 7 7 9 9 3 3 i i i 2 2 4 15 1 1 14 10 15 10 i 15 7 9 3 14 7 9 3 2 8 1 2 8 1 Example: HEAP-INCREASE-KEY CS 477/677

  16. 16 - 14 10 8 7 9 3 2 4 1 15 MAX-HEAP-INSERT • Goal: • Inserts a new element into a max-heap • Idea: • Expand the max-heap with a new element whose key is - • Calls HEAP-INCREASE-KEY to set the key of the new node to its correct value and maintain the max-heap property 16 14 10 8 7 9 3 2 4 1 CS 477/677

  17. - MAX-HEAP-INSERT Alg: MAX-HEAP-INSERT(A, key, n) • heap-size[A] ← n + 1 • A[n + 1] ← - • HEAP-INCREASE-KEY(A, n + 1, key) 16 14 10 8 7 9 3 2 4 1 Running time:O(lgn) CS 477/677

  18. Insert value 15: - Start by inserting - Increase the key to 15 Call HEAP-INCREASE-KEY on A[11] = 15 16 16 14 10 14 10 8 7 9 3 8 7 9 3 2 4 1 2 4 1 15 The restored heap containing the newly added element - 16 16 15 10 14 10 8 14 9 3 8 15 9 3 2 4 1 7 2 4 1 7 Example: MAX-HEAP-INSERT CS 477/677

  19. Summary • We can perform the following operations on heaps: • MAX-HEAPIFY O(lgn) • BUILD-MAX-HEAP O(n) • HEAP-SORT O(nlgn) • MAX-HEAP-INSERT O(lgn) • HEAP-EXTRACT-MAX O(lgn) • HEAP-INCREASE-KEY O(lgn) • HEAP-MAXIMUM O(1) CS 477/677

  20. The Search Problem • Find items with keys matching a given search key Applications: • Keeping track of customer account information at a bank • Search through records to check balances and perform transactions • Keep track of reservations on flights • Search to find empty seats, cancel/modify reservations • Search engine • Looks for all documents containing a given word CS 477/677

  21. Symbol Tables (Dictionaries) • Dictionary = data structure that supports two basic operations: insert a new item and return an item with a given key • Queries: return information about the set • Search (S, k) • Minimum (S), Maximum (S) • Successor (S, x), Predecessor (S, x) • Modifying operations: change the set • Insert (S, k) • Delete (S, k) CS 477/677

  22. Implementations of Symbol Tables • Key-indexed-array • Key values are distinct, small numbers • Store the items in an array, indexed by keys • Ordered/unordered arrays • Ordered/unordered linked lists Insert Search key-indexed array 1 1 ordered array N N ordered list N N unordered array 1 N unordered list 1 N CS 477/677

  23. Binary Search Trees • Support many dynamic set operations • SEARCH, MINIMUM, MAXIMUM, PREDECESSOR, SUCCESSOR, INSERT • Running time of basic operations on binary search trees • On average: (lgn) • The expected height of the tree is lgn • In the worst case: (n) • The tree is a linear chain of n nodes CS 477/677

  24. parent L R key data Right child Left child Binary Search Trees • Tree representation: • A linked data structure in which each node is an object • Node representation: • Key field • Satellite data • Left: pointer to left child • Right: pointer to right child • p: pointer to parent (p [root [T]] = NIL) • Satisfies the binary-search-tree property CS 477/677

  25. 5 3 7 2 5 9 Binary Search Tree Example • Binary search tree property: • If y is in left subtree of x, then key [y] ≤ key [x] • If y is in right subtree of x, then key [y] ≥ key [x] CS 477/677

  26. 5 3 7 2 5 9 Traversing a Binary Search Tree • Inorder tree walk: • Prints the keys of a binary tree in sorted order • Root is printed between the values of its left and right subtrees: left, root, right • Preorder tree walk: • root printed first: root, left, right • Postorder tree walk: left, right, root • root printed last Inorder: 2 3 5 5 7 9 Preorder: 5 3 2 5 7 9 Postorder: 2 5 3 9 7 5 CS 477/677

  27. 5 3 7 2 5 9 Traversing a Binary Search Tree Alg: INORDER-TREE-WALK(x) • if x  NIL • then INORDER-TREE-WALK ( left [x]) • print key [x] • INORDER-TREE-WALK ( right [x]) • E.g.: • Running time: • (n), where n is the size of the tree rooted at x Output: 2 3 5 5 7 9 CS 477/677

  28. 5 3 7 2 4 9 Searching for a Key • Given a pointer to the root of a tree and a key k: • Return a pointer to a node with key k if one exists • Otherwise return NIL • Idea • Starting at the root: trace down a path by comparing k with the key of the current node: • If the keys are equal: we have found the key • If k < key[x] search in the left subtree of x • If k > key[x] search in the right subtree of x CS 477/677

  29. 5 3 7 2 4 9 Searching for a Key Alg: TREE-SEARCH(x, k) • if x = NIL or k = key [x] • then return x • if k < key [x] • then return TREE-SEARCH(left [x], k ) • else return TREE-SEARCH(right [x], k ) Running Time: O (h), h – the height of the tree CS 477/677

  30. 15 6 18 3 7 17 20 2 4 13 9 Example: TREE-SEARCH • Search for key 13: • 15  6  7  13 CS 477/677

  31. Iterative Tree Search Alg:ITERATIVE-TREE-SEARCH(x, k) • while x  NIL and k  key [x] • do if k < key [x] • then x  left [x] • else x  right [x] • return x CS 477/677

  32. 15 6 18 3 7 17 20 2 4 13 9 Finding the Minimum in a Binary Search Tree • Goal: find the minimum value in a BST • Following left child pointers from the root, until a NIL is encountered Alg: TREE-MINIMUM(x) • while left [x] NIL • do x ← left [x] • return x Running time: O(h), h – height of tree Minimum = 2 CS 477/677

  33. 15 6 18 3 7 17 20 2 4 13 9 Finding the Maximum in a Binary Search Tree • Goal: find the maximum value in a BST • Following right child pointers from the root, until a NIL is encountered Alg: TREE-MAXIMUM(x) • while right [x] NIL • do x ← right [x] • return x • Running time: O(h), h – height of tree Maximum = 20 CS 477/677

  34. 15 6 18 3 7 17 20 2 4 13 9 Successor Def: successor (x ) =y, such that key [y] is the smallest key > key [x] • E.g.:successor (15) = successor (13) = successor (9) = • Case 1: right (x) is non empty • successor (x ) = the minimum in right (x) • Case 2: right (x) is empty • go up the tree until the current node is a left child: successor (x ) is the parent of the current node • if you cannot go further (and you reached the root): x is the largest element 17 15 13 CS 477/677

  35. 15 6 18 3 7 17 20 2 4 13 9 Finding the Successor Alg: TREE-SUCCESSOR(x) • if right [x]  NIL • then return TREE-MINIMUM(right [x]) • y ← p[x] • while y  NIL and x = right [y] • do x ← y • y ← p[y] • return y Running time: O (h), h – height of the tree y x CS 477/677

  36. 15 6 18 3 7 17 20 2 4 13 9 Predecessor Def: predecessor (x ) =y, such that key [y] is the biggest key < key [x] • E.g.:predecessor (15) = predecessor (9) = predecessor (13) = • Case 1: left (x) is non empty • predecessor (x ) = the maximum in left (x) • Case 2: left (x) is empty • go up the tree until the current node is a right child: predecessor (x ) is the parent of the current node • if you cannot go further (and you reached the root): x is the smallest element 13 7 9 CS 477/677

  37. 12 5 18 2 9 15 19 1 3 13 17 Insertion • Goal: • Insert value vinto a binary search tree • Idea: • If key [x] < v move to the right child of x, else move to the left child of x • When x is NIL, we found the correct position • If v < key [y] insert the new node as y’s left child else insert it as y’s right child • Begining at the root, go down the tree and maintain: • Pointer x: traces the downward path (current node) • Pointer y: parent of x (“trailing pointer” ) Insert value 13 CS 477/677

  38. y y 12 12 12 12 x 5 5 5 5 18 18 18 18 2 2 2 2 9 9 9 9 15 15 15 15 19 19 19 19 1 1 1 1 3 3 3 3 17 17 17 17 x 13 Example: TREE-INSERT x, y=NIL Insert 13: x = NIL y = 15 CS 477/677

  39. 12 5 18 2 9 15 19 1 3 13 17 Alg:TREE-INSERT(T, z) • y ← NIL • x ← root [T] • while x ≠ NIL • do y ← x • if key [z] < key [x] • then x ← left [x] • else x ← right [x] • p[z] ← y • if y = NIL • then root [T] ← z Tree T was empty • else if key [z] < key [y] • then left [y] ← z • else right [y] ← z Running time: O(h) CS 477/677

  40. Readings • Chapter 6 • Chapter 12 CS 477/677

More Related