本文作者：sytyale，另外一个聪明好学的同事

'茴' 字的十种写法

1、术语说明

名词	描述
稳定	如果 原本在 前面且 ，排序之后 仍然在 的前面
不稳定	如果 原本在 前面且 ，排序之后 可能会出现在 的后面
内排序	所有排序操作都在内存中完成
外排序	由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行
时间复杂度	一个算法执行所耗费的时间
空间复杂度	运行完一个程序所需内存的大小

2、特性表格

排序算法	平均时间	最好时间	最坏时间	空间复杂度	排序方式	稳定性
冒泡排序					In-place	稳定
选择排序					In-place	不稳定
插入排序					In-place	稳定
希尔排序					In-place	不稳定
归并排序					Out-place	稳定
快速排序					In-place	不稳定
堆排序					In-place	不稳定
计数排序					Out-place	稳定
基数排序					Out-place	稳定
桶排序					Out-place	稳定

• n: 数据规模
• k: '桶' 的个数
• In-place: 占用常数内存，不占用额外内存
• Out-place: 占用额外内存

3、分类

​ 常见的冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序 等属于比较排序 。即元素需要和其他元素比较才能确定自己的位置 。

​ 在冒泡排序、选择排序、插入排序之类的排序中，问题规模为，又因为需要比较次，所以平均时间复杂度为。在归并排序、快速排序、堆排序之类的排序中，问题规模通过分治法消减为次，所以时间复杂度平均。

​ 比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。可以说，比较排序适用于一切需要排序的情况。

​ 计数排序、基数排序、桶排序则属于非比较排序 。非比较排序是通过确定每个元素之前有多少个元素来排序。针对数组 ，计算 之前有多少个元素，则唯一确定了 在排序后数组中的位置 。

​ 非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度。

​ 非比较排序时间复杂度底，但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。

4、详解

4.1、Bubble Sort (冒泡排序)

4.1.1、算法原理

​ 冒泡排序是一种简单的排序算法。它遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。当所有元素顺序都正确则认为该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

4.1.2、算法描述(从小到大排序)

• 步骤1: 从第一个元素开始依次每次比较两个元素的值，如果前者大于后者则交换位置

• 步骤2: 第一次循环完成后最大的元素在最后面,记录已循环的次数(末尾已确定顺序的长度)

• 步骤3: 循环步骤1，每次循环到已确定的末尾(第i次循环比较到倒数第i+1个元素即可结束)

• 步骤4: 循环直到倒数第i+1个元素即为正数第二个元素时(从第二个开始后面已经全部排序)，排序结束

4.1.3、动图示例

4.1.4、代码示例

    /**
     * 冒泡排序
     *
     * @param array 目标数组
     * @return 排序后的数组
     */
    public static int[] bubbleSort(int[] array) {
        if (array == null || array.length == 0) {
            return array;
        }
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] < array[j]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }

4.1.5、算法分析

• 最佳情况：。优化算法，一次循环结束没有发生任何元素交换则直接结束

• 最差情况：

• 平均情况：

4.2、Selection Sort (选择排序)

4.2.1、算法原理

​ 选择排序是表现最稳定的排序算法之一 ，因为无论什么数据进去都是的时间复杂度 ，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

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

4.2.2、算法描述(从小到大)

• 步骤1：无序区为R[1…n]，有序区为空

• 步骤2：第i趟排序(i=1,2,3…n-1)开始时，从无序区找到最小的元素放到有序区的末尾

• 步骤3：n-1趟结束，数组有序化，排序结束

4.2.3、动图示例

4.2.4、代码示例

    /**
     * 选择排序
     *
     * @param array 目标数组
     * @return 排序后的数组
     */
    public static int[] selectionSort(int[] array) {
        if (array.length == 0) {
            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;
    }

4.2.5、算法分析

• 最佳情况：

• 最差情况：

• 平均情况：

4.3、Insertion Sort (插入排序)

4.3.1、算法原理

​ 插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到 的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

4.3.2、算法描述(从小到大)

步骤1: 从第一个元素开始，该元素可以认为已经被排序

步骤2: 取出下一个元素，依次对比已排序序列的元素，将该元素插入已排序序列中第一个比其大的元素前

步骤3:循环步骤2直到全部元素都已经插入已排序集合，排序结束

4.3.3、动图示例

4.3.4、代码示例

    /**
     * 插入排序
     *
     * @param array 目标数组
     * @return 排序后的数组
     */
    public static int[] insertionSort(int[] array) {
        if (array.length == 0) {
            return array;
        }
        int current;
        for (int i = 0; i < array.length - 1; i++) {
            current = array[i + 1];
            int preIndex = i;
            while (preIndex >= 0 && current < array[preIndex]) {
                array[preIndex + 1] = array[preIndex];
                preIndex--;
            }
            array[preIndex + 1] = current;
        }
        return array;
    }

4.3.5、算法分析

• 最佳情况： .数据已经有序时,所有数据都比前一个数据大

• 最坏情况：

• 平均情况：

4.4、Shell Sort(希尔排序)

4.4.1、算法原理

​ 希尔排序是 Donald Shell 于1959年提出的一种排序算法。希尔排序是简单插入排序经过改进后的一个更高效版本，也称为缩小增量排序，同时该算法是冲破 的第一批算法之一。它与插入排序的不同之处在于它会优先比较距离较远的元素。

​ 希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 时，整个文件恰被分成一组，算法便终止。

4.4.2、算法描述

​ 先选择增量，后续以的方式持续缩小增量，这种增量选择我们可以用一个序列来表示即，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。

• 步骤1：定义一个增量序列，其中 且 ，序列长度即为排序的次数

• 步骤2：按增量序列个数k，对序列进行k 趟排序；

• 步骤3：每趟排序，根据对应的增量，将待排序列分割成若干长度为的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

4.4.3、算法动图

4.4.4、代码示例

    /**
     * 希尔排序
     *
     * @param array 目标数组
     * @return 排序后的数组
     */
    public static int[] shellSort(int[] array) {
        int len = array.length;
        int temp, gap = len / 2;
        while (gap > 0) {
            for (int i = gap; i < len; i++) {
                temp = array[i];
                int preIndex = i - gap;
                while (preIndex >= 0 && array[preIndex] > temp) {
                    array[preIndex + gap] = array[preIndex];
                    preIndex -= gap;
                }
                array[preIndex + gap] = temp;
            }
            gap /= 2;
        }
        return array;
    }

4.4.5、算法分析

• 最佳情况：
• 最坏情况：
• 平均情况：

4.5、Merge Sort(归并排序)

4.5.1、算法原理

​ 同选择排序，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 的时间复杂度。代价是需要额外的内存空间。

​ 归并排序是建立在归并操作上的一种稳定排序算法，是采用分治法（Divide and Conquer）的典型的应用。核心是每次将子序列排序，然后将有序子序列再合并排序，直到全部有序。

4.5.2、算法描述(2-路归并)

• 2-路归并:将两个有序表合并成一个有序表

• 步骤1：把长度为 的输入序列分成两个长度为的子序列

• 步骤2：对这两个子序列分别采用归并排序

• 步骤3：将两个排序好的子序列合并成一个最终的排序序列

4.5.3、算法动图

4.5.4、代码示例

    /**
     * 归并排序
     *
     * @param array 目标数组
     * @return 排序后的数组
     */
    public static 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 static int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        for (int index = 0, i = 0, j = 0; index < result.length; index++) {
            if (i >= left.length) {
                result[index] = right[j++];
            } else if (j >= right.length) {
                result[index] = left[i++];
            } else if (left[i] > right[j]) {
                result[index] = right[j++];
            } else {
                result[index] = left[i++];
            }
        }
        return result;
    }

4.5.5、算法分析

• 最佳情况：
• 最差情况：
• 平均情况：

4.6、Quick Sort(快速排序)

4.6.1、算法原理

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

4.6.2、算法描述(从小到大)

• 步骤1：从数列中挑出一个元素，称为“基准”(pivot)
• 步骤2：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面。这个称为分区（partition）操作
• 步骤3：递归将基准两边的数列排序

4.6.3、算法动图

4.6.4、代码示例

    /**
     * 快速排序
     *
     * @param array 目标数组
     * @param start 需要排序的下标起点,以 0 开始
     * @param end   需要排序的下标起点,以 array.length-1 开始
     * @return 排序后的数组
     */
    public static int[] quickSort(int[] array, int start, int end) {
        if (array == null || start < 0 || end >= array.length || start > end) {
            return null;
        }
        int smallIndex = partition(array, start, end);
        if (smallIndex > start) {
            quickSort(array, start, smallIndex - 1);
        }
        if (smallIndex < end) {
            quickSort(array, smallIndex + 1, end);
        }
        return array;
    }
    
    /**
     * partition 算法
     *
     * @param array 目标数组
     * @param start 需要排序的下标起点,以 0 开始
     * @param end   需要排序的下标起点,以 array.length-1 开始
     * @return 标杆元素下标
     */
    private static int partition(int[] array, int start, int end) {
        int pivot = (int) (start + Math.random() * (end - start + 1));
        int smallIndex = start - 1;
        swap(array, pivot, end);
        for (int i = start; i <= end; i++) {
            if (array[i] <= array[end]) {
                smallIndex++;
                if (i > smallIndex) {
                    swap(array, i, smallIndex);
                }
            }
        }
        return smallIndex;
    }
    
    /**
     * 交换数组内两个元素
     *
     * @param array 待交换元素的数组
     * @param i     待交换的元素下标
     * @param j     待交换的元素下标
     */
    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

4.6.5、算法分析

• 最佳情况：
• 最差情况：
• 平均情况：

4.7、Heap Sort(堆排序)

4.7.1、算法原理

​ 堆排序是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。即堆的根节点要么最大要么最小。

4.7.2、算法描述(从小到大)

• 步骤1：构建一个堆
• 步骤2：将堆调整为最大堆-即最大值在根节点(第一个节点)
• 步骤3：将最大值(第一个节点)和最后一个未排序的节点交换位置
• 步骤4：循环上述步骤2和步骤3直到未排序的元素只剩一个，排序结束

4.7.3、算法动图

4.7.4、代码示例

    /**
     * 堆排序算法
     *
     * @param array 目标数组
     * @return 排序后的数组
     */
    public static int[] heapSort(int[] array) {
        int len = array.length;
        if (len < 1) {
            return array;
        }
        buildMaxHeap(array, len);
        while (len > 0) {
            swap(array, 0, len - 1);
            len--;
            adjustHeap(array, 0, len);
        }
        return array;
    }
    
    /**
     * 建立最大堆
     * <p>
     * 从最后一个非叶子节点开始调整全部的非叶子节点，保证全部非叶子节点一定比其子节点大
     * <p>
     * 从最后一个非叶子节点开始向上构造最大堆,i的左子树和右子树分别2i+1和2(i+1),
     *
     * @param array 待排序的数组
     * @param len   需要构建堆的元素个数,从 array[0] 到 array[len-1]
     */
    public static void buildMaxHeap(int[] array, int len) {
        for (int i = (len / 2 - 1); i >= 0; i--) {
            adjustHeap(array, i, len);
        }
    }
         
    /**
     * 调整使节点一定比子节点大,如果本节点比子节点小,需要交换位置,
     * 并递归该子节点重新保证该子节点比其子节点大
     *
     * @param array 待排序的数组
     * @param i     当前节点的下标
     * @param len   剩余堆元素个数,限制调整的数组范围从 array[0] 到 array[len-1]
     */
    private static void adjustHeap(int[] array, int i, int len) {
        int maxIndex = i;
        //如果有左子树，且左子树大于父节点，则将最大指针指向左子树
        if (i * 2 + 1 < len && array[i * 2 + 1] > array[maxIndex]) {
            maxIndex = i * 2 + 1;
        }
        //如果有右子树，且右子树大于父节点，则将最大指针指向右子树
        if (i * 2 + 2 < len && array[i * 2 + 2] > array[maxIndex]) {
            maxIndex = i * 2 + 2;
        }
        //如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。
        if (maxIndex != i) {
            swap(array, maxIndex, i);
            adjustHeap(array, maxIndex, len);
        }
    }
    
    /**
     * 交换数组内两个元素
     *
     * @param array 待交换元素的数组
     * @param i     待交换的元素下标
     * @param j     待交换的元素下标
     */
    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

4.7.5、算法分析

• 最佳情况：
• 最差情况：
• 平均情况：

4.8、Counting Sort(计数排序)

4.8.1、算法原理

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

​ 计数排序是一种稳定的排序算法。其使用一个额外的数组C，其中第个元素是待排序数组A中值等于的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

4.8.2、算法描述(从小到大)

• 步骤1：找出待排序的数组中最大和最小值
• 步骤2：构建统计数组，第一个下标对应最小值，最后一个下标对应最大值，所有值都初始为
• 步骤3：循环将待排序数组的值映射成下标 则在统计数组中下标为 的值加
• 步骤4：遍历统计数组将全部元素放回原数组

4.8.3、算法动图

4.8.4、代码示例

    /**
     * 计数排序
     *
     * @param array 待排序数组
     * @return 有序数组
     */
    public static int[] countingSort(int[] array) {
        if (array.length == 0) {
            return array;
        }
        int min = array[0], max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
            if (array[i] < min) {
                min = array[i];
            }
        }
        int[] bucket = new int[max - min + 1];
        for (int value : array) {
            bucket[value - min]++;
        }
        // index 原数组下标, i 统计数组下标
        int index = 0;
        for (int i = 0; i < bucket.length; i++) {
            for (int j = 0; j < bucket[i]; j++) {
                array[index] = i + min;
                index++;
            }
        }
        return array;
    }

4.8.5、算法分析

​ 当输入的元素是 个 到 之间的整数时，它的运行时间是 。计数排序不是比较排序，速度快于任何比较排序。由于用来计数的数组C的长度取决于待排序数组中数据的范围，这使得计数排序对于数据范围很大的数组，需要大量时间和内存。

• 最佳情况：
• 最差情况：
• 平均情况：

4.9、Bucket Sort(桶排序)

4.9.1、算法原理

​ 桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。 ​ 假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序(可能另选合适的排序算法)

4.9.2、算法描述(从小到大)

• 步骤1：人为设置一个，作为每个桶所能放置多少个不同数值（例如当时，该桶可以存放 这几种数字，但是容量不限，即可以存放 个 ）
• 步骤2：遍历输入数据把数据依次放到对应的桶里去
• 步骤3：对每个不是空的桶进行排序，可以选用其它排序，也可以递归使用桶排序(每个桶再分成多个桶)
• 步骤4：从不是空的桶里把排好序的数据拼接起来，全部已排序桶拼接完成则排序结束

4.9.3、算法动图

4.9.4、代码示例

  /**
     * 桶排序
     * 
     * @param array      待排序数组
     * @param bucketSize 桶中元素个数
     * @return 有序集合
     */
    public static List<Integer> bucketSort(List<Integer> array, int bucketSize) {
        if (array == null || array.size() < 2) {
            return array;
        }
        int max = array.get(0), min = array.get(0);
        for (Integer integer : array) {
            if (integer > max) {
                max = integer;
            }
            if (integer < min) {
                min = integer;
            }
        }
        int bucketCount = (max - min) / bucketSize + 1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount);
        ArrayList<Integer> resultArr = new ArrayList<>();
        for (int i = 0; i < bucketCount; i++) {
            bucketArr.add(new ArrayList<>());
        }
        for (Integer integer : array) {
            bucketArr.get((integer - min) / bucketSize).add(integer);
        }
        for (int i = 0; i < bucketCount; i++) {
            if (bucketSize == 1) {
                resultArr.addAll(bucketArr.get(i));
            } else {
                if (bucketCount == 1) {
                    bucketSize--;
                }
                resultArr.addAll(bucketSort(bucketArr.get(i), bucketSize));
            }
        }
        return resultArr;
    }

4.9.5、算法分析

• 最佳情况：
• 最差情况：
• 平均情况：

4.x、Radix Sort(基数排序)

4.x.1、算法原理

​ 基数排序也是非比较的排序算法，对每一位进行排序，从最低位开始排序，复杂度为,为数组长度，为数组中的数的最大的位数；

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

​ 基数排序有两种方法：MSD 从高位开始进行排序、LSD 从低位开始进行排序

4.x.2、算法描述

• 步骤1：取得数组中的最大数，并取得位数
• 步骤2：arr为原始数组，从最低位开始取每个位组成radix数组
• 步骤3：对radix进行计数排序（利用计数排序适用于小范围数的特点）

4.x.3、算法动图

4.x.4、代码示例

    /**
     * 基数排序
     *
     * @param array 待排序的数组
     * @return 排序后的数组
     */
    public static int[] radixSort(int[] array) {
        if (array == null || array.length < 2) {
            return array;
        }
        // 1.先算出最大数的位数；
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            max = Math.max(max, array[i]);
        }
        int maxDigit = 0;
        while (max != 0) {
            max /= 10;
            maxDigit++;
        }
        int mod = 10, div = 1;
        ArrayList<ArrayList<Integer>> bucketList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            bucketList.add(new ArrayList<>());
        }
        for (int i = 0; i < maxDigit; i++, mod *= 10, div *= 10) {
            for (int value : array) {
                int num = (value % mod) / div;
                bucketList.get(num).add(value);
            }
            int index = 0;
            for (ArrayList<Integer> integers : bucketList) {
                for (Integer integer : integers) {
                    array[index++] = integer;
                }
                integers.clear();
            }
        }
        return array;
    }

4.x.5、算法分析

• 最佳情况：
• 最差情况：
• 平均情况：

查看更多文章关注公众号：好奇心森林