1. Sorting

2. Sorting Terminology Sort Key –each element to be sorted must be associated with a sort key which can be compared with other keys e.g. for any two keys k i and k j, k i > k j, k i < k j,or k i = k j

3. Sorting Terminology The Sorting Problem Arrange a set of records so that the values of their key fields are in non- decreasing order.

4. Sorting Algorithms (Running Time Analysis) Things to measure –comparisons bet. keys –swaps The measure of these things usually approximate fairly accurately the running time of the algorithm.

5. Sorting Algorithms Insertion Sort O( n 2 ) Bubble Sort O( n 2 ) Selection Sort O( n 2 ) Shellsort O( n 1.5 ) Quicksort O( nlog 2 n ) Mergesort O( nlog 2 n ) Heapsort O( nlog 2 n ) Binsort O( n ) w/ qualified input Radix Sort O( n ) w/ qualified input

6. Insertion Sort: Algorithm void insertionSort( Elem[] a, int n ) { for( int i = 1; i < n; i++ ) {for( int j = i; (j > 0) && ( a[ j].key < a[ j-1].key); j-- ) {swap( a[ j], a[ j-1] ) }

7. Insertion Sort: Illustration

8. Insertion Sort: Time complexity outer for loop executed n-1 times inner for loop depends on how many keys before element i are less than it. –worst case: reverse sorted (each i th element must travel all the way up) running time: (n-1)(n)/2 => O( n 2 ) –best case: already sorted (each i th element does not need to travel at all) running time: (n-1) => O( n ) –average case: { (n-1)(n)/2 } / 2 => O( n 2 )

9. Bubble Sort: Algorithm void bubbleSort( Elem[] a, int n ) { for( int i = 0; i < n-1; i++ ) {for( int j = n-1; j > i; j-- ) {if( a[ j].key < a[j-1].key ) {swap( a[ j], a[ j-1] ) }

10. Bubble Sort: Illustration

11. Bubble Sort: Time complexity number of comparisons in inner for loop for the i th iteration is always equals to i –running time:  i = n(n+1)/2  O( n 2 ) n i = 1

12. Selection Sort: Algorithm void selectionSort( Elem[] a, int n ) { for( int i = 0; i < n-1; i++ ) {int lowindex = i for( int j = n-1; j > i; j-- ) {if( a[ j].key < a[ lowindex ].key ) {lowindex = j; } swap( a[i], a[ lowindex ] ) }

13. Selection Sort: Illustration

14. Selection Sort: Time complexity number of comparisons in inner for loop for the i th iteration is always equals to i –running time:  i = n(n+1)/2  O( n 2 ) n i = 1

15. Shellsort: Algorithm void shellsort( Element[] a ) { for( int i = a.length/2; i >= 2; i /=2 ) {for( int j = 0; j < i; j++ ) {insertionSort2( a, j, a.length-j, i ); } insertionSort2( a, 0, a.length, 1 ); } void insertionSort2( Element[] a, int start, int n, int incr ) { for( int i=start+incr; i<n; i+=incr) {for( j=i; (j>=incr) && (a[ j].key < a[ j-incr].key); j-=incr) {swap( a[j], a[j-incr] ); }

16. Shellsort: Illustration

17. Shellsort: Time complexity O( n 1.5 )

18. Quicksort: Algorithm void quicksort( Elem[] a, int I, int j ) {int pivotindex = findpivot( a, i, j ) swap( a[pivotindex], array[j] ) // stick pivot at the end int k = partition( a, i-1, j, a[j].key ) // k will be the first position in the right subarray swap( a[k], a[j] )// put pivot in place if( k-i > 1 )quicksort( a, i, k-1 )// sort left partition if( j-k > 1 )quicksort( a, k+1, j )// sort right partition } int findpivot( Elem[] A, int i, int j ){ return ( (i+j) / 2 ) } int partition( Elem[] A, int l, int r, Key pivot ) {do// move the bounds inward until they meet { while( a[++l ].key < pivot )// move left bound right while( r && a[--r].key > pivot )// move right bound left swap( a[l], a[r] )// swap out-of-place values }while( l < r )// stop when they cross swap( a[l], a[r] )// reverse last, wasted swap return l// return the first position in right position }

19. Quicksort: Illustration

21. Quicksort: Time complexity findpivot() takes constant time: 0(1) partition() depends on the length of the sequence to be partitioned: –O(s) for sequence of length s Worst-case: when pivot splits the array of size n into partitions of size n-1 and 0. O(n 2 ) Best case: when pivot always splits the array into two equal halves. –There will be log 2 n levels (1 st level: one n sequence, 2 nd level: two n/2 sequences, 3 rd level: four n/4 sequences, …): O(nlog 2 n) Average case: O( n log 2 n ) –given by the recurrence relation T( n ) = cn + 1/n  ( T( k ) + T( n - 1 - k ) ), T(0) = c, T(1) = c n-1 k = 0