Sorting (Heapsort, Mergesort)

1. Sorting(Heapsort, Mergesort) CS 201 Data Structures and Algorithms Text: Read Weiss, § 7.5 – 7.6 Izmir University of Economics 1

2. Heapsort • Priority queues can be used to sort in O(NlogN) time. • First, build a binary heap of N elements in O(N) time • perform NdeleteMin operations each taking O(logN) time, hence resulting in O(NlogN). • Problem: needs an extra array. • A clever solution: after each deleteMin heap size shrinks by 1, use this space. But the result will be a decreasing sorted order. Thus we may use a max heap by changing the heap-order property Izmir University of Economics

3. Heapsort Example Max heap after buildHeap phase Max heap after first deleteMax phase Izmir University of Economics

4. Analysis of Heapsort • worst case analysis • 2N comparisons-buildHeap • N-1 deleteMax operations. • Theorem: Average # of comparisons to heapsort a random permutation of N distinct items is 2NlogN-O(NloglogN). • Proof: on any input, cost sequence D: d1, d2,..., dN for any D, distinct deleteMax sequences total # of heaps with cost less than M is at most # of heaps with cost M < N(logN-loglogN-4) is at most (N/16)N. So the average # of comparisons is at least 2M. Izmir University of Economics

5. Mergesort • runs in O(NlogN), # of comparisons is nearly optimal, fine example of a recursive algorithm. • Fundamental operation is merging of 2 sorted lists. • The basic merging algorithm takes 2 input arrays A and B, an output array C. 3 counters, Actr, Bctr, and Cctr are initially set to the beginning of their respective arrays. • The smaller of A[Actr] and B[Bctr] is copied to C[Cctr ] and the appropriate counters are advanced. • When either list is exhausted, the rest of the other list is copied to C. Izmir University of Economics

6. Mergesort - merge • The time to merge is linear, at most N-1 comparisons are required (since each comparison adds an element to C. It should also be noted that after N-1 elements are added to array C, the last element need not be compared but it simply gets copied). • Mergesort algorithm is then easy to describe. If N=1 DONE else { mergesort(left half); mergesort(right half); merge(left half, right half); } Izmir University of Economics

7. Mergesort - Implementation void Mergesort( ElementType A[ ], int N ) { ElementType *TmpArray; TmpArray = malloc( N * sizeof( ElementType ) ); if( TmpArray != NULL ) { MSort( A, TmpArray, 0, N - 1 ); free( TmpArray ); } else FatalError( "No space for tmp array!!!" ); } Izmir University of Economics

8. MSort - Implementation void MSort( ElementType A[ ], ElementType TmpArray[ ], int Left, int Right ) { int Center; if( Left < Right ) { Center = ( Left + Right ) / 2; MSort( A, TmpArray, Left, Center ); MSort( A, TmpArray, Center + 1, Right ); Merge( A, TmpArray, Left, Center + 1, Right ); } } Izmir University of Economics

9. Merge - Implementation /*Lpos = start of left half, Rpos = start of right half*/ void Merge( ElementType A[ ], ElementType TmpArray[ ], int Lpos, int Rpos, int RightEnd ) { int i, LeftEnd, NumElements, TmpPos; LeftEnd = Rpos - 1; TmpPos = Lpos; NumElements = RightEnd - Lpos + 1; while( Lpos <= LeftEnd && Rpos <= RightEnd ) /*main loop*/ if( A[ Lpos ] <= A[ Rpos ] ) TmpArray[ TmpPos++ ] = A[ Lpos++ ]; else TmpArray[ TmpPos++ ] = A[ Rpos++ ]; while( Lpos <= LeftEnd ) /*Copy rest of first half*/ TmpArray[ TmpPos++ ] = A[ Lpos++ ]; while( Rpos <= RightEnd ) /*Copy rest of second half*/ TmpArray[ TmpPos++ ] = A[ Rpos++ ]; for( i = 0; i < NumElements; i++, RightEnd-- ) /*Copy TmpArray back*/ A[ RightEnd ] = TmpArray[ RightEnd ]; } /* Last copying may be avoided by interchanging the roles of A and TmpArray at alternate levels of recursion*/ Izmir University of Economics

10. Analysis of Mergesort • Write down recurrence relations and solve them • T(1)=1 • T(N)=2T(N/2)+N // assumption is N=2k Izmir University of Economics