package cn.ac.ihep.sort;

import java.util.Arrays;

public class Sort implements ISort {
	
	final int MAXVALUE = 1000000;

	@Override
	public int[] InsertSort(int[] a) {
		// TODO Auto-generated method stub
		int  length = a.length;
		int i, j, temp;
		System.out.println("=================InsertSort Begin=======================");
		System.out.println("Before Sort:");
		System.out.println(Arrays.toString(a));
//		System.out.println("========================================================");
		for (i = 1; i < length; i++) {
			for (j = i-1; j >= 0; j--) {
				if (a[j] > a[j+1]) {
					temp = a[j+1];
					a[j+1] = a[j];
					a[j] = temp;
				}
			}
			//System.out.println(Arrays.toString(a));
		}
//		System.out.println("========================================================");
		System.out.println("After Sort:");
		System.out.println(Arrays.toString(a));
		System.out.println("=================InsertSort End=======================");
		
		return a;
	}

	@Override
	public int[] BubbleSort(int[] a) {
		// TODO Auto-generated method stub
		int  length = a.length;
		int i, j, temp;
//		System.out.println("=================BubbleSort Begin=======================");
//		System.out.println("Before Sort:");
//		System.out.println(Arrays.toString(a));
//		System.out.println("========================================================");
		for (i = length-1; i > 0; i--) {
			for (j = 0; j < i; j++) {
				if (a[j] > a[j+1]) {
					temp = a[j+1];
					a[j+1] = a[j];
					a[j] = temp;
				}
			}
			//System.out.println(Arrays.toString(a));
		}
//		System.out.println("========================================================");
//		System.out.println("After Sort:");
//		System.out.println(Arrays.toString(a));
//		System.out.println("==================BubbleSort End=======================");
		return a;
	}

	@Override
	public int[] SelectSort(int[] a) {
		// TODO Auto-generated method stub
		int  length = a.length;
		int i, j, k, temp;
//		System.out.println("=================SelectSort Begin=======================");
//		System.out.println("Before Sort:");
//		System.out.println(Arrays.toString(a));
		//System.out.println("========================================================");
		for (i = 0; i < length; i++) {
			k = i;
			for (j = i+1; j < length; j++) {
				if (a[j] < a[k]) {
					k = j;	
				}
			}
			temp = a[i];
			a[i] = a[k];
			a[k] = temp;
			
			//System.out.println(Arrays.toString(a));
		}
		//System.out.println("========================================================");
//		System.out.println("After Sort:");
//		System.out.println(Arrays.toString(a));
//		System.out.println("===============SelectSort End=======================");
		return a;
	}

	@Override
	public int[] ShellSort(int[] a) {
//		System.out.println("=================ShellSort Begin=======================");
//		System.out.println("Before Sort:");
//		System.out.println(Arrays.toString(a));
		int gap = a.length/2;  
        int temp;  
        while(gap>0){  
            for(int i=gap;i<a.length;i++){  
                temp = a[i];  
                int j = i - gap;  
                while(j>=0 && temp < a[j]){  
                    a[j+gap] = a[j];  
                    j = j - gap;  
                }  
                a[j+gap] = temp;  
            }  
            gap = gap/2;   
        }  
		
//		System.out.println("After Sort:");
//		System.out.println(Arrays.toString(a));
//		System.out.println("=================ShellSort End=======================");
		
		return a;
	}

	@Override
	public int[] QuickSort(int[] a) {
		
//		System.out.println("=================QuickSort Begin=======================");
//		System.out.println("Before Sort:");
//		System.out.println(Arrays.toString(a));
		
		MyQuickSort(a, 0, a.length-1);
		
//		System.out.println("After Sort:");
//		System.out.println(Arrays.toString(a));
//		System.out.println("=================QuickSort End=========================");
		return a;
	}
	public void MyQuickSort(int[] a, int p, int r) {

		if (p < r) {
			int q = partiton(a, p, r);
			MyQuickSort(a, p, q-1);
			MyQuickSort(a, q+1, r);
		}
	}
	public int partiton(int[] a, int p, int r) {
		int i = p-1;
		int x = a[r];
		for (int j = p; j < r; j++) {
			if (a[j] <= x) {
				i++;
				int temp = a[i];
				a[i] = a[j];
				a[j] = temp;			
			}
		}
		int temp = a[r];
		a[r] = a[i+1];
		a[i+1] = temp;
		
		return i+1;
	}

	@Override
	public int[] HeapSort(int[] a) {
		// TODO Auto-generated method stub
//		System.out.println("=================HeapSort Begin=======================");
//		System.out.println("Before Sort:");
//		System.out.println(Arrays.toString(a));
		int heapsize = a.length;
		
		BuildMaxHeap(a);
		
		//System.out.println(Arrays.toString(a));
		
		for (int i = heapsize-1; i > 0; i--) {
			int temp = a[0];
			a[0] = a[i];
			a[i] = temp;
			MaxHeapify(a, 0, i);
		}
//		System.out.println("After Sort:");
//		System.out.println(Arrays.toString(a));
//		System.out.println("=================HeapSort End=======================");
		return a;
	}
	public void BuildMaxHeap(int[] a) {
		int heapsize = a.length;
		
		for (int i = heapsize/2; i >= 0; i--) {
			MaxHeapify(a, i, heapsize);
		}
	}
	public void MaxHeapify(int[] a, int i, int heapsize) {
		int lChild = 2*i + 1;
		int rChild = 2*i + 2;
		
		int largest = i;
		
		if (lChild < heapsize && a[lChild] > a[i]) {
			largest = lChild;
		}
		if (rChild < heapsize && a[rChild] > a[largest]) {
			largest = rChild;
		}
		if (largest != i) {
			int temp = a[i];
			a[i] = a[largest];
			a[largest] = temp;
			MaxHeapify(a, largest, heapsize);
		}
	}

	@Override
	public int[] MergeSort(int[] a) {
//		System.out.println("=================MergeSort Begin=======================");
//		System.out.println("Before Sort:");
//		System.out.println(Arrays.toString(a));
		MyMergeSort(a, 0, a.length-1);
//		System.out.println("After Sort:");
//		System.out.println(Arrays.toString(a));
//		System.out.println("=================MergeSort End=======================");
		return a;
	}
	
	public void MyMergeSort(int[] a, int begin, int end) {
		if (begin < end) {
			int mid = (begin + end) / 2;
			MyMergeSort(a, begin, mid);
			MyMergeSort(a, mid+1, end);
			Merge(a, begin, mid, end);
		}
	}
	
	/*
	 * Merge() 
	 *
	 */
	public void Merge(int[] a, int begin, int mid, int end) {
		int nL = mid - begin + 1;
		int nR = end - mid;
		
		int[] L = new int[nL+1];
		int[] R = new int[nR+1];
		
		for (int i = 0; i < nL; i++) {
			L[i] = a[begin+i];
		}
		L[nL] = MAXVALUE;
		for (int i = 0; i < nR; i++) {
			R[i] = a[mid+1+i];
		}
		R[nR] = MAXVALUE;
		int i = 0;
		int j = 0;
		for (int k = begin; k <= end; k++) {
			if (L[i] < R[j]) {
				a[k] = L[i];
				i++;
			}
			else {
				a[k] = R[j];
				j++;
			}
		}
		
	}//end Merge()	
	
	@Override
	public int[] CountingSort(int[] a) {
//		System.out.println("=================CountingSort Begin=======================");
//		System.out.println("Before Sort:");
//		System.out.println(Arrays.toString(a));
		int len = a.length;
		int max = getArrayMax(a);
		int[] result = new int[len];
		int[] assist = new int[max+1];
		for (int i = 0; i < max+1; i++ ) {
			assist[i] = 0;
		}
		for (int i = 0; i < len; i++) {
			assist[a[i]]++;
		}
//		System.out.println("assist:");
//		System.out.println(Arrays.toString(assist));
		for (int i = 1; i < max+1; i++) {
			assist[i] += assist[i-1];
		}
//		System.out.println("assist:");
//		System.out.println(Arrays.toString(assist));
		for (int i = 0; i < len; i++) {
			result[ assist[a[i]] - 1 ] = a[i];
			assist[a[i]]--;
		}
//		System.out.println("After Sort:");
//		System.out.println(Arrays.toString(result));
//		System.out.println("=================CountingSort End=========================");
		return result;
	}
	public int getArrayMax(int[] a) {
		int len = a.length;
		int max = a[0];
		for (int i = 1; i < len; i++) {
			if (a[i] > max) {
				max = a[i];
			}
		}
		return max;
	}
}