各种排序算法

    // 冒泡，最小的值浮上来
    public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length; ++i) {
            for (int j = i + 1; j < array.length; ++j) {
                if (array[i] > array[j]) {
                    int tmp = array[i];
                    array[i] = array[j];
                    array[j] = tmp;
                }
            }
        }
    }

    // 选择，每次选择最小的值，最后交换当前的值
    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length; ++i) {
            int t = i;
            for (int j = i + 1; j < array.length; ++j) {
                if (array[j] < array[t]) {
                    t = j;
                }
            }
            if (t != i) {
                int tmp = array[t];
                array[t] = array[i];
                array[i] = tmp;
            }
        }
    }

    // 插入，简单插入
    public static void simpleInsertSort(int[] array) {
        for (int i = 1; i < array.length; ++i) {
            int j = i - 1;
            int get = array[i];
            while (j >= 0 && array[j] > get) {
                array[j + 1] = array[j];
                j--;
            }
            array[j + 1] = get;
        }
    }

    // 插入，希尔排序
    public static void shellInsertSort(int[] array) {
        int gap = array.length / 2;
        while (gap >= 1) {
            for (int i = gap; i < array.length; i++) {
                int j = i - gap;
                int get = array[i];
                while (j >= 0 && array[j] > get) {
                    array[j + gap] = array[j];
                    j -= gap;
                }
                array[j + gap] = get;
            }
            gap /= 2;
        }
    }

    // 归并
    public static void mergeSort(int[] array) {
        int[] tmp = new int[array.length];
        mergeSort(array, tmp, 0, array.length - 1);
    }

    private static void mergeSort(int[] array, int[] tmp, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(array, tmp, left, mid);
            mergeSort(array, tmp, mid + 1, right);
            merge(array, tmp, left, mid, right);
        }
    }

    // 将array[left,mid],array[mid+1，right]这两个数组合并
    private static void merge(int[] array, int[] tmp, int left, int mid, int right) {
        int i = left;
        int t = 0;
        int j = mid + 1;
        while (i <= mid && j <= right) {
            if (array[i] <= array[j]) {
                tmp[t++] = array[i++];
            } else {
                tmp[t++] = array[j++];
            }
        }

        while (i <= mid) {
            tmp[t++] = array[i++];
        }

        while (j <= right) {
            tmp[t++] = array[j++];
        }

        t = 0;
        while (left <= right) {
            array[left++] = tmp[t++];
        }
    }

    // 堆排序，将一维数组当做树结构
    public static void heapSort(int[] array) {
        // 调整堆为大根堆
        for (int i = array.length / 2 - 1; i >= 0; i--) {
            adjustHeap(array, i, array.length);
        }
        // 交换与继续调整
        for (int i = array.length - 1; i > 0; i--) {
            int tmp = array[i];
            array[i] = array[0];
            array[0] = tmp;
            adjustHeap(array, 0, i);
        }

    }

    // 调整堆
    private static void adjustHeap(int[] array, int i, int length) {
        int tmp = array[i];
        for (int k = 2 * i + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && array[k] < array[k + 1]) {
                k++;
            }
            if (array[k] > tmp) {
                array[i] = array[k];
                i = k;
            } else {
                break;
            }
        }
        array[i] = tmp;
    }

    // 快速排序，找到要插入的坑，然后递归
    public static void fastSort(int[] array) {
        fastSort(array, 0, array.length - 1);
    }

    // 快速排序
    private static void fastSort(int[] array, int left, int right) {
        if (left >= right) {
            return;
        }
        int low = left;
        int high = right;
        int index = array[low];
        while (low < high) {
            while (low < high && array[high] > index) {
                --high;
            }
            array[low] = array[high];
            while (low < high && array[low] < index) {
                ++low;
            }
            array[high] = array[low];
        }
        array[low] = index;
        fastSort(array, left, low - 1);
        fastSort(array, low + 1, right);
    }