import java.util.Random;


public class ST
{
    /**
     * 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[] rtn = new int[size]; 
	for (int i=0; i<size; i++) rtn[i]=i;
	Random r = new Random();
	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]);
    }
    public static void main(String[] args)
    {
	
	int sorttype=2;
	ST st = new ST();
	for (int i=10000; i<2000000; i=i*2)
	{
	int[] dta = st.fyShuffle(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;
	}
	long etime = System.nanoTime();
	//st.printer(dta, "AFT");
	System.out.println("Time " + i + " "  + (etime-stime)/100000);
	}
    }
}