排序

	//冒泡
	for(int i = array.length -1; i > 0; i--){
			for(int j = 0; j < i; j++){
				if(array[j]>array[j+1]){
					int tem = 0;
					tem = array[j];
					array[j] = array[j+1];
					array[j+1] = tem;
				}
			}
		}
	//快速排序
	public static void quickSortByThree(int[] a, int low, int high) {
        if (low >= high)
            return;
        int mid = low + (high - low) / 2;
        if (a[mid] < a[low])
            Sort.swap(a, mid, low);//交换mid和low
        if (a[low] > a[high])
            Sort.swap(a, low, high);
        if (a[mid] > a[high])
            Sort.swap(a, mid, high);
        Sort.swap(a, mid, high - 1);
        int pivot = a[high - 1];
        int i, j;
        for (i = low, j = high - 1;;) {
            while (i < high - 1 && a[++i] < pivot)
                ;
            while (j > low && a[--j] > pivot)
                ;
            if (i >= j)
                break;
            Sort.swap(a, i, j);
        }
        Sort.swap(a, i, high - 1);
        quickSortByThree(a, low, i - 1);
        quickSortByThree(a, i + 1, high);
    }
    //插入排序
    public static void insertSort(int[] array) {
        int len = array.length;
        for (int i = 1; i < len; i++) {
            for (int j = i; j > 0; j--) {
                if (array[j] < array[j - 1]) {
                    Sort.swap(array, j, j - 1);//交换j和j-1
                } else
                    break;
            }
        }
    }
    //选择排序
    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[min]) {
                    min = j;
                }
            }
            Sort.swap(array, i, min);//交换i和min
        }
    }
    //归并排序
    public static void mergeSort(int[] a, int[] tmp, int left, int right) {
        if (left < right) {
            int mid = left + (right - left) / 2;
            mergeSort(a, tmp, left, mid);// 左排序
            mergeSort(a, tmp, mid + 1, right);// 右排序
            merge(a, tmp, left, mid + 1, right);// 左右合并
        }
    }
public static void merge(int[] a, int[] tmp, int left, int rightPos,
            int right) {
        int leftEnd = rightPos - 1;
        int tmpPos = left;
        int num = right - left + 1;
        while (left <= leftEnd && rightPos <= right) {
            if (a[left] < a[rightPos]) {
                tmp[tmpPos++] = a[left++];
            } else {
                tmp[tmpPos++] = a[rightPos++];
            }
        }
        while (left <= leftEnd) {
            tmp[tmpPos++] = a[left++];
        }
        while (rightPos <= right) {
            tmp[tmpPos++] = a[rightPos++];
        }
        for (int i = 0; i < num; i++, right--) {
            a[right] = tmp[right];
        }
    }
    //折半排序
    public static void halfSort(int[] array) {
        int low, high, mid;
        int tmp, j;
        for (int i = 1; i < array.length; i++) {
            tmp = array[i];
            low = 0;
            high = i - 1;
            while (low <= high) {
                mid = low + (high - low) / 2;
                if (array[mid] > tmp)
                    high = mid - 1;
                else
                    low = mid + 1;
            }
            for (j = i - 1; j > high; j--) {
                array[j + 1] = array[j];
            }
            array[high + 1] = tmp;
        }
    }