Document Sample

Chapter 6 Heapsort 1 Introduction • Heapsort – Running time: O(n lg n) • Like merge sort – Sort in place: only a constant number of array elements are stored outside the input array at any time • Like insertion sort • Heap – A data structure used by Heapsort to manage information during the execution of the algorithm – Can be used as an efficient priority queue 2 Heaps 3 Binary Heap • An array object that can be viewed as a nearly complete binary tree (see Section B.5.3) – Each tree node corresponds to an array element that stores the value in the tree node – The tree is completely filled on all levels except possibly the lowest, which is filled from the left up to a point – A has two attributes • length[A]: # of elements in the array • heap-size[A]: # of elements in the heap stored within A – heap-size[A] length[A] – No element past A[heap-size[A]] is an element of the heap – max-heap and min-heap 4 A Max-Heap 5 Length and Heap-Size 11 7 11 7 Length = 10 Heap-Size = 7 6 Heap Computation • Given the index i of a node, the indices of its parent, left child, and right child can be computed simply: i PARENT (i ) : return / 2 LEFT (i ) : return 2i RIGHT (i ) : return 1 2i 7 Heap Property • Heap property – the property that the values in the node must satisfy • Max-heap property: for every node i other than the root – A[PARENT(i)] A[i] – The value of a node is at most the value of its parent – The largest element in a max-heap is stored at the root – The subtree rooted at a node contains values on larger than that contained at the node itself • Min-heap property: for every node i other than the root – A[PARENT(i)] A[i] 8 Heap Height • The height of a node in a heap is the number of edges on the longest simple downward path from the node to a leaf • The height of a heap is the height of its root – The height of a heap of n elements is (lg n) 9 Heap Procedures • MAX-HEAPIFY: maintain the max-heap property – O(lg n) • BUILD-MAX-HEAP: produces a max-heap from an unordered input array – O(n) • HEAPSORT: sorts an array in place – O(n lg n) • MAX-HEAP-INSERT, HEAP-EXTRACT, HEAP-INCREASE- KEY, HEAP-MAXIMUM: allow the heap data structure to be used as a priority queue – O(lg n) 10 Maintaining the Heap Property • MAX-HEAPIFY – Inputs: an array A and an index i into the array – Assume the binary tree rooted at LEFT(i) and RIGHT(i) are max- heaps, but A[i] may be smaller than its children (violate the max- heap property) – MAX-HEAPIFY let the value at A[i] floats down in the max-heap 11 Example of MAX-HEAPIFY 12 MAX-HEAPIFY Extract the indices of LEFT and RIGHT children of i Choose the largest of A[i], A[l], A[r] Float down A[i] recursively 13 Running time of MAX- HEAPIFY • (1) to find out the largest among A[i], A[LEFT(i)], and A[RIGHT(i)] • Plus the time to run MAX-HEAPIFY on a subtree rooted at one of the children of node i – The children’s subtrees each have size at most 2n/3 – the worst case occurs when the last row of the tree is exactly half full • T(n) T(2n/3) + (1) – By case 2 of the master theorem: T(n) = O(lg n) 14 7/11 Building A Heap 15 Build Max Heap • Observation: A[(n/2+1)..n] are all leaves of the tree – Each is a 1-element heap to begin with • Upper bound on the running time – O(lg n) for each call to MAX-HEAPIFY, and call n times O(n lg n) • Not tight 16 17 Loop Invariant • At the start of each iteration of the for loop of lines 2-3, each node i+1, i+2, .., n is the root of a max-heap – Initialization: Prior to the first iteration of the loop, i = n/2. Each node n/2+1, n/2+2,.., n is a leaf and the root of a trivial max-heap. – Maintenance: Observe that the children of node i are numbered higher than i. By the loop invariant, therefore, they are both roots of max-heaps. This is precisely the condition required for the call MAX- HEAPIFY(A, i) to make node i a max-heap root. Moreover, the MAX- HEAPIFY call preserves the property that nodes i+1, i+2, …, n are all roots of max-heaps. Decrementing i in the for loop update reestablishes the loop invariant for the next iteration – Termination: At termination, i=0. By the loop invariant, each node 1, 2, …, n is the root of a max-heap. In particular, node 1 is. 18 Cost for Build-MAX-HEAP • Heap-properties of an n-element heap – Height = lg n – At most n/2h+1 nodes of any height h lg n n lg n h h h1 O ( h) O ( n h ) O ( n h ) O ( n) h 0 2 h 0 2 h 0 2 Ignore the constant ½ h 1 2 2 h 0 2 h (1 1 ) 2 2 x kx k (for |x| < 1) h 0 (1 x) 2 19 The HeapSort Algorithm 20 Idea • Using BUILD-MAX-HEAP to build a max-heap on the input array A[1..n], where n=length[A] • Put the maximum element, A[1], to A[n] – Then discard node n from the heap by decrementing heap-size(A) • A[2..n-1] remain max-heaps, but A[1] may violate – call MAX-HEAPIFY(A, 1) to restore the max-heap property for A[1..n-1] • Repeat the above process from n down to 2 • Cost: O(n lg n) – BUILD-MAX-HEAP: O(n) – Each of the n-1 calls to MAX-HEAPIFY takes time O(lg n) 21 Next Slide Example of HeapSort 22 Example of HeapSort (Cont.) 1 10 1 14 14 10 9 1 14 23 Algorithm 24 Priority Queues 25 Definition • A priority queue is a data structure for maintaining a set S of elements, each with an associated value called a key. A max-priority queue supports the following operations: – INSERT(S, x) inserts the element x into the set S – MAXIMUM(S) returns the element of S with the largest key – EXTRACT-MAX(S) removes and returns the element of S with the largest key – INCREASE-KEY(S, x, k) increases the value of element x’s key to the new value k, which is assumed to be at least as largest as x’s current key value • Application of max-priority queue: Job scheduling in computer 26 HEAP-MAXIMUM and HEAP-EXTRACT-MAX (1) O(lg n) 27 HEAP-INCREASE-KEY • Steps – Update the key of A[i] to its new value • May violate the max-heap property – Traverse a path from A[i] toward the root to find a proper place for the newly increased key O(lg n) 28 29 Example of HEAP-INCREASE-KEY MAX-HEAP-INSERT O(lg n) 30

DOCUMENT INFO

Shared By:

Categories:

Tags:
sets and disjoin sets, binary search, merge sort, qick sort, selection sort, Strassen’s matrix multiplication algorithms, Greedy Method, knapsack problem, job sequencing with dead lines, minimum spanning trees, single souce paths, Cook’s theorem, NP hard graph and NP scheduling, dynamic programing, 8 queen’s problem, graph colouring, Hamiltonian cycles

Stats:

views: | 83 |

posted: | 1/26/2011 |

language: | English |

pages: | 30 |

Description:
Analysis and Design of Algorithms

SHARED BY

About
if any file u wil find copyright contact me it will be remove in 3 to 4 buisnees days.
add me on sanjaydudeja007@gmail.com
or visit
http://www.ohotech.com/

OTHER DOCS BY SanjuDudeja

How are you planning on using Docstoc?
BUSINESS
PERSONAL

By registering with docstoc.com you agree to our
privacy policy and
terms of service, and to receive content and offer notifications.

Docstoc is the premier online destination to start and grow small businesses. It hosts the best quality and widest selection of professional documents (over 20 million) and resources including expert videos, articles and productivity tools to make every small business better.

Search or Browse for any specific document or resource you need for your business. Or explore our curated resources for Starting a Business, Growing a Business or for Professional Development.

Feel free to Contact Us with any questions you might have.