heapsort counting sort radix sort n.
Skip this Video
Loading SlideShow in 5 Seconds..
Download Presentation


209 Views Download Presentation
Download Presentation


- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript


  2. HEAPSORT • O(n lg n) worstcaselikemergesort. • Likeinsertionsort, but unlike merge sort, heapsort sorts in place: • Combines the best of both algorithms. To understand heapsort, we’llcover heaps and heap operations.

  3. Heap data structure a binary tree is a tree data structure in which each node has at most two child nodes • The (binary) heap data structure is an array object that we can view as anearlycompletebinarytree • A.length, number of elements in the array, • A.heap-size,how many elements in the heap are stored withinarrayA. • 0 <=A.heap-size <=A.length • Height of node = # of edges on a longest simple path from the nodedown toa leaf. • Height of heap = height of root = (lg n). • A heap can be stored as an array A. • Root of tree is A[1]. • Parent of A[i ] = A[i/2]. • Left child of A[i ] = A[2i ]. • Right child of A[i ] = A[2i + 1].

  4. Heap data structure • There are two kinds of binary heaps: max-heaps and min-heaps. In both kinds,thevalues in the nodes satisfy a heap property, the specifics of which depend onthekind of heap. • In a max-heap, the max-heap property is that for every node iotherthantheroot, • A[PARENT(i)] >=A[İ] • In a min-heap, the min-heap property is that for every node iotherthantheroot, • A[PARENT(i)] <=A[İ] • Fortheheapsortalgorithmweusemax-heaps.

  5. Maintainingtheheapproperty • In order to maintain the max-heap property, we call the procedure MAX-HEAPIFY. • Its inputs are an array A and an index i into the array.

  6. Building a heap • We can use the procedure MAX-HEAPIFY in a bottom-up manner to convert anarray A[1…n], where n = A.length, into a max-heap.

  7. ççç

  8. Heapsortalgorithm • The HEAPSORT procedure takes time O(nlgn), since the call to BUILD-MAXHEAPtakes time O(n)and each of the n -1 calls to MAX-HEAPIFY takes time O(lgn) The complexity of BuildHeap appears to be Θ(n lg n) – n calls to Heapify at a cost of Θ(lg n)per call, but this result can be improved to Θ(n). The analysis is in the book. The intuition is thatmost of the calls to heapify are on very short heaps.

  9. CountingSort • Counting sort assumes that each of the n input elements is an integer in the range0 to k • Counting sort determines, for each input element x, the number of elements lessthan x. • It uses this information to place element x directly into its position in theoutputarray.

  10. CountingSort

  11. CountingSort

  12. RadixSort • Radix sort is the algorithm used by the card-sorting machines you now find only incomputermuseums. • Radix sort solves the problem of card sorting by sorting onthe least significant digit first. • The algorithm then combines the cards into a singledeck, with the cards in the 0 bin preceding the cards in the 1 bin preceding thecards in the 2 bin, and so on. Then it sorts the entire deck again on the second-leastsignificant digit and recombines the deck in a like manner. • The process continuesuntil the cards have been sorted on all d digits. Remarkably, at that point the cardsare fully sorted on the d-digit number.

  13. RadixSort • In a typical computer, which is a sequential random-access machine, we sometimesuse radix sort to sort records of information that are keyed by multiple fields. • For example, we might wish to sort dates by three keys: year, month, and day. Wecould run a sorting algorithm with a comparison function that, given two dates,compares years, and if there is a tie, compares months, and if another tie occurs,compares days. • Alternatively, we could sort the information three times with astable sort: first on day, next on month, and finally on year.

  14. RadixSort • The code for radix sort is straightforward. The following procedure assumes thateach element in the n-element array A has d digits, where digit 1 is the lowest-orderdigit and digit d is the highest-order digit.

  15. RadixSort


  17. Exercise 6.4.1 • llustrate the operation of HEAPSORT on the array A ={5, 13, 2, 25, 7, 17, 20, 8, 4}.