Chapter 17: Sorting Algorithms. 1.1 Description Performance Example: Bubble Sort Bubble Sort Algorithm 5

Transcription

1 Chapter 17: Sorting Algorithms Christian Jacob 1 Bubble Sort Description Performance Example: Bubble Sort Bubble Sort Algorithm 5 2 Selection Sort Description Performance Example: Selection Sort Selection Sort Algorithm 9 3 Insertion Sort Description Example: Insertion Sort Insertion Sort Algorithm 12 4 Quicksort Description Performance 14 TOC 1 Back

2 Chapter 17: Sorting Algorithms Christian Jacob 4.3 Example: Quicksort Quicksort Algorithm 30 TOC 2 Back

3 Bubble Sort Chapter 17: Sorting Algorithms Christian Jacob 1 Bubble Sort 1.1 Description Each two neighbouring elements (x, y) are compared: If x y then leave them unchanged. If x > y then swap their positions. This is done for all overlapping pairs, until no swaps have to be performed any more. 1.2 Performance In the worst case (data sorted in reverse order) and on average, bubble sort n 2 n 2 needs ---- comparisons and ---- swaps. 2 2 First Back TOC 3 Prev Next Last

4 Bubble Sort Chapter 17: Sorting Algorithms Christian Jacob 1.3 Example: Bubble Sort First Back TOC 4 Prev Next Last

5 Bubble Sort Chapter 17: Sorting Algorithms Christian Jacob 1.4 Bubble Sort Algorithm void bubblesort(int *list) { int i, swaps = True; while(swaps) { swaps = False; for(i=0; i < length(list)-1; i++) { if( list[i] > list[i+1] ) { swapelements(i, i+1); swaps = True; First Back TOC 5 Prev Next Last

6 Selection Sort Chapter 17: Sorting Algorithms Christian Jacob 2 Selection Sort 2.1 Description For each element x we search to the right in the array in order to find the smallest element y in the remainder of the array. If necessary, the two values x and y are swapped. The smallest value ends up at position one. The former value at position one now is at the previous position of the smaller value. The second smallest element ends up at position two, etc. First Back TOC 6 Prev Next Last

7 Selection Sort Chapter 17: Sorting Algorithms Christian Jacob 2.2 Performance In each iteration i, Selection Sort needs ( N i) comparisons, with N being the array length. Hence, the total number of comparisons is: N i = 1 ( N i) = N N N 2 On average, comparisons and N swaps are necessary 2 First Back TOC 7 Prev Next Last

8 Selection Sort Chapter 17: Sorting Algorithms Christian Jacob 2.3 Example: Selection Sort First Back TOC 8 Prev Next Last

9 Selection Sort Chapter 17: Sorting Algorithms Christian Jacob 2.4 Selection Sort Algorithm void selectionsort(int *list) { int min; // minimum int minpos; // position of minimum int i, j; for(i=0; i < length(list); i++) { min = list[i]; minpos = i; // find minimum for(j=i; j < length(list); j++) { if( list[j] < min ) { min = list[j]; minpos = j; swapelements(i, minpos); // swap First Back TOC 9 Prev Next Last

10 Insertion Sort Chapter 17: Sorting Algorithms Christian Jacob 3 Insertion Sort 3.1 Description Insertion sort is similar to selection sort, but works the other way around: Each element is selected in turn and inserted at the correct position between the already sorted elements. Thus, to bring each element to its place correct position, a whole block of values has to be moved (in the worst case, the whole already sorted block). Advantage: Insertion sort behaves practically linear in the size of the array, if the array is "almost" sorted. This is usually the case for index files which are regularly resorted. First Back TOC 10 Prev Next Last

11 Insertion Sort Chapter 17: Sorting Algorithms Christian Jacob 3.2 Example: Insertion Sort First Back TOC 11 Prev Next Last

12 Insertion Sort Chapter 17: Sorting Algorithms Christian Jacob 3.3 Insertion Sort Algorithm void insertionsort(int *list) { int i; // position of element to be moved int j; // position of next-larger element // in already sorted block for(i=0; i < length(list); i++) { j=0; // find correct position while( list[j] < list[i] ) j++; move(i, j); // move i-element before j First Back TOC 12 Prev Next Last

13 4 Quicksort 4.1 Description Quick sort is one of the standard sorting algorithms used today for a number of reasons: works with only little additional storage needed very well examined efficient The algorithm divides the array in two partitions with the following properties: The dividing element is already at the correct position (needs never be moved). All values in the right partition are smaller than the divider, all values in the left partition are larger. Then the algorithm is applied to the left and right partitions recursively (divideand-conquer method). First Back TOC 13 Prev Next Last

14 The Challenge The real challenge lies in finding an algorithm which divides the array as required for the recursive calls. One possible way to do so is as follows: Choose an arbitrary element. Take two pointers running inward from the edges of the array. For each pointer pair, swap the two wrongly ordered elements with respect to the arbitrary divider. When the two pointers meet, swap the divider with the element pointed to by the left pointer. 4.2 Performance On the average the algorithm performs using case it needs N 2 operations. N logn operations, in the worst The algorithm performance can be improved if more about the structure of the pre-sorted data is known. First Back TOC 14 Prev Next Last

15 4.3 Example: Quicksort Divider: d i k void quicksort(int *list, int l, int r); { i = l; k = r+1; d = list[l]; First Back TOC 15 Prev Next Last

16 4.3 Example: Quicksort d i k while( i < k ) { do { i++; while( list[i] < d ); do { k--; while( list[k] > d ); if( k > i ) swap(k, i); First Back TOC 16 Prev Next Last

17 4.3 Example: Quicksort d i k while( i < k ) { do { i++; while( list[i] < d ); do { k--; while( list[k] > d ); if( k > i ) swap(k, i); First Back TOC 17 Prev Next Last

18 4.3 Example: Quicksort d i k while( i < k ) { do { i++; while( list[i] < d ); do { k--; while( list[k] > d ); if( k > i ) swap(k, i); First Back TOC 18 Prev Next Last

19 4.3 Example: Quicksort d i k while( i < k ) { do { i++; while( list[i] < d ); do { k--; while( list[k] > d ); if( k > i ) swap(k, i); First Back TOC 19 Prev Next Last

20 4.3 Example: Quicksort d i k while( i < k ) { do { i++; while( list[i] < d ); do { k--; while( list[k] > d ); if( k > i ) swap(k, i); First Back TOC 20 Prev Next Last

21 4.3 Example: Quicksort d i k while( i < k ) { do { i++; while( list[i] < d ); do { k--; while( list[k] > d ); if( k > i ) swap(k, i); First Back TOC 21 Prev Next Last

22 4.3 Example: Quicksort d i k while( i < k ) { do { i++; while( list[i] < d ); do { k--; while( list[k] > d ); if( k > i ) swap(k, i); First Back TOC 22 Prev Next Last

23 4.3 Example: Quicksort d i k while( i < k ) { do { i++; while( list[i] < d ); do { k--; while( list[k] > d ); if( k > i ) swap(k, i); First Back TOC 23 Prev Next Last

24 4.3 Example: Quicksort d i k while( i < k ) { do { i++; while( list[i] < d ); do { k--; while( list[k] > d ); if( k > i ) swap(k, i); First Back TOC 24 Prev Next Last

25 4.3 Example: Quicksort d i k while( i < k ) { do { i++; while( list[i] < d ); do { k--; while( list[k] > d ); if( k > i ) swap(k, i); First Back TOC 25 Prev Next Last

26 4.3 Example: Quicksort d k i while( i < k ) { do { i++; while( list[i] < d ); do { k--; while( list[k] > d ); if( k > i ) swap(k, i); First Back TOC 26 Prev Next Last

27 4.3 Example: Quicksort d l k i while( i < k ) { swap(l, k); First Back TOC 27 Prev Next Last

28 4.3 Example: Quicksort d l k i while( i < k ) { swap(l, k); First Back TOC 28 Prev Next Last

29 4.3 Example: Quicksort d l k r { quicksort { quicksort if( l < k-1) quicksort(list, l, k-1); if( k+1 < r) quicksort(list, k+1, r); First Back TOC 29 Prev Next Last

30 4.4 Quicksort Algorithm Sorts sub-array list[l] list[r] in ascending order: void quicksort(int *list, int l, int r) { int i = l; int k = r+1; int d = list[l]; // divider while( i < k ) { do { i++; while( list[i] < d ); do { k--; while( list[k] > d ); if( k > i ) swap(k, i); // swap elems k & i swap(l, k); // put divider in place if( l < k-1 ) quicksort(list, l, k-1); if( k+1 < r ) quicksort(list, k+1, r); First Back TOC 30 Prev Next Last