常见排序算法

/*
 * 排序算法：
 *      交换排序：快速排序（O(NlogN),不稳定）、冒泡排序（O(N^2),稳定）
 *      插入排序：直接插入排序（O(N^2),稳定）、希尔排序（O(N^1.3)不稳定）
 *      选择排序：直接选择排序（O(N^2),不稳定），堆排序（O(NlogN),不稳定）
 *      归并排序（O(NlogN),稳定）
 */
public class Sort {
    /*
     * 1.快速排序，该方法有三个参数，数组arr，需要进行排序的部分数组(由low和high截取)，然后找
     * 一个基准值（一般为需要排序的数组的第一个元素），确定基准值所在的位置（start=end时），再使用
     * 递归对基准值两边的元素继续进行快排。
     * 
     * 简言之，快排第一步就是确定基准值的位置，然后再进行递归求解。
     */
    public static void quicklySort(int arr[], int low, int high) {
        int key = arr[low];
        int start = low;
        int end = high;
        while (start < end){
            while (arr[end] >= key && start < end){
                end--;
            }
            arr[start] = arr[end];
            while (arr[start] <= key && start < end){
                start++;
            }
            arr[end] = arr[start];
        }
        arr[start] = key; // 将基准值填到相应位置
        if (start > low)
            quicklySort(arr, low, start - 1);
        if (end < high)
            quicklySort(arr, end + 1, high);
    }

    /*
     * 2.冒泡排序，遇见比当前数小的就交换顺序
     */
    public static void bubbleSort(int arr[]) {
        int temp;
        for (int i = 0; i < arr.length; i++){
            for (int j = arr.length - 1; j > i; j--){ //从后往前冒，当然也可以从前往后沉
                if (arr[j] < arr[j - 1]){
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
        }
    }
    /*
     * 3.直接插入排序,假设数组第一个元素自成一个有序序列，从第二个元素起，依次与前面的元素进行
     * 比较，插入到正确的位置以构成有序序列，直到最后一个元素插入到正确位置从而使得整个数组有序。
     */
    public static void insertionSort(int arr[]) {
        int temp;
        for (int i = 1; i < arr.length; i++){ //i表示从哪个位置的元素开始与它之前的元素进行比较
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1] ){//这里不用for循环是因为使用for循环则无论arr[j]是否小于arr[j-1],都要进行j--的操作
                temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
                j--;
            }
        }
    }

    /*
     * 4.希尔排序，改进的直接插入排序，先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行
     * 直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入
     * 排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有
     * 较大提高。步长的选择是希尔排序的重要部分。只要最终步长为1任何步长序列都可以工作。
     */
    public static void shellSort(int arr[]) {
        int increment;
        for (increment = arr.length / 2; increment > 0; increment /= 2){
            //增量之后进行直接插入排序
            for (int j = increment; j < arr.length; j++){
                if (arr[j] < arr[j - increment]){
                    int temp = arr[j];
                    int k = j - increment;
                    while (k >= 0 && arr[k] > temp){
                        arr[k + increment] = arr[k];
                        k -= increment;
                    }
                    arr[k + increment] = temp;
                }
            }
        }
    }

    /*
     * 5.直接选择排序，思想就是从第一个元素开始遍历数组，找到数组中的最小元素跟第一个元素交换
     * 位置，然后接着从第二个元素开始重复刚才的过程，直到最后一个元素，跟冒泡不同，直接选择排序
     * 是每一次遍历只交换一次元素，而冒泡则是只要发现当前元素比前面的元素小就要交换位置。
     */
    public static void selectionSort(int arr[]) {
        int min;//记录最小元素的索引位置
        int temp;
        for (int i = 0; i < arr.length - 1; i++){
            min = i;
            for (int j = i + 1; j < arr.length; j++){
                if (arr[j] < arr[min]){
                    min = j;
                }
            }
            temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
        }
    }

    /*
     * 6.堆排序，升序构建最大堆（父大于子），
     * 首先，构建最大堆buildMaxHeap();需要借助筛选函数heapScreen();
     * 其次，将堆顶元素跟堆得最后一个元素交换位置（最大值放后边）
     * 
     */
    //n为构建堆的节点总数
    public static void buildMaxHeap(int arr[], int n) {
        //1.构建最大堆
        for (int i = (n - 1) / 2; i >= 0; i--){//从最后一个非叶子结点开始筛选 i = (n - 1) / 2
            heapScreen(arr, i, n);
        }
    }
    //筛选，即调整元素位置，使之满足最大堆的性质,i为开始节点，n为节点总数 
    public static void heapScreen(int arr[], int i, int n) {
        int temp = arr[i];
        int j = 2 * i + 1;//左孩子
        while (j < n){
            if (j + 1 < n && arr[j] < arr[j + 1])
                j++;
            if (arr[j] <= temp)
                break;
            arr[i] = arr[j];
            i = j;
            j = 2 * i + 1;
        }
        arr[i] = temp;
    }

    public static void heapSort(int arr[]) {
        for (int i = arr.length; i > 0; i-- ){
            buildMaxHeap(arr,i);
            System.out.println(arr[0]);
            //注意：这里交换元素不能用swap函数，这涉及到引用传递的问题。详情见博客
            int temp = arr[0];
            arr[0] = arr[i - 1];
            arr[i - 1] = temp;

        }
    }

    /*7、归并排序
     * 步骤：先递归拆分(sort)，然后合并（merge），排序在合并中实现
     */
    public static void mergeSort(int arr[]){
        sort(arr, 0, arr.length - 1);
    }

    public static void sort(int arr[], int low, int high) {
        if (low < high){
            int mid = (low + high) / 2;
            sort(arr, 0, mid);
            sort(arr, mid + 1, high);
            merge(arr, low, mid, high);
        }
    }

    public static void merge(int arr[], int low, int mid, int high) {
        int i = low;
        int j = mid + 1;
        int temp[] = new int[arr.length];//定义长度为arr.length的数组是为了下标能跟arr对上
        int k = low;//临时数组temp的下标
        while (i <= mid && j <= high){
            if (arr[i] <= arr[j])
                temp[k++] = arr[i++];
            else
                temp[k++] = arr[j++];
        }
        while (i <= mid)
            temp[k++] = arr[i++];
        while (j <= high)
            temp[k++] = arr[j++];
        for (int n = low; n <= high; n++)
            arr[n] = temp[n];
    }
}