// revised!!

import java.util.*;

public class sorts {

    public static void main( String[] args ) {

	int    n;
	if ( args.length < 1 ) {
	    System.out.println( "usage: java sorts <n>" );
	    System.exit( 1 );
	}
	n = Integer.parseInt( args[0].trim() );

	int[] A = new int[n];
	for ( int i=0; i<n; i++ ) {
	    A[i] = (int)( Math.random() * 100 );
	}

	System.out.println();
	permute( A );
	printArray( "before blortSort:", A );
	blortSort( A );
	printArray( ">after blortSort:", A );

	System.out.println();
	permute( A );
	printArray( "before selectionSort:", A );
	selectionSort( A );
	printArray( ">after selectionSort:", A );

	System.out.println();
	permute( A );
	printArray( "before insertionSort:", A );
	insertionSort( A );
	printArray( ">after insertionSort:", A );

	System.out.println();
	permute( A );
	printArray( "before bubbleSort:", A );
	bubbleSort( A );
	printArray( ">after bubbleSort:", A );

	System.exit( 0 );

    } // end of main() method


    static void printArray( String s, int[] A ) {
	System.out.print( s+" -->  " );
	for ( int i=0; i<A.length; i++ ) {
	    System.out.print( A[i]+" " );
	}
	System.out.println();
    } // end of printArray() method


    static void swap( int x1, int x2, int[] A ) {
	int tmp = A[x1];
	A[x1] = A[x2];
	A[x2] = tmp;
    } // end of swap() method


    static boolean isSorted( int[] A ) {
	int i = 0;
	boolean anyErrors = false;
	while (( ! anyErrors ) && ( i < A.length-1 )) {
	    if ( A[i] > A[i+1] ) {
		anyErrors = true;
	    }
	    else {
		i++;
	    }
	} /* end while */
	return( ! anyErrors );
    } /* end of isSorted() */
    

    static void permute( int[] A ) {
	int i, r;
	for ( i=0; i<A.length-1; i++ ) {
	    r = (int)( Math.random() * (A.length-i) ) + i;
	    swap( i,r,A );
	} /* end for i */
    } /* end of permute() */


    static int findMin( int startIndex, int[] A ) {
	int min  = A[startIndex];
	int minx = startIndex;
	for ( int i=startIndex+1; i<A.length; i++ ) {
	    if ( A[i] < min ) {
		min  = A[i];
		minx = i;
	    }
	}
	return( minx );
    } // end of findMin() method


    static void blortSort( int[] A ) {
	int count=0;
	while ( ! isSorted( A )) {
	    permute( A );
	    printArray( "after pass#"+count, A );
	    count++;
	} /* end of while */
    } /* end of blortSort() */


    static void insertionSort( int[] A ) {
	int key, pos;
	for ( int i=1; i<A.length; i++ ) {
	    key = A[i];
	    pos = i;
	    while ((pos > 0) && (A[pos-1]>key )) {
		A[pos] = A[pos-1];
		pos--;
	    } // end while
	    A[pos] = key;
	    printArray( "after pass#"+i, A );
	} // end for
    } // end of insertionSort() method


    static void selectionSort( int[] A ) {
	for ( int i=0; i<A.length; i++ ) {
	    int minx = findMin( i, A );
	    swap( i,minx,A );
	    printArray( "after pass #"+i, A );
	}
    } // end of selectionSort() method


    static void bubbleSort( int[] A ) {
	for ( int pass=1; pass<=A.length-1; pass++ ) {
	    for ( int i=0; i<=A.length-2; i++ ) {
		if ( A[i] > A[i+1] ) {
		    swap( i,i+1,A );
		}
	    } // end for i
	    printArray( "after pass#"+pass, A );
	} // end for pass
    } // end of bubbleSort() method


} // end of class sorts