sorting. sorting terminology sort key –each element to be sorted must be associated with a sort...
TRANSCRIPT
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