public class MergeSort1 {

  public void sortInPlace (Comparable[] data)
  {
    mergeSortRecursive (data, 0, data.length-1);
  }

  void swap (Comparable[] data, int i, int j)
  {
    Comparable temp = data[i];
    data[i] = data[j];
    data[j] = temp;
  }


  void simpleMerge (Comparable[] data, int left, int middle, int right)
  {
    // 1. Create the space and initialize the cursors:
    Comparable[] mergeSpace = new Comparable [right-left+1];
    int leftCursor = left;
    int rightCursor = middle+1;

    // 2. Fill the merge space by one by one, selecting from the correct partition
    for (int i=0; i<mergeSpace.length; i++) {

      if (leftCursor > middle) {
        // 2.1  If left side is done, merge only from right:
        mergeSpace[i] = data[rightCursor];
        rightCursor++;
      }
      else if (rightCursor > right) {
        // 2.2  If right side is done, merge only from right:
        mergeSpace[i] = data[leftCursor];
        leftCursor++;
      }
      else if (data[leftCursor].compareTo (data[rightCursor]) <= 0) {
        // 2.3 Otherwise, if the leftCursor element is less, move it:
        mergeSpace[i] = data[leftCursor];
        leftCursor++;
      }
      else {
        // 2.4 Move from right:
        mergeSpace[i] = data[rightCursor];
        rightCursor++;
      }
    }
 
    // 3. Copy back into original array:
    for (int i=0; i<mergeSpace.length; i++)
      data[left+i] = mergeSpace[i];
  }

  void mergeSortRecursive (Comparable[] data, int left, int right) 
  {
    // 1. We will allow left cursor to go past right as one way
    //    to bottom out of recursion.
    if (left >= right) 
      return;

    // 2. Handle 2-element case directly:
    if (left+1 == right) {
      if (data[left].compareTo (data[right]) > 0)
        swap (data, left, right);
      return;
    }

    // 3. Find the middle point:
    int middle = (left+right) / 2;

    // 4. Sort the left side, including the middle:
    mergeSortRecursive (data, left, middle);

    // 5. Sort the right side:
    mergeSortRecursive (data, middle+1, right);

    // 6. Merge:
    simpleMerge (data, left, middle, right);
  }


  public static void test1 ()
  {
    MergeSort1 mSort = new MergeSort1 ();
    String[] data = {"F", "A", "A",  "E", "J", "K", "I", "C", "G", "D"};
    int dataSize = 10;
    // Sort:
    mSort.sortInPlace (data);
    // Check:
    boolean ok = true;
    for (int i=0; i < dataSize-1; i++)
      if (data[i].compareTo (data[i+1]) > 0)
        ok = false;
    if (! ok) {
      System.out.println ("Failure detected");
      System.exit (0);
    }
    System.out.println ("Passed");
  }

  public static void main (String[] argv)
  {
    test1 ();
  }


}