Sorting

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 ki and kj,

ki > kj , ki < kj ,or ki = kj

Sorting Terminology

The Sorting Problem

Arrange a set of records so that the values of their key fields are in non-decreasing order.

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.

Sorting Algorithms Insertion Sort O( n2 )

Bubble Sort O( n2 )

Selection Sort O( n2 )

Shellsort O( n1.5 )

Quicksort O( nlog2n )

Mergesort O( nlog2n )

Heapsort O( nlog2n )

Binsort O( n ) w/ qualified input

Radix Sort O( n ) w/ qualified input

Insertion Sort: Algorithmvoid 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] )

}

}

}

Insertion Sort: Illustration

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 ith element must travel all

the way up)• running time: (n-1)(n)/2 => O( n2 )

– best case: already sorted (each ith element does not need to travel at all)

• running time: (n-1) => O( n )

– average case: { (n-1)(n)/2 } / 2 => O( n2 )

Bubble Sort: Algorithmvoid 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] )

}

}

}

}

Bubble Sort: Illustration

Bubble Sort: Time complexity number of comparisons in inner for loop for

the ith iteration is always equals to i– running time:

i = n(n+1)/2 O( n2 )

n

i = 1

Selection Sort: Algorithmvoid 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 ] )

}}

Selection Sort: Illustration

Selection Sort: Time complexity number of comparisons in inner for loop for

the ith iteration is always equals to i– running time:

i = n(n+1)/2 O( n2 )

n

i = 1

Shellsort: Algorithmvoid 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] );}

}}

Shellsort: Illustration

Shellsort: Time complexityO( n1.5 )

Quicksort: Algorithmvoid quicksort( Elem[] a, int I, int j ){ int pivotindex = findpivot( a, i, j )

swap( a[pivotindex], array[j] ) // stick pivot at the endint k = partition( a, i-1, j, a[j].key ) // k will be the first position

in the right subarrayswap( a[k], a[j] ) // put pivot in placeif( k-i > 1 )quicksort( a, i, k-1 ) // sort left partitionif( 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 rightwhile( r && a[--r].key > pivot ) // move right bound leftswap( a[l], a[r] ) // swap out-of-place values

}while( l < r ) // stop when they crossswap( a[l], a[r] ) // reverse last, wasted swapreturn l // return the first position in right position

}

Quicksort: Illustration

Quicksort: Illustration

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(n2)

Best case: when pivot always splits the array into two equal halves. – There will be log2n levels (1st level: one n sequence, 2nd level: two

n/2 sequences, 3rd level: four n/4 sequences, …): O(nlog2n)

Average case: O( n log2n )– given by the recurrence relation

T(n) = cn + 1/n ( T(k) + T(n - 1 - k) ), T(0) = c , T(1) = cn-1

k = 0