public void bubbleSort(int[] numbers)
{
     /*traverse the array (or a subset of the array) length-1 times*/
     for (int highest_unsorted=numbers.length-1; highest_unsorted != 0; highest_unsorted--)
     {    
      	/*makes the necessary comparisons for one pass through the array*/	
      	for (int best_so_far=0; best_so_far < highest_unsorted; best_so_far++)
      	{
        		/*compare adjacent items and swap them if necessary*/
        		if (numbers[best_so_far] > numbers[best_so_far+1])
          			swapNumbers (best_so_far, best_so_far+1);
      	}
     }
}

public void selectionSort(int[] numbers)
{
    /*For every index in the array, with the exception of the last one,*/
    for(int searcherIndex=0; searcherIndex < numbers.length-1; searcherIndex++)
    {
      	/*Assume that the number is where it's supposed to be*/
      	int correctIndex = searcherIndex;
      	
      	/*Try out other candidate indexes*/
      	for (int candidateIndex=searcherIndex+1; candidateIndex < numbers.length; candidateIndex++)
      	{
      		/*If you find a smaller number, make it's index the correct index*/
      		if(numbers[candidateIndex] < numbers[correctIndex])
        			correctIndex = candidateIndex;
      	}
      	/*At this point correctIndex really will be the correct index*/
      	swapNumbers (searcherIndex, correctIndex);
    }
}

 public void insertionSort(int[] numbers)
  {
    /*going through all of the items in the array*/
    for (int insertMe=1; insertMe < numbers.length; insertMe++)
    {
      /*find the correct index for the item*/
      for (int newPosn=0; newPosn < insertMe; newPosn++)
      {
        /*stop when you come to an item greater than the item in question*/
        if (numbers[insertMe] < numbers[newPosn])
        {
          /*put the item in question somewhere for safe keeping*/
	  int temp = numbers[insertMe];
	  
          /*move everything after the correct index down to make room*/
          for (int shift=insertMe; shift > newPosn; )
            numbers[shift] = numbers[--shift];

	  /*put the item in its correct index*/
          numbers[newPosn] = temp;

	  /*You've found the right index for the item and it's time to stop*/
          break;
        }
      }
    }
  }

/*
 *quickSort() calls sortPartition()
 */
public void quickSort(int[] numbers)
{
    sortPartition (0, numbers.length-1);
}

/*
 * This is a helper method which is used by findPartition() to 
 * find the "pivot point" - the place to divide the partition.
 */
private int findPivot (int left, int right)
{
    return ((right + left)/2);
}

/*
 * This is a helper method called by sortNumbers(). It sorts
 * an individual partition about the given pivot point.
 */
private int partition (int left, int right, int pivot)
{
    do
    {
      while (numbers[++left] < numbers[pivot]);
      while ((right !=0) && (numbers[--right] > numbers[pivot]));
      swapNumbers (left, right);
    } while (left < right);

    swapNumbers (left, right);

    return left;
}

/*
 * This is a helper method called by sortNumbers(). It recursively 
 * calls itself on subpartitions to sort the numbers. The actual
 * sorting within the partition is done by sortPartition(), which
 * is iterative.
 */
private void sortPartition (int left, int right)
{
    int pivot = findPivot (left, right);
    swapNumbers (pivot, right);
    int newpivot= partition (left-1, right, right);
    swapNumbers (newpivot, right);

    if ((newpivot-left) > 1) sortPartition (left, newpivot-1));
    if ((right - newpivot) > 1) sortPartition (newpivot+1, right));
}