Sorting

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 ki and kj,
• ki gt kj , ki lt kj ,or ki kj

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

6
Insertion Sort Algorithm

• void insertionSort( Elem a, int n )
• for( int i 1 i lt n i )
• for( int j i (j gt 0) ( a j.key lt 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 ith element must
  travel all the way up)
• running time (n-1)(n)/2 gt O( n2 )
• best case already sorted (each ith element does
  not need to travel at all)
• running time (n-1) gt O( n )
• average case (n-1)(n)/2 / 2 gt O( n2 )

9
Bubble Sort Algorithm

• void bubbleSort( Elem a, int n )
• for( int i 0 i lt n-1 i )
• for( int j n-1 j gt i j-- )
• if( a j.key lt aj-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
  ith iteration is always equals to i
• running time
• ? i n(n1)/2 ? O( n2 )

n i 1
12
Selection Sort Algorithm

• void selectionSort( Elem a, int n )
• for( int i 0 i lt n-1 i )
• int lowindex i
• for( int j n-1 j gt i j-- )
• if( a j.key lt a lowindex .key )
• lowindex j
• swap( ai, a lowindex )

13
Selection Sort Illustration
14
Selection Sort Time complexity

• number of comparisons in inner for loop for the
  ith iteration is always equals to i
• running time
• ? i n(n1)/2 ? O( n2 )

n i 1
15
Shellsort Algorithm

• void shellsort( Element a )
• for( int i a.length/2 i gt 2 i /2 )
• for( int j 0 j lt 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 istartincr iltn iincr)
• for( ji (jgtincr) (a j.key lt a
  j-incr.key) j-incr)
• swap( aj, aj-incr )

16
Shellsort Illustration
17
Shellsort Time complexity

• O( n1.5 )

18
Quicksort Algorithm

• void quicksort( Elem a, int I, int j )
• int pivotindex findpivot( a, i, j )
• swap( apivotindex, arrayj ) // stick
  pivot at the end
• int k partition( a, i-1, j, aj.key ) // k
  will be the first position in the right
  subarray
• swap( ak, aj ) // put pivot in place
• if( k-i gt 1 ) quicksort( a, i, k-1 ) // sort
  left partition
• if( j-k gt 1 ) quicksort( a, k1, j ) // sort
  right partition
• int findpivot( Elem A, int i, int j ) return
  ( (ij) / 2 )
• int partition( Elem A, int l, int r, Key pivot
  )
• do // move the bounds inward until they meet
• while( al .key lt pivot ) // move left
  bound right
• while( r a--r.key gt pivot ) // move right
  bound left
• swap( al, ar ) // swap out-of-place values
• while( l lt r ) // stop when they cross
• swap( al, ar ) // reverse last, wasted
  swap
• return l // return the first position in right
  position

19
Quicksort Illustration
20
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(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) c

n-1 k 0