Sorting Algorithms

• Bubble Sort
  Exchange two adjacent elements if they are out of order. Repeat until array is sorted. This is a slow algorithm.
  public static void BubbleSort( int[ ] array ) { int swap; for( int i = 1 ; i < array.Length ; i++ ) for( int j = 0 ; j < array.Length - i ; j++ ) { if( array[j] > array[j + 1] ) { swap = array[j]; array[j] = array[j + 1]; array[j + 1] = swap; } } } public static void ImprovedBubbleSort( int[ ] array ) { for( int k1 = array.Length - 1 , k2 = 0 ; k1 > 0 ; k1 = k2 , k2 = 0 ) for( int j = 0 ; j < k1 ; j++ ) { if( array[j] > array[j + 1] ) { int temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; k2 = j; } } }
• Quick Sort
  Partition array into two segments. The first segment all elements are less than or equal to the pivot value.
  The second segment all elements are greater or equal to the pivot value. Sort the two segments recursively. Quicksort is fastest on average, but sometimes unbalanced partitions can lead to very slow sorting.
   /* If you think of a one dimensional array as going from * the lowest index on the left to the highest index on the right * then the parameters to this function are lowest index or * left and highest index or right. The first time you call * this function it will be with the parameters 0, array.Length - 1. * * array an integer array * left left boundary of array partition * right right boundary of array partition */ private static void QuickSort( int[ ] array , int left , int right ) { int lowest = left; int highest = right; int middle; if( right > left ) { // Arbitrarily establishing partition element as the midpoint of // the array. middle = array[( left + right ) / 2]; // loop through the array until indices cross while( lowest <= highest ) { // find the first element that is greater than or equal to // the partition element starting from the left Index. while( ( lowest < right ) && ( array[lowest] < middle ) ) { ++lowest; } // find an element that is smaller than or equal to // the partition element starting from the right Index. while( ( highest > left ) && ( array[highest] > middle ) ) { --highest; } // if the indexes have not crossed, swap if( lowest <= highest ) { int temp; temp = array[lowest]; array[lowest] = array[highest]; array[highest] = temp; ++lowest; --highest; } } // If the right index has not reached the left side of array // must now sort the left partition. if( left < highest ) { QuickSort( array , left , highest ); } // If the left index has not reached the right side of array // must now sort the right partition. if( lowest < right ) { QuickSort( array , lowest , right ); } } }
• Insertion Sort
  Scan successive elements for out of order item, then insert the item in the proper place. Sort small array fast, big
  array very slowly.
   public static void InsertionSort( int[ ] array ) { int j; for( int i = 1 ; i < array.Length ; i++ ) { int temp = array[i]; for( j = i ; j > 0 && temp < array[j - 1] ; j-- ) { array[j] = array[j - 1]; } array[j] = temp; } }
• Shell Sort
  Sort every Nth element in an array using insertion sort. Repeat using smaller N values, until N = 1. On
  average, Shellsort is fourth place in speed. Shellsort may sort some distributions slowly.
  public static void ShellSort( int[ ] array ) { int increment; for( increment = 1 ; increment <= array.Length / 9 ; increment = 3 * increment + 1 ) ; for( ; increment > 0 ; increment /= 3 ) { for( int i = increment + 1 ; i <= array.Length ; i += increment ) { int t = array[i - 1]; int j = i; while( ( j > increment ) && ( array[j - increment - 1] > t ) ) { array[j - 1] = array[j - increment - 1]; j -= increment; } array[j - 1] = t; } } }
• Selection Sort
  Find the largest element in the array, and put it in the proper place. Repeat until array is sorted. This is also slow.
  public static void SelectionSort( int[ ] array ) { for( int i = 0 ; i < array.Length - 1 ; i++ ) { int k = i; for( int j = i + 1 ; j < array.Length ; j++ ) { if( array[k] > array[j] ) { k = j; } } int temp = array[k]; array[k] = array[i]; array[i] = temp; } }