import java.util.Random;


public class ST
{
    public int[] fyShuffle(int size)
    {
	return fyShuffle(size, 0);
    }

    /**
     * Return aan array of size istem containing values 0..(size-1) 
     * in random order.  Uses the Fisher-Yates shuffle algorithm
     * @param size -- the size of the array
     * @return a shuffled array
     */
    public int[] fyShuffle(int size, int seed)
    {
	int[] rtn = new int[size]; 
	for (int i=0; i<size; i++) rtn[i]=i;
	Random r;
	if (seed==0)
	    r = new Random();
	else
	    r = new Random(seed);
	for (int i=0; i<size-2; i++)
	{
	    int rr = i+r.nextInt(size-i);
	    int tmp = rtn[i];
	    rtn[i]=rtn[rr];
	    rtn[rr]=tmp;
	}
	return rtn;
    }
    
    /**
     * DO Selection sort, in place, on provided array.  Hence, this changes
     * the order of items in the provided array.
     * @param rdm the array to be sorted
     */
    public void selectionSortIP(int[] rdm)
    {
	for (int i=0; i< (rdm.length-2); i++)
	{
	    int lo = rdm[i];
	    int loi = i;
	    for (int j=i+1; j<rdm.length; j++)
	    {
		if (rdm[j]<lo)
		{
		    lo=rdm[j];
		    loi=j;
		}
	    }
	    int tmp = rdm[i];
	    rdm[i]=rdm[loi];
	    rdm[loi]=tmp;
	}
    }
    
    /**
     * Do intertions sort, in place, on the array to be sorted
     * Hence, this changes
     * the order of items in the provided array.
     * @param rdm the array to be sorted
     */
    public void insertionSortIP(int[] rdm)
    {
	for (int i=1; i<rdm.length; i++)
	{
	    int tgt = rdm[i];
	    int j;
	    for (j=0; j<i; j++)
	    {
		if (rdm[j]>tgt) break;
	    }
	    for (int k=i; k>j; k--)
	    {
		rdm[k]=rdm[k-1];
	    }
	    rdm[j]=tgt;
	}
    }
    
    /**
     * Insert into an array organized as a heap.
     * While this code is correct, it is also a very simplified version of a heap, 
     * in that the heap contains only a key and the key must be an integer.
     * @param heap the array
     * @param size the number of data items in the array
     * @param dta the data item to be added
     */
    private void heapInsert(int[] heap, int size, int dta)
    {
	// put in at end
	int loc = size;
	heap[loc] = dta;
	// bubble up
	int upp = (loc-1)/2;
	while (loc>0)
	{
	    if (heap[loc] > heap[upp])
	    {
		// swap and climb
		int tmp = heap[upp];
		heap[upp] = heap[loc];
		heap[loc] = tmp;
		loc = upp;
		upp = (loc-1)/2;
	    }
	    else
	    {
		break;
	    }
	}
    }

    /**
     * Remove the top element of the heap.
     * While this code is correct, it is also a very simplified version of a heap, 
     * in that the heap contains only a key and the key must be an integer.
     * @param heap an array whiose data is organized as a heap
     * @param heapSize the number of data items in the heap
     * @return the top most item in the heap.
     */
    private int heapPoll(int[] heap, int heapSize)
    {
	if (heapSize==0)
	    return -1;
	int rval=heap[0];
	heap[0]=heap[heapSize-1];
	heap[heapSize-1]=-1;
	downheap(heap, 0, heapSize);
	return rval;
    }
    
    private void downheap(int[] heap, int upp, int heapSize)
    {
	
	while (true)
	{
	    int dwn;
	    int dwn1 = upp*2+1;
	    if (dwn1>=heapSize)
		break;
	    int dwn2 = upp*2+2;
	    if (dwn2>=heapSize)
	    {
		dwn=dwn1;
	    }
	    else
	    {
		if (heap[dwn1]>heap[dwn2])
		    dwn=dwn1;
		else
		    dwn=dwn2;
	    }
	    if (heap[dwn]>heap[upp])
	    {
		int tmp = heap[dwn];
		heap[dwn] = heap[upp];
		heap[upp]=tmp;
		upp=dwn;
	    }
	    else
	    {
		break;
	    }
	}
    }

    /**
     * Build heap from top down
     * 
     * @param rdm
     */
    public void heapsort1(int[] rdm)
    {
	int[] newheap = new int[rdm.length];
	for (int i=0; i<rdm.length; i++)
	{
	    heapInsert(newheap, i, rdm[i]);
	}
	int heapsize=rdm.length;
	for (int i=0; i<rdm.length; i++)
	{
	    rdm[i]=heapPoll(newheap, heapsize--);	

	}
    }
    
    /**
     * Build heap bottom up.
     * Slightly, but stat significantly, better than heapsort1
     * @param rdm
     */
    public void heapsort2(int[] rdm)
    {
	int heapsize=rdm.length;
	int[] newheap = new int[rdm.length];
	for (int i=0; i<rdm.length; i++) 
	    newheap[i]=rdm[i];
	int i;
	for (i=2; (i-1)<newheap.length; i=i*2);
	i=i/4;
	while((i-1)>=0)
	{
	    int fullStart=i-1;
	    int fullLen=i;
	    for (int j=0; j<fullLen; j++)
		downheap(newheap, fullStart+j, heapsize);
	    i=i/2;
	}
        //printer(newheap, "heaped");
	for (i=0; i<rdm.length; i++)
	{
	    rdm[i]=heapPoll(newheap, heapsize--);	
	}
    }
    
    public void printer(int[] dta, String id)
    {
	for (int i=0; i<dta.length; i++)
	    System.out.println(id+ " " + i + " " + dta[i]);
    }
    
    
    private int[] domerge(int[] list1, int[] list2)
    {
	int[] rtn = new int[list1.length + list2.length];
	int locr=0, loc1=0, loc2=0;
	while (loc1<list1.length && loc2<list2.length) 
	{
	    if (list1[loc1] < list2[loc2])
	    {
		rtn[locr++]=list2[loc2++];
	    }
	    else
		rtn[locr++]=list1[loc1++];
	}
	for (int i=loc1; i<list1.length; i++)
	    rtn[locr++]=list1[i];
	for (int i=loc2; i<list2.length; i++)
	    rtn[locr++]=list2[i];
	return rtn;
    }
    
    public int[] mergesort(int[] list, int strt, int eend)
    {
	if (eend==strt)
	{
	    int[] tmp = new int[1];
	    tmp[0]=list[strt];
	    return tmp;
	}
	if (eend<strt)
	    return new int[0];
	int mid = (strt+eend)/2;
	return domerge(mergesort(list, strt, mid), mergesort(list, mid+1, eend));
    }
    
    
    
    public int[] mergesort2(int[] list, int strt, int eend)
    {
	if ((eend-strt)<100)
	{
	    int[] tmp = new int[eend-strt];
	    for (int i=0; i<(eend-strt); i++)
		tmp[i]=list[strt+i];
	    insertionSortIP(tmp);
	    return tmp;
	}
	if (eend<strt)
	    return new int[0];
	int mid = (strt+eend)/2;
	return domerge(mergesort(list, strt, mid), mergesort(list, mid+1, eend));
    }
    
    

    
    private int[] array;
    private int[] tempMergArr;
    private int length;
    public int[] mergesort3(int inputArr[]) {
        this.array = inputArr;
        this.length = inputArr.length;
        this.tempMergArr = new int[length];
        doMergeSort3(0, length - 1);
        return array;
    }
 
    private void doMergeSort3(int lowerIndex, int higherIndex) {
         
        if (lowerIndex < higherIndex) {
            int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
            // Below step sorts the left side of the array
            doMergeSort3(lowerIndex, middle);
            // Below step sorts the right side of the array
            doMergeSort3(middle + 1, higherIndex);
            // Now merge both sides
            mergeParts3(lowerIndex, middle, higherIndex);
        }
    }
 
    private void mergeParts3(int lowerIndex, int middle, int higherIndex) {
 
        for (int i = lowerIndex; i <= higherIndex; i++) {
            tempMergArr[i] = array[i];
        }
        int i = lowerIndex;
        int j = middle + 1;
        int k = lowerIndex;
        while (i <= middle && j <= higherIndex) {
            if (tempMergArr[i] <= tempMergArr[j]) {
                array[k] = tempMergArr[i];
                i++;
            } else {
                array[k] = tempMergArr[j];
                j++;
            }
            k++;
        }
        while (i <= middle) {
            array[k] = tempMergArr[i];
            k++;
            i++;
        }
    }
    
    public void quickSort(int arr[], int begin, int end) 
    {
	if (begin < end) {
	    int partitionIndex = partition(arr, begin, end);
	    
	    quickSort(arr, begin, partitionIndex-1);
	    quickSort(arr, partitionIndex+1, end);
	}
    }
    
    private int partition(int arr[], int begin, int end) 
    {
	int pivot = arr[end];
	int i = (begin-1);
	 
	for (int j = begin; j < end; j++) 
	{
	    if (arr[j] <= pivot) 
	    {
		i++;
	 
		int swapTemp = arr[i];
		arr[i] = arr[j];
		arr[j] = swapTemp;
	    }
	}
	int swapTemp = arr[i+1];
	arr[i+1] = arr[end];
	arr[end] = swapTemp;
	return i+1;
    }
    
    public static void main(String[] args)
    {
	//nmain();
	mmain();
    }
    
    
    public static void nmain()
    {
	ST st = new ST();
	int[] dta = st.fyShuffle(100);
	st.printer(dta, "BEF");
	dta = st.mergesort3(dta);
	st.printer(dta, "AFT");
    }

    
    public static void mmain()
    {
	int reps=5;
	int sorttype=7;
	ST st = new ST();
	for (int i=10000; i<10000000; i=i*2)
	{
	    long tt = 0;
	    for (int j=0; j<reps; j++)
	    {
		int[] dta = st.fyShuffle(i, (j+1)*i);
		long stime = System.nanoTime();
		switch(sorttype)
		{
		case 0:
		    st.selectionSortIP(dta);
		    break;
		case 1:
		    st.insertionSortIP(dta);
		    break;
		case 2:
		    st.heapsort1(dta);
		    break;
		case 3:
		    st.heapsort2(dta);
		    break;
		case 4:
		    st.mergesort(dta, 0, dta.length-1);
		    break;
		case 5:
		    st.mergesort2(dta, 0, dta.length-1);
		    break;
		case 6:
		    st.mergesort3(dta);
		    break;
		case 7:
		    st.quickSort(dta, 0, dta.length-1);
		    break;
		}
		long etime = System.nanoTime();
		//st.printer(dta, "AFT");
		System.out.println("    Time " + i + " "  + (etime-stime)/100000);
		tt += (etime-stime);
	    }
	    System.out.println("Time " + i + " "  + (tt/reps)/100000);
	}
    }
}