Sorting
This presentation is the property of its rightful owner.
Sponsored Links
1 / 21

Sorting PowerPoint PPT Presentation


  • 87 Views
  • Uploaded on
  • Presentation posted in: General

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 k i and k j , k i > k j , k i < k j , or k i = k j. Sorting Terminology. The Sorting Problem

Download Presentation

Sorting

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Sorting

Sorting


Sorting terminology

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 terminology1

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

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

Sorting Algorithms

  • Insertion SortO( n2 )

  • Bubble SortO( n2 )

  • Selection SortO( 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 algorithm

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] )

}

}

}


Insertion sort illustration

Insertion Sort: Illustration


Insertion sort time complexity

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 algorithm

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] )

}

}

}

}


Bubble sort illustration

Bubble Sort: Illustration


Bubble sort time complexity

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 algorithm

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 ] )

}

}


Selection sort illustration

Selection Sort: Illustration


Selection sort time complexity

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 algorithm

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] );

}

}

}


Shellsort illustration

Shellsort: Illustration


Shellsort time complexity

Shellsort: Time complexity

  • O( n1.5 )


Quicksort algorithm

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

}


Quicksort illustration

Quicksort: Illustration


Quicksort illustration1

Quicksort: Illustration


Quicksort time complexity

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


  • Login