十大经典排序算法（Java实现）

排序算法概述

定义

将杂乱无章的数据元素，通过一定的方法按关键字顺序排列的过程叫做排序。

比较

各算法原理及实现

下面我们来逐一分析十大经典排序算法，主要围绕下列问题展开：
1、算法的基本思想是什么？
2、算法的代码实现？
3、算法的时间复杂度是多少？（平均、最好、最坏）什么情况下最好？什么情况下最坏？
4、算法的空间复杂度是多少？
5、算法的稳定性如何？

直接插入排序（Insertion Sort）

基本思想

直接插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

算法描述

一般来说，直接插入排序都采用in-place（原地算法）在数组上实现。具体算法描述如下：

从第一个元素开始，该元素可以认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
将新元素插入到该位置后；
重复步骤2~5。

动图演示

代码实现

public static int[] insertioSort(int[] nums){
    if (nums.length <= 1) return nums;
    int current;
    for (int i = 1; i < nums.length; ++i){
        current = nums[i];
        int preIndex = i - 1;
        while (current >= 0 && current < nums[preIndex]){
            nums[preIndex + 1] = nums[preIndex];
            preIndex--;
        }
        nums[preIndex + 1] = current;
    }
    return nums;
}

时间复杂度：

直接插入排序平均时间复杂度为O(n²)，最好时间复杂度为O(n)，最坏时间复杂度为O(n²)。

最好情况：

如果待排序元素本来是正序的，比较和移动元素的次数分别是 (n - 1) 和 0，因此最好情况的时间复杂度为O(n)。

最坏情况：如果待排序元素本来是逆序的，需要进行 (n - 1) 趟排序，所需比较和移动次数分别为 n * (n - 1) / 2和 n * (n - 1) / 2。因此最坏情况下的时间复杂度为O(n²)。

空间复杂度

直接插入排序使用了常数空间，空间复杂度为O（1）

稳定性

直接插入属于稳定的

算法扩展

在直接插入排序中，待插入的元素总是在有序区线性查找合适的插入位置，没有利用有序的优势，考虑使用二分查找搜索插入位置进行优化，即二分插入排序。

public static int[] binaryInsertioSort(int[] nums){
    if (nums.length <= 1) return nums;
    for (int i = 1; i < nums.length; ++i){
        int left = 0;
        int right = i - 1;
        int current = nums[i];
        while(left <= right){
            int mid = left + (right - left) / 2;
            if (nums[mid] > right){
                right -= 1;
            } else {
                left += 1;
            }
        }
        for (int j = i - 1; j >= left; --j){
            nums[j + 1] = nums[j];
        }
        nums[left] = current;
    }
    return nums;
}

冒泡排序（Bubble Sort）

基本思想

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为每趟比较将当前数列未排序部分的最大的元素“沉”到数列末端，而小的元素会经由交换慢慢“浮”到数列的顶端。

算法描述

比较相邻的元素。如果前一个比后一个大，就交换它们两个；
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
针对所有的元素重复以上的步骤，除了最后一个；
重复步骤1~3，直到排序完成。为了优化算法，可以设立一个布尔标识，每趟排序开始前设为false，如果该趟排序发生了交换就置为true，如果一趟排序结束标识仍为false表示该趟排序没有发生交换，即数组已经有序，可以提前结束排序。

动图演示

public static int[] bubbleSort(int[] nums){
    if (nums.length <= 1) return nums;
    // 设置标识，检测是否交换过，如果没有交换过则表示已经有序，无需排序
    int numPairs = nums.length;
    boolean = isSwap = true;
    while (isSwap){
        isSwap = false;
        for (int i = 0; i < numPairs - 1; ++i){
            if (nums[i + 1] < nums[i]){
                int temp = nums[i + 1];
                nums[i + 1]  = nums[i];
                nums[i] = temp;
                isSwap = true;
            }
        }
        numPairs--;
    }
    return nums;
}

时间复杂度

冒泡排序平均时间复杂度为O(n²)，最好时间复杂度为O(n)，最坏时间复杂度为O(n²)。

最好情况：

如果待排序元素本来是正序的，那么一趟冒泡排序就可以完成排序工作，比较和移动元素的次数分别是 (n - 1) 和 0，因此最好情况的时间复杂度为O(n)。

最坏情况：如果待排序元素本来是逆序的，需要进行 (n - 1) 趟排序，所需比较和移动次数分别为 n * (n - 1) / 2和 3 * n * (n-1) / 2。因此最坏情况下的时间复杂度为O(n²)。

空间复杂度

冒泡排序使用了常数空间，空间复杂度为O(1)

稳定性

当 array[j] == array[j+1] 的时候，我们不交换 array[i] 和 array[j]，所以冒泡排序是稳定的。

算法扩展

鸡尾酒排序，又称定向冒泡排序、搅拌排序等，是对冒泡排序的改进。在把最大的数往后面冒泡的同时，把最小的数也往前面冒泡，同时收缩无序区的左右边界，有序区在序列左右逐渐累积。

动图如下：

代码如下：

public static int[] cocktailSort(int[] nums){
    if (nums.length <= 1) return nums;
    int left = 0, right = nums.length - 1;
    while (left <= right){
        for (int i = left; i < right; ++i){
            if (nums[i + 1] < nums[i]){
                int temp = nums[i + 1];
                nums[i + 1] = nums[i];
                nums[i] = temp;
            }
        }
        
    }
}

鸡尾酒排序是稳定的。它的平均时间复杂度为O(n²)，最好情况是待排序列原先就是正序的，时间复杂度为O(n)，最坏情况是待排序列原先是逆序的，时间复杂度为O(n²。空间复杂度为O(1)。

快速排序（Quick Sort）

基本思想

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

算法描述

快速排序使用分治法来把一个数列分为两个子数列。具体算法描述如下：

从数列中挑出一个元素，称为 “基准”（pivot）；
重新排序数列，所有比基准值小的元素放在基准前面，所有比基准值大的元素放在基准的后面（相同的数可以到任一边），该基准就处于数列的中间位置。这称为分区（partition）操作；
递归地（recursive）对小于基准值元素的子数列和大于基准值元素的子数列进行快速排序。

动图演示

代码实现

快速排序最核心的步骤就是partition操作，即从待排序的数列中选出一个数作为基准，将所有比基准值小的元素放在基准前面，所有比基准值大的元素放在基准的后面（相同的数可以到任一边），该基准就处于数列的中间位置。partition函数返回基准的位置，然后就可以对基准位置的左右子序列递归地进行同样的快排操作，从而使整个序列有序。

下面我们来介绍partition操作的两种实现方法：左右指针法 和 挖坑法。

方法一：左右指针法

基本思路：

将数组的最后一个数 right 作为基准数 key。
分区过程：从数组的首元素 begin 开始向后找比 key 大的数（begin 找大）；end 开始向前找比 key 小的数（end 找小）；找到后交换两者（swap），直到 begin >= end 终止遍历。最后将 begin（此时begin == end）和最后一个数交换（这个时候 end 不是最后一个位置），即 key 作为中间数（左区间都是比key小的数，右区间都是比key大的数）
再对左右区间重复第二步，直到各区间只有一个数。


/**
 * 快速排序方法
 * @param nums
 * @param left 数列左边界
 * @param right 数列右边界
 * @return
 */
public static void Quicksort(int[] nums, int left, int right) {
    if(left < right){
        int pos = partition(nums, left, right);
        Quicksort(nums, left, pos - 1);
        Quicksort(nums, pos + 1, right);
    }
}

/**
 * partition操作
 * @param nums
 * @param left 数列左边界
 * @param right 数列右边界
 * @return
 */
public static int partition(int[] nums, int left, int right){
    int begin = left;
    int end = right;
    while (begin < end){
        // begin找大
        while (begin < end && nums[begin] <= nums[right]) begin++;
        // end找小
        while (begin < end && nums[end] >= nums[right]) end--;
        swap(nums, begin, end);
    }
    swap(nums, begin, right);
    return begin;       //返回基准
}
/**
 * 交换数组内两个元素
 * @param nums
 * @param i
 * @param j
 */
public static void swap(int[] nums, int i, int j){
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

方法二：挖坑法

基本思路：

定义两个指针 left 指向起始位置，right 指向最后一个元素的位置，然后指定一个基准 key（right），作为坑。
left 寻找比基准（key）大的数字，找到后将 left 的数据赋给 right，left 成为一个坑，然后 right 寻找比基数（key）小的数字，找到将 right 的数据赋给 left，right 成为一个新坑，循环这个过程，直到 begin 指针与 end指针相遇，然后将 key 填入那个坑（最终：key的左边都是比key小的数，key的右边都是比key大的数），然后进行递归操作。

/**
 * partition操作
 * @param nums
 * @param left 数列左边界
 * @param right 数列右边界
 * @return
 */
public static int partition(int[] nums, int left, int right){
    int key = nums[right]; // 初始坑
    while (left < right){
        // left 找大
        while (left < right && nums[left] <= key) left++;
        nums[right] = nums[left]; // 赋值，然后left作为新坑
        // right找小
        while (left < right && nums[right] >= key) right--;
        nums[left] = nums[right]; // right作为新坑
    }
    nums[left] = key;
    // 将key赋值给left和right的相遇点
    // 保持key的左边都是比key小的数，key的右边都是比key大的数
    return left;
}

 /**
 * 快速排序方法
 * @param nums
 * @param left 数列左边界
 * @param right 数列右边界
 * @return
 */
public static void Quicksort(int array[], int left, int right) {
    if(left < right){
        int pos = partition(array, left, right);
        Quicksort(array, left, pos - 1);
        Quicksort(array, pos + 1, right);
    }
}

代码优化

我们之前选择基准的策略都是固定基准，即固定地选择序列的右边界值作为基准，但如果在待排序列几乎有序的情况下，选择的固定基准将是序列的最大（小）值，快排的性能不好（因为每趟排序后，左右两个子序列规模相差悬殊，大的那部分最后时间复杂度很可能会达到O(n²）

下面提供几种常用的快排优化：

优化一：随机基准

每次随机选取基准值，而不是固定选取左或右边界值。将随机选取的基准值和右边界值进行交换，然后就回到了之前的解法。只需要在 partition 函数前增加如下操作即可：

int random = (int) (left + Math.random() * (right - left + 1));
//随机选择 left ~ right 之间的一个位置作为基准
swap(array, random, right);
//把基准值交换到右边界

优化二：三数取中法

基本思想：

取第一个数，最后一个数，第（N/2）个数即中间数，三个数中数值中间的那个数作为基准值。

举个例子，对于int[] array = { 2，5，4，9，3，6，8，7，1，0}，2、3、0分别是第一个数，第（N/2）个是数以及最后一个数，三个数中3最大，0最小，2在中间，所以取2为基准值。实现getMid函数即可：

/**
 * 三数取中，返回array[left]、array[mid]、array[right]三者的中间者下标作为基准
 * @param array
 * @param left
 * @param right
 * @return
 */
public static int getMid(int[] array,int left,int right) {
    int mid = left + ((right - left) >> 1);
    int a = array[left];
    int b = array[mid];
    int c = array[right];
    if ((b <= a && a <= c) || (c <= a && a <= b)) { //a为中间值
        return left;
    }
    if ((a <= b && b <= c) || (c <= b && b <= a)) { //b为中间值
        return mid;
    }
    if ((a <= c && c <= b) || (b <= c && c <= a)) { //c为中间值
        return right;
    }
    return left;
}

优化三：当待排序序列的长度分割到一定大小后，使用插入排序

在子序列比较小的时候，直接插入排序性能较好，因为对于有序的序列，插排可以达到O(n)的复杂度，如果序列比较小，使用插排效率要比快排高。

实现方式也很简单，快排是在子序列元素个数为 1 时才停止递归，我们可以设置一个阈值n，假设为5，则大于5个元素，子序列继续递归，否则选用插排。
此时QuickSort()函数如下：

public static void Quicksort(int array[], int left, int right) {
    if(right - left > 5){
        int pos = partition(array, left, right);
        Quicksort(array, left, pos - 1);
        Quicksort(array, pos + 1, right);
    }else{
        insertionSort(array);
    }
}

优化四：三路划分

如果待排序列中重复元素过多，也会大大影响排序的性能，这是因为大量相同元素参与快排时，左右序列规模相差极大，快排将退化为冒泡排序，时间复杂度接近O(n2)。这时候，如果采用三路划分，则会很好的避免这个问题。

三路划分的思想是利用 partition 函数将待排序列划分为三部分：第一部分小于基准v，第二部分等于基准v，第三部分大于基准v。这样在递归排序区间的时候，我们就不必再对第二部分元素均相等的区间进行快排了，这在待排序列存在大量相同元素的情况下能大大提高快排效率。

来看下面的三路划分示意图：

说明：红色部分为小于基准v的序列，绿色部分为等于基准v的序列，白色部分由于还未被 cur 指针遍历到，属于大小未知的部分，蓝色部分为大于基准v的序列。
left 指针为整个待排区间的左边界，right 指针为整个待排区间的右边界。less 指针指向红色部分的最后一个数（即小于v的最右位置），more 指针指向蓝色部分的第一个数（即大于v的最左位置）。cur 指针指向白色部分（未知部分）的第一个数，即下一个要判断大小的位置。

算法思路：

由于最初红色和蓝色区域没有元素，初始化 less = left - 1，more = right + 1，cur = left。整个区间为未知部分（白色）。
如果当前 array[cur] < v，则 swap(array,++less,cur++)，即把红色区域向右扩大一格（less指针后移），把 array[cur] 交换到该位置，cur 指针前移判断下一个数。
如果当前 array[cur] = v，则不必交换，直接 cur++
如果当前 array[cur] > v，则 swap(array,–more,cur)，即把蓝色区域向左扩大一格（more指针前移），把 array[cur] 交换到该位置。特别注意！此时cur指针不能前移，这是因为交换到cur位置的元素来自未知区域，还需要进一步判断array[cur]。

利用三路划分，我们就可以递归地进行三路快排了！并且可以愉快地避开所有重复元素区间。

代码实现：

public static int[] partition(int[] array,int left,int right){
        int v = array[right]; //选择右边界为基准
        int less = left - 1; // < v 部分的最后一个数
        int more = right + 1; // > v 部分的第一个数
        int cur = left;
        while(cur < 7more){
            if(array[cur] < v){
                swap(array,++less,cur++);
            }else if(array[cur] > v){
                swap(array,--more,cur);
            }else{
                cur++;
            }
        }
        return new int[]{less + 1,more - 1};  //返回的是 = v 区域的左右下标
}

public static void Quicksort(int array[], int left, int right) {
        if (left < right) {
            int[] p = partition(array,left,right);
            Quicksort(array,left,p[0] - 1); //避开重复元素区间
            Quicksort(array,p[1] + 1,right);
        }
}

归并排序（Merge Sort）

基本思想

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

算法描述

把长度为 n 的输入序列分成两个长度为 n / 2 的子序列；
对这两个子序列分别采用归并排序；
将两个排序好的子序列合并成一个最终的排序序列。

动图演示

代码实现

/**
 * 归并排序
 * @param nums
 * @return
 */
public static int[] mergeSort(int[] nums){
    if (nums.length < 2) return nums;
    int mid = nums.length / 2;
    int[] left = Arrays.copyOfRange(nums, 0, mid);
    int[] right = Arrays.copyOfRange(nums, mid, nums.length);
    return merge(mergeSort(left), mergeSort(right));
}

/**
 * 归并排序--将两段有序数组结合成一个有序数组
 * @param left
 * @param right
 * @return
 */

public static int[] merge(int[] left, int[]  right){
    int[] result = new int[left.length + right.length];
    int i = 0, j  = 0, k = 0;
    while (i < left.length && j < right.length){
        if (left[i] <= right[j]) {
            result[k++] = left[i++];
        } else {
            result[k++] = right[j++];
        }
    }
    while (i < left.length){
        result[k++] = left[i++];
    }
    while (j < right.length){
        result[k++] = right[i++];
    }
    return result;
}

时间复杂度

归并排序平均时间复杂度为O(nlogn)，最好时间复杂度为O(nlogn)，最坏时间复杂度为O(nlogn)。

归并排序的形式就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的可以得出它在任何情况下时间复杂度均是O(nlogn)。

空间复杂度

归并排序空间复杂度为O(n)

稳定性

归并排序是稳定的。

算法应用

归并排序可以用于求解逆序对数量问题，具体见：剑指offer - 数组中的逆序对

import java.util.*;
public class Solution {
     private static final int MOD = 1000000007;
     private int cnt = 0;

    //递归调用
     private int[] MergeSort(int[] array) {
        if (array.length < 2) 
            return array;
        int mid = array.length / 2;
        int[] left = Arrays.copyOfRange(array, 0, mid);
        int[] right = Arrays.copyOfRange(array, mid, array.length);
        return merge(MergeSort(left), MergeSort(right));
    }
    /**
     * 将两段有序数组结合成一个有序数组
     *
     * @param left
     * @param right
     * @return
     */
    private int[] merge(int[] left, int[] right) {
             int[] result = new int[left.length + right.length];
             int i = 0,j = 0,k = 0;
             while (i < left.length && j < right.length) {
                if (left[i] <= right[j]) {
                    result[k++] = left[i++];
                } else {
                    result[k++] = right[j++];
                     /*归并同时统计逆序对数量，因为归并的两个子序列都已有序，故当left[i] >  
                     right[j]，有left[i...left.length - 1]均大于right[j]*/
                    this.cnt = (this.cnt % MOD + (left.length - i) % MOD) % MOD;
                }
             }
             while (i < left.length) {
                result[k++] = left[i++];
             }
             while (j < right.length) {
                result[k++] = right[j++];
             }
             return result;
     }

     public int InversePairs(int [] array) {
        MergeSort(array);
        return cnt % MOD;
    }
}

堆排序（Heap Sort）

基本思想

堆排序是一种树形选择排序方法，它利用了堆这种数据结构。在排序的过程中，将array[0，…，n-1]看成是一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的关系，在当前无序区中选择关键字最大（最小）的元素。

概念

堆：堆是一种完全二叉树，且满足所有父节点的值均大于等于（或小于等于）其子节点的值。

大根堆（最大堆）：满足所有父节点的值均大于等于其子节点的值的堆称为大根堆，堆顶元素是堆中元素的最大值。

小根堆（最小堆）：满足所有父节点的值均小于等于其子节点的值的堆称为小根堆，堆顶元素是堆中元素的最小值。

堆的顺序存储结构：使用顺序数据结构（数组）存储堆，表示方法为：

数组按层序遍历的顺序存放完全二叉树的结点，下标为 0 处为堆顶，下标为 len - 1 处为堆尾。
结点 i 如果存在左孩子（下标不超过 len - 1 就存在），左孩子的下标为（2 * i + 1）；如果存在右孩子，右孩子的下标为（2 * i + 2）。结点 i 的父结点下标为 (i - 1) / 2 (下标为 0 的结点除外，它没有父结点)。最后一个非叶子结点即为堆尾元素的父结点，下标为 (len - 1 - 1) / 2 = (len - 2) / 2。

算法描述

将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为（n-1），则整个排序过程完成。

动图演示

代码实现

// 声明全局变量 用于记录nums的长度
static int len;

public static int[] HeapSort(int[] nums){
    len = nums.length;
    if (len <= 1) return nums;
    // 1.构建大顶堆
    buildMaxHeap(nums);
    // 2.循环将堆顶（最大值）与堆尾交换，删除堆尾元素，然后重现调整大顶堆
    while(len > 0){
        swap(nums, 0, len - 1);
        len--; // 原先的堆尾进入有序区，删除堆尾元素
        adjustHeap(nums, 0); // 重新调整大顶堆
    }
    return nums;
}

/**
 * 自顶向下调整以i为根的堆为大顶堆
 * @param nums
 * @param i
 */
public static void adjustHeap(int[] nums, int i){
    int maxIndex = i;
    // 如果有左子树，且左子树大于父节点，则将最大指针指向左子树
    if (2 * i + 1 < len && nums[2 * i + 1] > nums[maxIndex]) maxIndex = 2 * i + 1;
    // 如果有右子树， 且右子树大于父节点，则将最大指针指向右子树
    if (2 * i + 2 < len && nums[2 * i + 2] > nums[maxIndex]) maxIndex = 2 * i + 2;
    // 如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。
    if (maxIndex != i){
        swap(nums, maxIndex, i);
        adjustHeap(nums, maxIndex);
    }
}

/**
 * 自底向上构建初始大根堆
 * @param nums
 */
public static void buildMaxHeap(int[] nums){
    // 从最后一个非叶子节点开始自底向上构建大顶堆
    for(int i = (len - 2) / 2; i >= 0; i--){
        adjustHeap(nums, i);
    }
}

/**
 * 交换数组的两个数
 * @param arr
 * @param i
 * @param len
 */
public static  void swap(int[] arr,int i,int len){
    int temp = arr[i];
    arr[i] = arr[len];
    arr[len] = temp;
}

扩展

插入元素：只需要把待插入的元素放置在堆尾，然后 len++ 把其纳入堆，然后调用 adjustHeap 函数重新调整堆即可。

删除堆顶元素：只需要把堆顶元素交换到堆尾，然后 len– 把其移出堆，然后调用 adjustHeap 函数重新调整堆即可。

时间复杂度

堆排序平均时间复杂度为O(nlogn)，最好时间复杂度为O(nlogn)，最坏时间复杂度为O(nlogn)。

堆排序的形式就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的可以得出它在任何情况下时间复杂度均是O(nlogn)。

空间复杂度

堆排序使用了常数空间，空间复杂度为O(1)。

稳定性

堆排序是不稳定的。

希尔排序（Shell Sort）

基本思想

1959年Shell发明，第一个突破O(n²)的排序算法，是直接插入排序的改进版。它与直接插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

算法描述

先将整个待排元素序列分割成 gap 个增量为 gap 的子序列（每个子序列由位置相差为 gap 的元素组成，整个序列正好分割成 gap 个子序列，每个序列中有 n / gap 个元素）分别进行直接插入排序，然后缩减增量为之前的一半再进行排序，待 gap == 1时，希尔排序就变成了直接插入排序。因为此时序列已经基本有序，直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的。gap初始值一般取 len / 2。

动图演示

/**
  * 希尔排序
  * @param nums
  * @return
  */
 public static int[] shellSort(int[] nums){
     int len = nums.length;
     if (len <= 1) return nums;
     int current, gap = len / 2;
     while(gap > 0){
         for (int i = gap; i < len; ++i){
             current = nums[i];
             int preIndex = i - gap;
             while(preIndex >= 0 && nums[preIndex] > current){
                 nums[preIndex + gap] = nums[preIndex];
                 preIndex -= gap;
             }
             nums[preIndex + gap] = current;
         }
         gap /= 2;
     }
     return nums;
 }

时间复杂度

希尔排序平均时间复杂度为O(nlogn)，最好时间复杂度为O(nlog2n)，最坏时间复杂度为O(nlog2n)。希尔排序的时间复杂度与增量序列的选取有关。

空间复杂度

希尔排序使用了常数空间，空间复杂度为O(1)

稳定性

由于相同的元素可能在各自的序列中插入排序，最后其稳定性就会被打乱，比如序列 2、4、1、2，所以希尔排序是不稳定的。

计数排序（Counting Sort）

基本思想

计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

算法描述

找出待排序的数组中最大和最小的元素；
统计数组中每个值为 i 的元素出现的次数，存入数组C的第i项；
对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
反向填充目标数组：将每个元素 i 放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

动图演示

代码实现

/**
    * 计数排序
    * @param nums
    * @return
    */
   public static int[] countingSort(int[] nums){
       if (nums.length <= 1) return nums;
       int bias, min = Integer.MIN_VALUE, max = Integer.MAX_VALUE;
       for (int i = 0; i < nums.length; ++i){
           min = Math.min(min, nums[i]);
           max = Math.max(max, nums[i]);
       }
       // 计算偏移量，将 min ~ max 映射到 bucket 数组的 0 ~ (max - min) 位置上
       bias = -min;
       int[] bucket = new int[max - min + 1];
       Arrays.fill(bucket, 0);
       for (int i = 0; i < nums.length; ++i){
           bucket[bucket[i] + bias]++;
       }
       int index = 0, i = 0;
       while(index < nums.length){
           if (bucket[i] != 0){
               nums[index] = i - bias;
               bucket[i]--;
               index++;
           } else {
               i++;
           }
       }
       return nums;
   }

时间复杂度

计数排序平均时间复杂度为O(n + k)，最好时间复杂度为O(n + k)，最坏时间复杂度为O(n + k)。n 为遍历一趟数组计数过程的复杂度，k 为遍历一趟桶取出元素过程的复杂度。

空间复杂度

计数排序空间复杂度为O(k)，k为桶数组的长度。

稳定性

计数排序是稳定的。

桶排序（Bucket Sort）

基本思想

桶排序与计数排序很相似，不过现在的桶不单计数，是实实在在地放入元素。按照映射函数将数据分配到不同的桶里，每个桶内元素再分别排序（可能使用别的排序算法），最后拼接各个桶中排好序的数据。映射函数人为设计，但要保证桶 i 中的数均小于桶 j （i < j）中的数，即必须桶间必须有序，桶内可以无序，可以考虑按照数的区间范围划分桶。下面代码的桶映射函数为：(i - min) / arr.length。

算法描述

设置一个定量的数组当作空桶；
遍历输入数据，并且把数据一个一个放到对应的桶里去；
对每个不是空的桶的桶内元素进行排序（可以使用直接插入排序等）；
从不是空的桶里把排好序的数据拼接起来。

动图演示

代码实现

public static int[] bucketSort(int[] array){
    int max = Integer.MIN_VALUE;
    int min = Integer.MAX_VALUE;
    for(int i = 0; i < array.length; i++){
        max = Math.max(max, array[i]);
        min = Math.min(min, array[i]);
    }
    
    /*桶映射函数：自己设计，要保证桶 i 的数均小于桶 j （i < j）的数，
      即必须桶间必须有序，桶内可以无序。这里桶映射函数为：(i - min) / arr.length*/
    int bucketNum = (max - min) / array.length + 1;
    ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
    for(int i = 0; i < bucketNum; i++){
        bucketArr.add(new ArrayList<Integer>());
    }
    
    //将每个元素放入桶
    for(int i = 0; i < array.length; i++){
        int num = (array[i] - min) / (array.length);
        bucketArr.get(num).add(array[i]);
    }
    
    //对每个桶进行排序
    for(int i = 0; i < bucketArr.size(); i++){
        Collections.sort(bucketArr.get(i));
    }
    
   int k = 0;
   for(int i = 0; i < bucketArr.size(); i++){
      for(int j = 0;j < bucketArr.get(i).size();j++) {
           array[k++] = bucketArr.get(i).get(j);
      }
  }
  return array;
}

时间复杂度

桶排序平均时间复杂度为O(n + k)，最好时间复杂度为O(n + k)，最坏时间复杂度为O(n2)。

空间复杂度

桶排序空间复杂度为O(n + k)。

稳定性

桶排序是稳定的。

基数排序（Radix Sort）

基本思想

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

算法描述

取得数组中的最大数，并取得位数；
array 为原始数组，从最低位开始取每个位组成 radix 数组；

对 radix 进行计数排序（利用计数排序适用于小范围数的特点）；

动图演示

代码实现

    /**
     * 基数排序
     * @param array
     * @return
     */
public static int[] RadixSort(int[] array) {
     if (array == null || array.length < 2)
        return array;
        // 1.先算出最大数的位数；
    int max = Integer.MIN_VALUE;
    for (int i = 0; i < array.length; i++) {
            max = Math.max(max, array[i]);
    }
    int maxDigit = 0;
    while (max != 0) {
            max /= 10;
            maxDigit++;
    }
    int div = 1;
    ArrayList<ArrayList<Integer>> bucketList = new ArrayList<ArrayList<Integer>>();
    for (int i = 0; i < 10; i++)
        bucketList.add(new ArrayList<Integer>());
        //2.进行maxDigit趟分配
    for (int i = 0; i < maxDigit; i++,div *= 10) {
            for (int j = 0; j < array.length; j++) {
                int num = (array[j] / div) % 10;
                bucketList.get(num).add(array[j]);
            }
        //3.收集
            int index = 0;
            for (int j = 0; j < bucketList.size(); j++) {
                for (int k = 0; k < bucketList.get(j).size(); k++)
                    array[index++] = bucketList.get(j).get(k);
                bucketList.get(j).clear();
            }
   }
   return array;
}

时间复杂度

基数排序平均时间复杂度为O(n * k)，最好时间复杂度为O(n * k)，最坏时间复杂度为O(n * k)。

空间复杂度

基数排序空间复杂度为O(n + k)。

稳定性

基数排序是稳定的。

简单选择排序（Selection Sort）

基本思想

简单选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

算法描述

n个记录的简单选择排序可经过(n-1)趟简单选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1..n]，有序区为空；
第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R[i..n]。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
(n-1)趟结束，数组有序化了。

动图演示

代码实现

public static int[] selectionSort(int[] array) {
        if (array.length <= 1)
             return array;
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            for (int j = i; j < array.length; j++) {
                if (array[j] < array[minIndex]) //找到最小的数
                    minIndex = j; //将最小数的索引保存
            }
            int temp = array[minIndex]; //将最小数和无序区的第一个数交换
            array[minIndex] = array[i];
            array[i] = temp;
        }
        return array;
    }

时间复杂度

简单选择排序平均时间复杂度为O(n2)，最好时间复杂度为O(n2)，最坏时间复杂度为O(n2)。

最好情况：如果待排序元素本来是正序的，则移动元素次数为 0，但需要进行 n * (n - 1) / 2 次比较。

最坏情况：如果待排序元素中第一个元素最大，其余元素从小到大排列，则仍然需要进行 n * (n - 1) / 2 次比较，且每趟排序都需要移动 3 次元素，即移动元素的次数为3 * (n - 1)次。需要注意的是，简单选择排序过程中需要进行的比较次数与初始状态下待排序元素的排列情况无关。

空间复杂度
简单选择排序使用了常数空间，空间复杂度为O(1)

稳定性
简单选择排序不稳定，比如序列 2、4、2、1，我们知道第一趟排序第 1 个元素 2 会和 1 交换，那么原序列中 2 个 2 的相对前后顺序就被破坏了，所以简单选择排序不是一个稳定的排序算法.

参考

一文搞定十大经典排序算法（Java实现）

堆排序

十大经典排序算法（Java实现）

排序算法概述

定义

分类

比较

相关概念

各算法原理及实现

直接插入排序（Insertion Sort）

冒泡排序（Bubble Sort）

快速排序（Quick Sort）

归并排序（Merge Sort）

堆排序（Heap Sort）

希尔排序（Shell Sort）

计数排序（Counting Sort）

桶排序（Bucket Sort）

基数排序（Radix Sort）

简单选择排序（Selection Sort）

参考