1 7.5 Heapsort Average number of comparison used to heapsort a random permutation of N items is 2N...
-
date post
21-Dec-2015 -
Category
Documents
-
view
225 -
download
1
Transcript of 1 7.5 Heapsort Average number of comparison used to heapsort a random permutation of N items is 2N...
1
7.5 Heapsort
• Average number of comparison used to heapsort a random permutation of N items is 2N logN - O (N log log N).
2
7.6 Mergesort
• Merging of 2 sorted lists
• One pass through the input, if the output is put in a third list.
• A divide and conquer approach
3
7.6 Mergesort• 1 13 24 26 2 15 27 38
Aptr Bptr Cptr
1 13 24 26 2 15 27 38 1
Aptr Bptr Cptr
1 13 24 26 2 15 27 38 1 2
Aptr Bptr Cptr
4
7.6 Mergesort
1 13 24 26 2 15 27 38 1 2 13
Aptr Bptr Cptr
1 13 24 26 2 15 27 38 1 2 13 15
Aptr Bptr Cptr
1 13 24 26 2 15 27 38 1 2 13 15 24
Aptr Bptr Cptr
5
7.6 Mergesort
/* Figure 7.9 Mergesort Routine */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); }}
6
7.6 Mergesort
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!!!");}
7
7.6 Mergesort
/* Figure 7.10 Merge Routine *//* 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;
8
7.6 Mergesort
/* main loop */ while (Lpos <= LeftEnd && Rpos <= RightEnd) if (A [Lpos] <= A [Rpos]) TmpArray [TmpPos++] = A [Lpos++]; else TmpArray [TmpPos++] = A [Rpos++];
9
7.6 Mergesort
while (Lpos <= LeftEnd) /* Copy rest of 1st half */ TmpArray [TmpPos++] = A [Lpos++]; while (Rpos <= RightEnd) /* Copy rest of 2nd half */ TmpArray [TmpPos++] = A [Rpos++];
/* Copy TmpArray back */ for (i = 0; i < NumElements; i++, RightEnd--) A [RightEnd] = TmpArray [RightEnd];}
10
7.6 Mergesort
• Analysis of Mergesort
O(NlogN)NNlogNT(N)
N2)T(N/2T(N)
1T(1)
• Requires additional memory for TmpArray and work of copying to the temporary array and back.
• Used for external sorting.
11
7.7 Quicksort
• Fastest known sorting algorithm in practice
• Average running time is O (N logN)
• Worst case performance is O (N2)
• Algorithm– If the number of elements in S is 0 or 1, then
return.
– Pick any element v in S. This is called the pivot.
12
7.7 Quicksort– Partition S -{v} (the remaining elements in
S) into 2 disjoint groups:
S1 = {x S-{v}|x v}, and S2 = {x S-{v}|x v}.
– Return {quicksort (S1) followed by v followed by quicksort (S2)}.
• More details– Set the pivot to the median among the first,
center and last elements.
13
7.7 Quicksort– Exchange the last element with the pivot.– Set i at the first element.– Set j at the next-to-last element.– While i is on the left of j, move i right,
skipping over elements that are smaller than the pivot.
– Move j left, skipping over elements that are larger than the pivot.
– When i and j have stopped, i is pointing at a large element and j at a small element.
14
7.7 Quicksort– If i is to the left of j, swap A [i] with A [j]
and continue.
– When i>j, swap the pivot element with the element at i.
– All elements to the left of pivot are smaller than pivot, and all elements to the right of pivot are larger than pivot.
• What to do when some elements are equal to pivot?
15
7.7 Quicksort
• Example: 8 1 4 9 6 3 5 2 7 0
Start: 8 1 4 9 0 3 5 2 7 6
i j
Move i: 8 1 4 9 0 3 5 2 7 6
i j
Move j: 8 1 4 9 0 3 5 2 7 6
i j
16
7.7 Quicksort
1st swap: 2 1 4 9 0 3 5 8 7 6
i j
Move i: 2 1 4 9 0 3 5 8 7 6
i j
Move j: 2 1 4 9 0 3 5 8 7 6
i j
17
7.7 Quicksort
2nd swap: 2 1 4 5 0 3 9 8 7 6
i j
Move i: 2 1 4 5 0 3 9 8 7 6
i&j
Move j: 2 1 4 5 0 3 9 8 7 6
(i & j crossed) j i
Swap element at i with pivot
2 1 4 5 0 3 6 8 7 9
18
7.7 Quicksort• Does not perform well for small arrays;
cutoff is about 10.
• When equal elements are encountered, it’s better to stop i and/or j (for swapping).
• Implementation– Sort A [Left], A [Right] and A [Center] in
place.
– Place the pivot at A [Right - 1] .
– Initialize i = Left + 1, and j = Right - 2.
19
7.7 Quicksort
/* Figure 7.12 Driver for quicksort */
void Quicksort (ElementType A [ ], int N)
{
Qsort( A, 0, N - 1 );
}
20
7.7 Quicksort
/* Figure 7.13 Code to perform median-of-three partitioning */
/* Return median of Left, Center, and Right */
/* Order these and hide the pivot */
ElementType Median3 (ElementType A [ ], int Left, int Right)
{ int Center = (Left + Right) / 2;
if (A [Left] > A [Center])
Swap (&A [Left], &A [Center]);
21
7.7 Quicksort
if (A [Left] > A [Right])
Swap (&A [Left], &A [Right]);
if (A [Center] > A [Right])
Swap (&A [Center], &A [Right]);
/* Invariant: A [Left] <= A [Center] <= A [Right] */
Swap (&A [Center], &A [Right - 1]);
return A [Right - 1]; /* Return pivot */
}
22
7.7 Quicksort
/* Figure 7.14 Main quicksort routine */
#define Cutoff (3)
void Qsort (ElementType A [ ], int Left, int Right)
{ int i, j;
ElementType Pivot;
if (Left + Cutoff <= Right)
{Pivot = Median3 (A, Left, Right);
i = Left; j = Right - 1;
23
7.7 Quicksort
for ( ; ; )
{while (A [++i] < Pivot){ }
while (A [--j] > Pivot){ }
if (i < j)
Swap (&A [i], &A [j]);
else
break;
}
24
7.7 Quicksort
/* Restore pivot */
Swap (&A [i], &A [Right - 1]);
Qsort (A, Left, i - 1);
Qsort (A, i + 1, Right);
}
else /* Do an insertion sort on the subarray */
InsertionSort (A + Left, Right - Left + 1);
}
25
7.7 Quicksort
• Worst case of quicksort
N
iNOicTNT
2
2)1()(
• Best caseT(N) = c N log N + N = O (N log N)
• Average caseT(N) = O (N log N)