冒泡 选择 插入 希尔 堆 归并 快速 排序算法

public static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
/**最简单的排序。<br>缺点是每次找最小值都是单纯的找，而没有为下一次寻找做出铺垫；*/
public static int[] simple_sort(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                swap(arr, i, j);
            }
        }
    }
    return arr;
}
/**标准冒泡排序。思想就是两两相邻比较并交换*/
public static int[] bubble_sort2(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = arr.length - 1; j > i; j--) {
            if (arr[j] < arr[j - 1]) {
                swap(arr, j, j - 1);
            }
        }
    }
    return arr;
}
/**改进冒泡排序<br>
改进在于如果出现一个序列，此序列基本是排好序的，如果是标准的冒泡排序，则还是需要进行不断的比较；<br>
最好：n-1次比较不移动，时间复杂度为O(n)，不占用辅助空间 。<br>最坏：n(n-1)/2次比较和移动，O(n^2)，占用交换的临时空间，大小为1*/
public static int[] bubble_sort3(int[] arr) {
    boolean isChanged = true;//如果一次循环中没有交换过元素，则说明已经排好序；
    for (int i = 0; i < arr.length && isChanged; i++) {
        isChanged = false;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                swap(arr, i, j);
                isChanged = true;
            }
        }
    }
    return arr;
}
/**简单选择排序。好于冒泡排序  <br>
每次循环找到最小值，并交换，因此交换次数始终为n-1次。<br>相对于最简单的排序，对于很多不必要的交换做了改进<br>
最差：n(n-1)/2次比较，n-1次交换，时间复杂度为O(n^2)  。<br>最好：n(n-1)/2次比较，不交换，时间复杂度为O(n^2)*/
public static int[] selection_sort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        int min = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[min] > arr[j]) {
                min = j;
            }
        }
        if (min != i) swap(arr, min, i);
    }
    return arr;
}
/**简单插入排序。<br>比选择排序和冒泡排序好。<br>对于记录较少或基本有序时很有效<br>
思想：给序列设定一个分界线，每次循环将分界线右边尚未排序的一个元素插入左侧已排序的数组中，并将分界线向右移一位<br>
最好：n-1次比较，0次移动，时间复杂度为O(n)  。<br>最差：(n+2)(n-1)/2次比较，(n+4)(n-1)/2次移动，时间复杂度为 O(n^2)  */
public static int[] insertion_sort(int[] arr) {
    int j;
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] < arr[i - 1]) {
            int tmp = arr[i];
            for (j = i - 1; j >= 0 && arr[j] > tmp; j--) {
                arr[j + 1] = arr[j];
            }
            arr[j + 1] = tmp;
        }
    }
    return arr;
}
/**希尔排序。<br>第一个突破O(n^2)的排序算法；是简单插入排序的改进版<br>
思想：通过将序列进行分组排序使得每组容量变小，再进行分组排序，然后进行一次简单插入排序即可<br>
时间复杂度为：O(n^(3/2))  。<br>不稳定排序算法  */
public static int[] shell_sort(int[] arr) {
    int j;
    int increment = arr.length;//如果increment=3，则i%3相等的索引为一组，比如索引1，1+3，1+3*2
    do {
        increment = increment / 3 + 1;//一般增量公式为：increment = increment/3+1
        for (int i = increment; i < arr.length; i++) { //i=increment 因为插入排序默认每组的第一个记录都是已排序的  
            if (arr[i] < arr[i - increment]) {
                int tmp = arr[i];
                for (j = i - increment; j >= 0 && arr[j] > tmp; j -= increment) {
                    arr[j + increment] = arr[j];
                }
                arr[j + increment] = tmp;
            }
        }
    } while (increment > 1);
    return arr;
}
/**堆排序。<br>是简单选择排序的改进版<br>
思想：构建一棵完全二叉树，首先构建大根堆,然后每次都把根节点即最大值移除，并用编号最后的节点替代，
这时数组长度减1，然后重新构建大根堆，以此类推；<br>
时间复杂度为O(nlogn)。辅助空间为1。<br>不稳定排序算法<br>不适合排序个数较少的序列，因为初始构建堆需要时间*/
public static int[] heap_sort(int[] arr) {
    int tmp[] = new int[arr.length + 1];
    tmp[0] = -1;
    for (int i = 0; i < arr.length; i++) {
        tmp[i + 1] = arr[i];
    }
    // 构建大根堆：O(n)  
    for (int i = arr.length / 2; i >= 1; i--) {
        makeMaxRootHeap(tmp, i, arr.length);
    }
    // 重建：O(nlogn)  
    for (int i = arr.length; i > 1; i--) {
        swap(tmp, 1, i);
        makeMaxRootHeap(tmp, 1, i - 1);
    }
    for (int i = 1; i < tmp.length; i++) {
        arr[i - 1] = tmp[i];
    }
    return arr;
}
private static void makeMaxRootHeap(int[] arr, int low, int high) {
    int tmp = arr[low];
    int j;
    for (j = 2 * low; j <= high; j *= 2) {
        if (j < high && arr[j] < arr[j + 1]) {
            j++;
        }
        if (tmp >= arr[j]) {
            break;
        }
        arr[low] = arr[j];
        low = j;
    }
    arr[low] = tmp;
}
/**归并排序。<br>
思想：利用递归进行分割和合并，分割直到长度为1为止，并在合并前保证两序列原本各自有序，合并后也有序<br>
时间复杂度O(nlogn) 。空间复杂度：O(n+logn) 。<br>稳定排序；*/
public static int[] merge_sort(int[] arr) {
    Msort(arr, arr, 0, arr.length - 1);
    return arr;
}
private static void Msort(int[] sr, int[] tr, int s, int t) {
    int tr2[] = new int[sr.length];
    int m;
    if (s == t) {
        tr[s] = sr[s];
    } else {
        m = (s + t) / 2;
        Msort(sr, tr2, s, m);
        Msort(sr, tr2, m + 1, t);
        Merge(tr2, tr, s, m, t);
    }
}
private static void Merge(int[] tr2, int[] tr, int i, int m, int t) {
    int j, k;
    for (j = i, k = m + 1; i <= m && k <= t; j++) {
        if (tr2[i] < tr2[k]) {
            tr[j] = tr2[i++];
        } else {
            tr[j] = tr2[k++];
        }
    }
    while (i <= m) {
        tr[j++] = tr2[i++];
    }
    while (k <= t) {
        tr[j++] = tr2[k++];
    }
}
/**快速排序。<br>冒泡排序的升级版，现在用的最多的排序方法<br>
思想：选取pivot，将pivot调整到一个合理的位置，使得左边全部小于他，右边全部大于他；<br>
时间复杂度：最好：O(nlogn) ，最坏：O(n^2)  。<br>空间复杂度：O(logn)  。<br>不稳定排序算法  */
public static int[] quick_sort(int[] arr) {
    qsort(arr, 0, arr.length - 1);
    return arr;
}
/**快速排序优化方案*/
public static int[] quick_sort2(int[] arr) {
    if (arr.length > 10) {
        qsort(arr, 0, arr.length - 1);
    } else {//快速排序适合大数组排序，如果是小数组，则效果可能没有简单插入排序来得好
        insertion_sort(arr);
    }
    return arr;
}
private static void qsort(int[] arr, int low, int high) {
    int pivot;
    if (low < high) {
        pivot = partition(arr, low, high);
        qsort(arr, low, pivot);
        qsort(arr, pivot + 1, high);
    }
}
private static int partition(int[] arr, int low, int high) {
    int pivotkey;
    pivotkey = arr[low];//选择pivot，此处可以优化  
    while (low < high) {
        while (low < high && arr[high] >= pivotkey) {
            high--;
        }
        swap(arr, low, high);//交换，此处可以优化  
        while (low < high && arr[low] <= pivotkey) {
            low++;
        }
        swap(arr, low, high);
    }
    return low;
}