import java.util.Arrays;

// File: Insert.java
// A Java application to illustrate the use of an insertion sort
// Additional javadoc documentation is available at:
//   http://www.cs.colorado.edu/~main/docs/Insert.html
 
/******************************************************************************
* The <CODE>Insert</CODE> Java application illustrates an insertion sort.
*
* <p><dt><b>Java Source Code for this class:</b><dd>
*   <A HREF="../applications/Insert.java">
*   http://www.cs.colorado.edu/~main/applications/Insert.java
*   </A>
*
* @author Michael Main 
*   <A HREF="mailto:main@colorado.edu"> (main@colorado.edu) </A>
*
* @version
*   Jun 12, 1998
******************************************************************************/
public class Insert
{
   /**
   * The main method illustrates the use of an insertion sort to sort a 
   * small array.
   * The <CODE>String</CODE> arguments (<CODE>args</CODE>) are not used 
   * in this implementation.
   **/
   public static void main(String[ ] args)
   {
      final String BLANKS = "  "; // A String of two blanks
      int i;                      // Array index

      int[ ] data = { 1000, 80, 10, 50, 70, 60, 90, 20, 30, 40, 0, -1000 };
      
      int[] data1 = data.clone();
      
      int[] data2 = {1000, 90, 80, 70, 60, 50, 40, 30, 20, 10, 0, -1000};

      // Print the array before sorting:
      System.out.println("Here is the entire original array:");
      for (i = 0; i < data.length; i++)
         System.out.print(data[i] + BLANKS);
      System.out.println( );

      // Sort the numbers, and print the result with two blanks after each number.
      insertionsort(data, 0, data.length);
//      System.out.println("I have sorted all but the first and last numbers.");
      System.out.println("The numbers are now:");
      for (i = 0; i < data.length; i++)
         System.out.print(data[i] + BLANKS);
      System.out.println( );
      System.out.println("===================================================");
      System.out.println( );
      System.out.println( );
      
      System.out.println("Here is the entire original array:");
      for (i = 0; i < data.length; i++)
         System.out.print(data[i] + BLANKS);
      System.out.println( );
      // Sort the numbers, and print the result with two blanks after each number.
      insertionsort(data);
//      System.out.println("I have sorted all but the first and last numbers.");
      System.out.println("The numbers are now:");
      for (i = 0; i < data.length; i++)
         System.out.print(data[i] + BLANKS);
      System.out.println( );
      System.out.println("===================================================");
      System.out.println( );
      System.out.println( );
      
      System.out.println("Here is the entire original array:");
      for (i = 0; i < data2.length; i++)
         System.out.print(data2[i] + BLANKS);
      System.out.println( );
      // Sort the numbers, and print the result with two blanks after each number.
      insertionsort(data2);
//      System.out.println("I have sorted all but the first and last numbers.");
      System.out.println("The numbers are now:");
      for (i = 0; i < data2.length; i++)
         System.out.print(data2[i] + BLANKS);
      System.out.println( );
   }
   
   
   /**
   * Sort an array of integers from smallest to largest, using an insertion sort
   * algorithm.
   * @param <CODE>data</CODE>
   *   the array to be sorted
   * @param <CODE>first</CODE> 
   *   the start index for the portion of the array that will be sorted
   * @param <CODE>n</CODE>
   *   the number of elements to sort
   * <dt><b>Precondition:</b><dd>
   *   <CODE>data[first]</CODE> through <CODE>data[first+n-1]</CODE> are valid
   *   parts of the array.
   * <dt><b>Postcondition:</b><dd>
   *   If <CODE>n</CODE> is zero or negative then no work is done. Otherwise, 
   *   the elements of </CODE>data</CODE> have been rearranged so that 
   *   <CODE>data[first] &lt= data[first+1] &lt= ... &lt= data[first+n-1]</CODE>.
   * @exception ArrayIndexOutOfBoundsException
   *   Indicates that <CODE>first+n-1</CODE> is an index beyond the end of the
   *   array.
   * */
   public static void insertionsort(int[ ] data, int first, int n)
   {
      int i, j;   // Loop control variables
      int entry;  // The element that is currently being inserted
         
      for (i = 1; i < n; i++)
      {
         entry = data[first+i];
         for (j = first+i; (j>first) && (data[j-1] > entry); j--) {
            data[j] = data[j-1]; 
            System.out.println(Arrays.toString(data));
         }
         data[j] = entry;   
         System.out.println(Arrays.toString(data));
      }
  } 
   
   //-------------------------------------------
   public static void insertionsort(int[ ] data)
   {
      int i, j;   // Loop control variables
      int entry;  // The element that is currently being inserted
      int n = data.length;
         
      for (i = 1; i < n; i++)
      {
         entry = data[i];
         for (j = i; (j>0) && (data[j-1] > entry); j--) {
            data[j] = data[j-1]; 
            System.out.println(Arrays.toString(data));
         }
         data[j] = entry;   
         System.out.println(Arrays.toString(data));
      }
  } 
   
}