1 / 15

Programming & Data Structures

GRIFFITH COLLEGE DUBLIN. Programming & Data Structures. Heap Sort and Priority Queue. The Heapsort Algorithm. The heapsort algorithm uses the fact that the largest element stored at the root A[1].

degennaro
Download Presentation

Programming & Data Structures

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. GRIFFITH COLLEGE DUBLIN Programming & Data Structures Heap Sort and Priority Queue Lecture 12

  2. The Heapsort Algorithm • The heapsort algorithm uses the fact that the largest element stored at the root A[1]. • We can place this value in its correct position by swapping it with the value at the final position A[n]. • If we decrement the size of the heap and Heapify from A[1] we can restore the heap • The heapsort algorithm then repeats this process for the heap of size n – 1 down to heap of size 2. Lecture 12

  3. Heapsort Algorithm Heapsort(A) Build-Heap(A) for i = length[A] downto 2 exchange A[1] and A[i] heap-size[A] = heap-size[A] – 1 Heapify(A, 1) endfor endalg Lecture 12

  4. 16 14 14 10 8 10 7 9 3 7 9 3 8 4 1 16 2 4 2 1 10 9 8 9 8 3 7 1 3 4 7 1 2 4 16 2 14 16 10 14 8 7 7 3 4 3 2 1 9 2 8 9 4 1 16 16 10 14 10 14 Example HeapSort Lecture 12

  5. 4 3 2 3 2 1 7 8 9 7 8 9 1 4 16 16 10 14 10 14 1 2 2 3 1 3 7 8 9 4 7 8 9 4 16 10 14 16 10 14 Example HeapSort cont. Lecture 12

  6. Analysis of HeapSort • The Heapsort procedure takes time O(n lg n), since the call to Build-Heap takes time O(n) and each of the n-1 calls to Heapify takes time O(lg n) • Heapsort is an excellent algorithm, but a good implementation of quicksort usually beats it in practice. • Nevertheless, the heap data structure itself has enormous utility. • One such use is as an efficient priority queue. Lecture 12

  7. Priority Queue • Many applications require that we process records with keys in order, but not necessarily in full sorted order • Items in a priority queue are not processed strictly in order of entry into the queue • Items can be placed on the queue at any time, but processing always takes the item with the largest key • The priority queue is a generalised queue Abstract Data Structure (ADT) • In fact, the priority queue is a proper generalisation of the stact and the queue ADTs, as we can implement either with priority queues, using appropriate priorities Lecture 12

  8. Definition • A priority queue is a data structure of items with keys that support two basic operations : insert a new item, and delete the item with the largest key. • Applications of priority queues include: • Simulation Systems, where events need to be processed chronologically. • Job scheduling in computer systems. • The Heap Data Structure is an efficient structure for implementing a simple priority queue • In practice, priority queues are more complex than the simple definition above. Lecture 12

  9. Priority Queue • One of the reasons that priority queue implementations are so useful is their flexibility • For that reason any implementation will need to support some of the following operations • Construct a priority queue from N given items • Insert a new item • Delete the maximum item • Change the priority of an arbitrary specified item • Delete an arbitrary specified item • We take “maximum” to mean “any record with the largest key value”. Lecture 12

  10. Heap Extract • As with many data structures, we also need to add standard initialise, test if empty and perhaps destroy and copy operations • Lets look at insert and delete maximum. Heap-Extract-Max(A) if heap-size[A] < 1 then error “heap underflow” endif max = A[1] A[1] = A[heap-size[A]] heap-size[A] = heap-size[A] – 1 Heapify(A, 1) return max endalg • The running time of Heap-Extract-Max is O(lg n), since it performs only a constant amount of work on top of the O(lg n) time for Heapify Lecture 12

  11. Heap Insert • Heap-Insert inserts a node into heap A. Expand by adding a new leaf to the tree. Traverse a path from this leaf toward the root to find a place for the new element. Heap-Insert(A, key) heap-size[A] = heap-size[A] + 1 i = heap-size[A] while i > 1 and A[Parent(i)] < key do A[i] = A[Parent(i)] i = Parent(i) endwhile A[i] = key endalg • Running time of on an n-element heap is O(lg n) since the path traced from the new leaf to the root has length O(lg n) • This is an example of a non-recursive sift up procedure. Lecture 12

  12. 16 16 14 10 14 10 7 9 3 7 9 3 8 8 1 1 2 4 2 4 16 16 10 15 10 14 9 3 14 9 3 8 8 1 7 1 7 2 4 2 4 Example Heap Insert (15) (a) (b) (d) (c) (a) is the heap before insert, (b) add a leaf (c) Copy from leaf to root until place fornew item found(d) Add new item Lecture 12

  13. Heap Delete • To construct a priority queue it is simply necessary to call Build-Heap for the array • To delete an arbitrarily specified item from the queue follow the design for Heap-Extract-Max Heap-Delete(A, i) if heap-size[A] < 1 then error “heap underflow” endif item = A[i] A[i] = A[heap-size[A]] heap-size[A] = heap-size[A] – 1 Heapify(A, i) return item endalg • Which will run in at worst O(lg n) time Lecture 12

  14. Changing Priorities • What if we want to change a node priority? • Implement based on the existing functions? • ‘Delete old value’ and ‘Insert new value’ • Each of these will run in O(lg n) time, which means that the procedure will also run in O(lg n) time. • The heap provides an efficient implementation for a priority queue using the operations outlined, but is not so efficient in other cases • For example, an operation which may sometimes be required is the join operation to merge two priority queues • There are other implementations (e.g. doubly linked list) which support this operation more efficiently Lecture 12

  15. Summary • The heapsort algorithm uses the fact that the largest element stored at the root A[1]. • We can place this value in its correct position by swapping it with the value at the final position A[n]. • If we decrement the size of the heap and Heapify from A[1] we can restore the heap • A heap can be an efficient implementation for a priority queue • To implement this we need to develop insert, delete and extract max algorithms Lecture 12

More Related