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

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

排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。在这里简单的记录一下十大经典排序算法，也以此为笔记方便日后拾起…

声明：部分代码来源JavaGuide

简介

排序算法分为内部排序和外部排序：

内部排序：数据记录在内存中进行排序

外部排序：因数据量过大，不能一次容纳全部的排序记录，在排序过程中需要访问外存

我们介绍的排序算法都为内部排序：

名词解释：

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

术语说明:

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

十种常见排序算法可以分类两大类别：比较类排序和非比较类排序。

常见的快速排序、归并排序、堆排序以及冒泡排序等都属于比较类排序算法。比较类排序是通过比较来决定元素间的相对次序，由于其时间复杂度不能突破 O(nlogn)，因此也称为非线性时间比较类排序。在冒泡排序之类的排序中，问题规模为 n，又因为需要比较 n 次，所以平均时间复杂度为 O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为 logn 次，所以时间复杂度平均 O(nlogn)。

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

而计数排序、基数排序、桶排序则属于非比较类排序算法。非比较排序不通过比较来决定元素间的相对次序，而是通过确定每个元素之前，应该有多少个元素来排序。由于它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。 非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度 O(n)。

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

1、冒泡排序（Bubble Sort）

冒泡排序是我们大多数人接触的第一种排序算法，它重复的遍历要排序的序列，依次比较两个元素，如果他们的顺序与所给条件不符合，就将他们的顺序调换过来。这个算法的名字由来是因为越小的元素会经由交换慢慢 “浮” 到数列的顶端。

1.1 算法步骤

1. 比较相邻元素，如果第一个比第二个大，就交换他们的位置；
2. 对每一对相邻的元素做相同的动作，从开始的第一对到结尾的最后一对，如此这般，最后的元素就会是最大的数；
3. 除了最后一个元素，针对所有元素重复以上步骤

1.2 算法图解

1.3 代码实现

/**
     * 1.冒泡排序: 设置flag目的是将算法的最佳时间复杂度优化为 O(n)，
     *            即当原输入序列就是排序好的情况下，该算法的时间复杂度就是 O(n)。
     *            这种情况优化了外排序，只执行了一次内排序
     * @param arr 需要排序的数组
     * @return 排序后的数组
     */
    public static int[] bubbleSort(int[] arr){

        for (int i = 1; i < arr.length; i++) {

            boolean flag = true; //每次遍历标志位都要先置为0，才能判断后面的元素是否发生了交换
            for (int j = 0; j < arr.length - i; j++) {
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = false; //只要有发生了交换，flag就置为1
                }
            }
            if(flag){
                break;
            }
            System.out.println("第"+ i +"次排序过程:"+ Arrays.toString(arr));
        }
        return arr;
    }

此处对代码做了一个小优化，加入了 Flag，目的是将算法的最佳时间复杂度优化为 O(n)，即当原输入序列就是排序好的情况下，该算法的时间复杂度就是 O(n)。

1.4 排序过程

原始数据:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
第1次排序过程:[3, 38, 5, 44, 15, 36, 26, 27, 2, 46, 4, 19, 47, 48, 50]
第2次排序过程:[3, 5, 38, 15, 36, 26, 27, 2, 44, 4, 19, 46, 47, 48, 50]
第3次排序过程:[3, 5, 15, 36, 26, 27, 2, 38, 4, 19, 44, 46, 47, 48, 50]
第4次排序过程:[3, 5, 15, 26, 27, 2, 36, 4, 19, 38, 44, 46, 47, 48, 50]
第5次排序过程:[3, 5, 15, 26, 2, 27, 4, 19, 36, 38, 44, 46, 47, 48, 50]
第6次排序过程:[3, 5, 15, 2, 26, 4, 19, 27, 36, 38, 44, 46, 47, 48, 50]
第7次排序过程:[3, 5, 2, 15, 4, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
第8次排序过程:[3, 2, 5, 4, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
第9次排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
排序后的数组为:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

1.5 算法分析

• 稳定性：稳定排序
• 时间复杂度：
  • 最佳：O(n)
  • 最差：O(n^2)
  • 平均：O(n^2)
• 空间复杂度：O(1)
• 排序方式：In-place

1.6 应用场景

使用最简单，适用于数据量很小的排序场景。

1、数据库查询

冒泡排序可用于对数据库中的数据进行排序，对于小规模数据集，冒泡排序的速度也足够快。

2、数字图像处理

冒泡排序可用于处理数字图像中的像素点，比如对像素点的灰度值进行排序，从而得到更清晰、更准确的图像。

3、传感器数据采集

在传感器采集的数据中，可能会出现一些异常点或者噪声，使用冒泡排序可以将这些异常值筛选出来，并快速进行处理。

4、从高到低列队

生活中，我们在集体活动中站队时，名列前茅次站队由于没有固定的位置，往往是大家先随便站成一排，然后再通过换位置的方式逐步形成高矮顺序，这里主要是冒泡的思想。

2、选择排序（Selection Sort）

选择排序的适用于大多数排序场景，它的好处就是不占用额外的内存空间。它的工作原理就是：首先在未排序序列中找到最小（大）的元素，存放在排序序列的起始位置，然后再从剩余未排序的序列中继续寻找最小（大）的元素排在已排序序列的末尾，以此类推，直至排序完毕。

2.1 算法步骤

1. 在未排序序列中寻找最小（大）元素，存放在排序序列起始位置；
2. 再从剩余未排序的序列中继续寻找最小（大）的元素排在已排序序列的末尾；
3. 重复2步骤，直至排序结束；

2.2 算法图解

2.3 代码实现

/**
     * 2.选择排序
     *
     * @param arr 需要排序的数组
     * @return 排序后的数组
     */
    public static int[] selectionSort(int[] arr){
        int Count = 1;
        for (int i = 0; i < arr.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[j] < arr[minIndex]){
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                int tmp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = tmp;
            }
            System.out.println("第"+ Count++ +"次排序过程:"+ Arrays.toString(arr));
        }
        return arr;
    }

2.4 排序过程

原始数据:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
第1次排序过程:[2, 44, 38, 5, 47, 15, 36, 26, 27, 3, 46, 4, 19, 50, 48]
第2次排序过程:[2, 3, 38, 5, 47, 15, 36, 26, 27, 44, 46, 4, 19, 50, 48]
第3次排序过程:[2, 3, 4, 5, 47, 15, 36, 26, 27, 44, 46, 38, 19, 50, 48]
第4次排序过程:[2, 3, 4, 5, 47, 15, 36, 26, 27, 44, 46, 38, 19, 50, 48]
第5次排序过程:[2, 3, 4, 5, 15, 47, 36, 26, 27, 44, 46, 38, 19, 50, 48]
第6次排序过程:[2, 3, 4, 5, 15, 19, 36, 26, 27, 44, 46, 38, 47, 50, 48]
第7次排序过程:[2, 3, 4, 5, 15, 19, 26, 36, 27, 44, 46, 38, 47, 50, 48]
第8次排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 44, 46, 38, 47, 50, 48]
第9次排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 44, 46, 38, 47, 50, 48]
第10次排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 46, 44, 47, 50, 48]
第11次排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 50, 48]
第12次排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 50, 48]
第13次排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 50, 48]
第14次排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
第15次排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
排序后的数组为:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

2.5 算法分析

• 稳定性：不稳定排序
• 时间复杂度：
  • 最佳：O(n^2)
  • 最差：O(n^2)
  • 平均：O(n^2)
• 空间复杂度：O(1)
• 排序方式：In-place

2.6 应用场景

选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多（n-1)次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。原地操作几乎是选择排序的唯一优点，当空间复杂度要求较高时，可以考虑选择排序。其次就是在检查给定的列表是否已经排序时可以适用该算法。

3、插入排序（Insertion Sort）

插入排序就像我们打扑克牌的时候，拿着一张扑克牌时，从后向前扫描大小，从而为这张扑克牌“插入”一个合适的位置以达到构建一个有序序列的目的。插入排序对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用 in-place 排序（即只需用到 O(1) 的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

3.1 算法步骤

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

3.2 算法图解

3.3 代码实现

 /**
     * 3.插入排序
     *
     * @param arr 需要排序的数组
     * @return 排序后的数组
     */
    public static int[] insertionSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            int current = arr[i];
            int preIndex = i - 1;
            while(preIndex >= 0 && current < arr[preIndex]){
                arr[preIndex+1] = arr[preIndex];
                preIndex -= 1;
            }
            arr[preIndex+1] = current;
            System.out.println("第"+ i +"次排序过程:"+ Arrays.toString(arr));
        }
        return arr;
    }

3.4 排序过程

原始数据:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
第1次排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
第2次排序过程:[3, 38, 44, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
第3次排序过程:[3, 5, 38, 44, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
第4次排序过程:[3, 5, 38, 44, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
第5次排序过程:[3, 5, 15, 38, 44, 47, 36, 26, 27, 2, 46, 4, 19, 50, 48]
第6次排序过程:[3, 5, 15, 36, 38, 44, 47, 26, 27, 2, 46, 4, 19, 50, 48]
第7次排序过程:[3, 5, 15, 26, 36, 38, 44, 47, 27, 2, 46, 4, 19, 50, 48]
第8次排序过程:[3, 5, 15, 26, 27, 36, 38, 44, 47, 2, 46, 4, 19, 50, 48]
第9次排序过程:[2, 3, 5, 15, 26, 27, 36, 38, 44, 47, 46, 4, 19, 50, 48]
第10次排序过程:[2, 3, 5, 15, 26, 27, 36, 38, 44, 46, 47, 4, 19, 50, 48]
第11次排序过程:[2, 3, 4, 5, 15, 26, 27, 36, 38, 44, 46, 47, 19, 50, 48]
第12次排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 50, 48]
第13次排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 50, 48]
第14次排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
排序后的数组为:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

3.5 算法分析

• 稳定性：稳定排序
• 时间复杂度：
  • 最佳：O(n)
  • 最差：O(n^2)
  • 平均：O(n^2)
• 空间复杂度：O(1)
• 排序方式：In-place

3.6 应用场景

1. 当输入规模n比较小的时候，应该使用选择排序或者时插入排序（插入排序通常会比选择排序少一些比较的次数，但是选择排序会比插入排序少挪动的次数）；
2. 插入排序适用于已有部分数据有序的情况，有序部分越大越好

4、希尔排序（Shell Sort）

希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为递减增量排序算法，同时该算法是冲破 O(n²) 的第一批算法之一。

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录 “基本有序” 时，再对全体记录进行依次直接插入排序。

4.1 算法步骤

我们选择增量 gap=length/2，缩小增量继续以 gap = gap/2 的方式，这种增量选择我们可以用一个序列来表示，{n/2, (n/2)/2, ..., 1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

• 选择一个增量序列 {t1, t2, …, tk}，其中 (ti>tj, i<j, tk=1)；
• 按增量序列个数 k，对序列进行 k 趟排序；
• 每趟排序，根据对应的增量 t，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

4.2 算法图解

4.3 代码实现

/**
     * 4.希尔排序
     *
     * @param arr 需要排序的数组
     * @return 排序后的数组
     */
    public static int[] shellSort(int[] arr){
        int n = arr.length;
        int gap = n / 2;
        int Count = 1;
        while (gap > 0){
            for (int i = gap; i < n; i++) {
                int current = arr[i];
                int preIndex = i - gap;
                while(preIndex >= 0 && current < arr[preIndex]){
                    arr[preIndex+gap] = arr[preIndex];
                    preIndex -= gap;
                }
                arr[preIndex+gap] = current;
            }
            gap /= 2;
            System.out.println("第"+ Count++ +"次排序过程:"+ Arrays.toString(arr));
        }
        return arr;
    }

4.4 排序过程

原始数据:[6, 4, 5, 7, 2, 8, 3, 0, 9, 1]
第1次排序过程:[6, 3, 0, 7, 1, 8, 4, 5, 9, 2]
第2次排序过程:[0, 2, 1, 3, 4, 5, 6, 7, 9, 8]
第3次排序过程:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
排序后的数组为:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

4.5 算法分析

• 稳定性：不稳定排序
• 时间复杂度：
  • 最佳：O(nlogn)
  • 最差：O(n^2)
  • 平均：O(nlogn)
• 空间复杂度：O(1)
• 排序方式：In-place

5、归并排序（Merge Sort）

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

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

5.1 算法步骤

归并排序算法是一个递归过程，边界条件为当输入序列仅有一个元素时，直接返回，具体过程如下：

1. 如果输入内只有一个元素，则直接返回，否则将长度为 n 的输入序列分成两个长度为 n/2 的子序列；
2. 分别对这两个子序列进行归并排序，使子序列变为有序状态；
3. 设定两个指针，分别指向两个已经排序子序列的起始位置；
4. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间（用于存放排序结果），并移动指针到下一位置；
5. 重复步骤 3 ~4 直到某一指针达到序列尾；
6. 将另一序列剩下的所有元素直接复制到合并序列尾。

5.2 算法图解

5.3 代码实现

 /**
     * 5.归并排序
     *
     * @param arr 需要排序的数组
     * @return 排序后的数组
     */
    public static int[] mergeSort(int[] arr) {
        if (arr.length <= 1) {
            return arr;
        }
        int middle = arr.length / 2;
        int[] arr_1 = Arrays.copyOfRange(arr, 0, middle);
        int[] arr_2 = Arrays.copyOfRange(arr, middle, arr.length);
        return merge(mergeSort(arr_1), mergeSort(arr_2));
    }

    /**
     * 合并两个数组
     *
     * @param arr_1 分组后的数组1
     * @param arr_2 分组后的数组2
     * @return sorted_arr
     */
    public static int[] merge(int[] arr_1, int[] arr_2) {
        int[] sorted_arr = new int[arr_1.length + arr_2.length];
        int idx = 0, idx_1 = 0, idx_2 = 0;
        while (idx_1 < arr_1.length && idx_2 < arr_2.length) {
            if (arr_1[idx_1] < arr_2[idx_2]) {
                sorted_arr[idx] = arr_1[idx_1];
                idx_1 += 1;
            } else {
                sorted_arr[idx] = arr_2[idx_2];
                idx_2 += 1;
            }
            idx += 1;
        }
        if (idx_1 < arr_1.length) {
            while (idx_1 < arr_1.length) {
                sorted_arr[idx] = arr_1[idx_1];
                idx_1 += 1;
                idx += 1;
            }
        } else {
            while (idx_2 < arr_2.length) {
                sorted_arr[idx] = arr_2[idx_2];
                idx_2 += 1;
                idx += 1;
            }
        }
        System.out.println("排序过程:"+ Arrays.toString(sorted_arr));
        return sorted_arr;
    }

5.4 排序过程

原始数据:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[38, 44]
排序过程:[3, 38, 44]
排序过程:[5, 47]
排序过程:[15, 36]
排序过程:[5, 15, 36, 47]
排序过程:[3, 5, 15, 36, 38, 44, 47]
排序过程:[26, 27]
排序过程:[2, 46]
排序过程:[2, 26, 27, 46]
排序过程:[4, 19]
排序过程:[48, 50]
排序过程:[4, 19, 48, 50]
排序过程:[2, 4, 19, 26, 27, 46, 48, 50]
排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
排序后的数组为:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

5.5 算法分析

• 稳定性：稳定排序
• 时间复杂度：
  • 最佳：O(nlogn)
  • 最差：O(nlogn)
  • 平均：O(nlogn)
• 空间复杂度：O(n)
• 排序方式：Out-place

5.6 应用场景

在外排序中通常使用排序-归并的策略，外排序是指处理超过内存限度的数据的排序算法，通常将中间结果放在读写较慢的外存储器，如下分成两个阶段：

• 排序阶段：读入能够放进内存中的数据量，将其排序输出到临时文件，一次进行，将带排序数据组织为多个有序的临时文件
• 归并阶段：将这些临时文件组合为大的有序文件

例如，使用 100m 内存对 900m 的数据进行排序，过程如下：

• 读入 100m 数据内存，用常规方式排序
• 将排序后的数据写入磁盘
• 重复前两个步骤，得到 9 个 100m 的临时文件
• 将 100m 的内存划分为 10 份，将 9 份为输入缓冲区，第 10 份为输出缓冲区
• 进行九路归并排序，将结果输出到缓冲区
• 若输出缓冲区满，将数据写到目标文件，清空缓冲区
• 若缓冲区空，读入相应文件的下一份数据

若要求排序稳定，则可选用归并排序。

6、快速排序（Quick Sort）

快速排序用到了分治思想，同样的还有归并排序。乍看起来快速排序和归并排序非常相似，都是将问题变小，先排序子串，最后合并。不同的是快速排序在划分子问题的时候经过多一步处理，将划分的两组数据划分为一大一小，这样在最后合并的时候就不必像归并排序那样再进行比较。但也正因为如此，划分的不定性使得快速排序的时间复杂度并不稳定。

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

6.1 算法步骤

快速排序使用分治法open in new window（Divide and conquer）策略来把一个序列分为较小和较大的 2 个子序列，然后递回地排序两个子序列。具体算法描述如下：

1. 从序列中随机挑出一个元素，做为 “基准”(pivot)；
2. 重新排列序列，将所有比基准值小的元素摆放在基准前面，所有比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个操作结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3. 递归地把小于基准值元素的子序列和大于基准值元素的子序列进行快速排序。

6.2 算法图解

6.3 代码实现

/**
     * 6.快速排序
     * @param arr 待排序数组
     * @param low 起始位置(左)
     * @param high 起始位置(右)
     */
    public static void quickSort(int[] arr,int low,int high){
        int left,right,pivot,temp;
        if(low > high){
            return;
        }
        left = low;
        right = high;
        //pivot就是基准位
        pivot= arr[low];
 
        while (left < right) {
            //先看右边，依次往左递减
            while (pivot<= arr[right] && left < right) {
                right--;
            }
            //再看左边，依次往右递增
            while (pivot>= arr[left] && left < right) {
                left++;
            }
            //如果满足条件则交换
            if (left < right) {
                temp = arr[right];
                arr[right] = arr[left];
                arr[left] = temp;
            }
 
        }
        //最后将基准为与left和right相等位置的数字交换
         arr[low] = arr[left];
         arr[left] = pivot;
        //递归调用左半数组
        quickSort(arr, low, right-1);
        //递归调用右半数组
        quickSort(arr, right+1, high);
    }

6.4 排序过程

原始数据:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 48, 50]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 48, 50]
排序过程:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 48, 50]
排序过程:[3, 5, 38, 44, 47, 15, 36, 26, 27, 2, 46, 4, 19, 48, 50]
排序过程:[3, 5, 38, 44, 47, 15, 36, 26, 27, 2, 46, 4, 19, 48, 50]
排序过程:[3, 5, 15, 44, 47, 38, 36, 26, 27, 2, 46, 4, 19, 48, 50]
排序过程:[3, 5, 15, 44, 47, 38, 36, 26, 27, 2, 46, 4, 19, 48, 50]
排序过程:[3, 5, 15, 44, 47, 38, 36, 26, 27, 2, 46, 4, 19, 48, 50]
排序过程:[3, 5, 15, 44, 47, 38, 36, 26, 27, 2, 46, 4, 19, 48, 50]
排序过程:[3, 5, 15, 2, 47, 38, 36, 26, 27, 44, 46, 4, 19, 48, 50]
排序过程:[3, 5, 15, 2, 47, 38, 36, 26, 27, 44, 46, 4, 19, 48, 50]
排序过程:[3, 5, 15, 2, 4, 38, 36, 26, 27, 44, 46, 47, 19, 48, 50]
排序过程:[3, 5, 15, 2, 4, 19, 36, 26, 27, 44, 46, 47, 38, 48, 50]
排序过程:[3, 5, 15, 2, 4, 19, 36, 26, 27, 44, 46, 47, 38, 48, 50]
排序过程:[3, 5, 15, 2, 4, 19, 36, 26, 27, 44, 46, 47, 38, 48, 50]
排序过程:[3, 2, 15, 5, 4, 19, 36, 26, 27, 44, 46, 47, 38, 48, 50]
排序过程:[3, 2, 4, 5, 15, 19, 36, 26, 27, 44, 46, 47, 38, 48, 50]
排序过程:[2, 3, 4, 5, 15, 19, 36, 26, 27, 44, 46, 47, 38, 48, 50]
排序过程:[2, 3, 4, 5, 15, 19, 36, 26, 27, 44, 46, 47, 38, 48, 50]
排序过程:[2, 3, 4, 5, 15, 19, 36, 26, 27, 44, 46, 47, 38, 48, 50]
排序过程:[2, 3, 4, 5, 15, 19, 36, 26, 27, 44, 46, 47, 38, 48, 50]
排序过程:[2, 3, 4, 5, 15, 19, 36, 26, 27, 44, 46, 47, 38, 48, 50]
排序过程:[2, 3, 4, 5, 15, 19, 36, 26, 27, 44, 46, 47, 38, 48, 50]
排序过程:[2, 3, 4, 5, 15, 19, 36, 26, 27, 44, 46, 47, 38, 48, 50]
排序过程:[2, 3, 4, 5, 15, 19, 36, 26, 27, 38, 46, 47, 44, 48, 50]
排序过程:[2, 3, 4, 5, 15, 19, 26, 36, 27, 38, 46, 47, 44, 48, 50]
排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 46, 47, 44, 48, 50]
排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 46, 47, 44, 48, 50]
排序过程:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 47, 46, 48, 50]
排序后的数组为:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

6.5 算法分析

• 稳定性：**不稳定排序
• 时间复杂度：
  • 最佳：O(nlogn)
  • 最差：O(nlogn)
  • 平均：O(nlogn)
• 空间复杂度：O(nlogn)
• 排序方式：In-place

6.6 应用场景

1. 当输入的数据基本有序的时候，应该使用插入排序或者是随机的快速排序。
2. 当n较大，要求速度较快的时候可以使用nlgn的算法比如：堆排序、快速排序和归并排序。堆排序的空间复杂度为lO(1)、而快速排序的空间复杂度是O(logn)(递归使用栈的情况)，而归并排序的时间复杂度最大是O(n).
3. 快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短

7、堆排序（Heap Sort）

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

7.1 算法步骤

将初始待排序列 (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，则整个排序过程完成。

7.2 算法图解

7.3 代码实现

 /**
     * 7.堆排序
     * @param arr 待排序数组
     * @return 排序后数组
     */
    public static int[] heapSort(int[] arr) {
        int temp;
        System.out.println("从后向前构建堆");
        //从后面的非叶子结点进行调整数组为大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            System.out.println("非叶子结点：" + i);
            bigTopPile(arr, i, arr.length);
        }
        System.out.println("从根节点开始构建堆");
        for (int j = arr.length - 1; j > 0; j--) {
            temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            System.out.println("确认下标为" + j + "：" + Arrays.toString(arr));
            // 从根节点开始调整数据为大顶堆
            bigTopPile(arr, 0, j);
        }
        return arr;
    }

    /**
     * 将数组变为一个大顶堆
     *
     * @param arr         数组
     * @param nonLeafNode 非叶子结点在数组中的下标
     * @param length      调整的数组长度
     */
    private static void bigTopPile(int[] arr, int nonLeafNode, int length) {
        System.out.println("构建前数组：" + Arrays.toString(arr));
        //保存非叶子结点
        int temp = arr[nonLeafNode];
        System.out.println("非叶子结点数据：" + temp);

        // index = nonLeafNode * 2 + 1 index为非叶子结点的左子结点
        for (int index = nonLeafNode * 2 + 1; index < length; index = index * 2 + 1) {
            System.out.println("左子节点：" + index);
            //左子节点小于右子节点  右子节点就是左子节点加1
            if (index + 1 < length && arr[index] < arr[index + 1]) {
                System.out.println("左子节点小于右子节点，指针指向右子节点");
                //左子节点小于右子节点 那么将index此时指向右子节点
                index++;
            }
            //如果子节点大于父节点  则进行交换
            if (arr[index] > temp) {
                System.out.println("子节点大于父节点，进行交换");
                arr[nonLeafNode] = arr[index];
                nonLeafNode = index;
            } else {
                break;
            }
        }
        arr[nonLeafNode] = temp;
        System.out.println("构建后数组：" + Arrays.toString(arr));
        System.out.println();
    }

7.4 排序过程

原始数据:[91, 60, 96, 13, 35, 65, 46, 65, 10, 30, 20, 31, 77, 81, 22]
从后向前构建堆
非叶子结点：6
构建前数组：[91, 60, 96, 13, 35, 65, 46, 65, 10, 30, 20, 31, 77, 81, 22]
非叶子结点数据：46
左子节点：13
子节点大于父节点，进行交换
构建后数组：[91, 60, 96, 13, 35, 65, 81, 65, 10, 30, 20, 31, 77, 46, 22]

非叶子结点：5
构建前数组：[91, 60, 96, 13, 35, 65, 81, 65, 10, 30, 20, 31, 77, 46, 22]
非叶子结点数据：65
左子节点：11
左子节点小于右子节点，指针指向右子节点
子节点大于父节点，进行交换
构建后数组：[91, 60, 96, 13, 35, 77, 81, 65, 10, 30, 20, 31, 65, 46, 22]

非叶子结点：4
构建前数组：[91, 60, 96, 13, 35, 77, 81, 65, 10, 30, 20, 31, 65, 46, 22]
非叶子结点数据：35
左子节点：9
构建后数组：[91, 60, 96, 13, 35, 77, 81, 65, 10, 30, 20, 31, 65, 46, 22]

非叶子结点：3
构建前数组：[91, 60, 96, 13, 35, 77, 81, 65, 10, 30, 20, 31, 65, 46, 22]
非叶子结点数据：13
左子节点：7
子节点大于父节点，进行交换
构建后数组：[91, 60, 96, 65, 35, 77, 81, 13, 10, 30, 20, 31, 65, 46, 22]

非叶子结点：2
构建前数组：[91, 60, 96, 65, 35, 77, 81, 13, 10, 30, 20, 31, 65, 46, 22]
非叶子结点数据：96
左子节点：5
左子节点小于右子节点，指针指向右子节点
构建后数组：[91, 60, 96, 65, 35, 77, 81, 13, 10, 30, 20, 31, 65, 46, 22]

非叶子结点：1
构建前数组：[91, 60, 96, 65, 35, 77, 81, 13, 10, 30, 20, 31, 65, 46, 22]
非叶子结点数据：60
左子节点：3
子节点大于父节点，进行交换
左子节点：7
构建后数组：[91, 65, 96, 60, 35, 77, 81, 13, 10, 30, 20, 31, 65, 46, 22]

非叶子结点：0
构建前数组：[91, 65, 96, 60, 35, 77, 81, 13, 10, 30, 20, 31, 65, 46, 22]
非叶子结点数据：91
左子节点：1
左子节点小于右子节点，指针指向右子节点
子节点大于父节点，进行交换
左子节点：5
左子节点小于右子节点，指针指向右子节点
构建后数组：[96, 65, 91, 60, 35, 77, 81, 13, 10, 30, 20, 31, 65, 46, 22]

从根节点开始构建堆
确认下标为14：[22, 65, 91, 60, 35, 77, 81, 13, 10, 30, 20, 31, 65, 46, 96]
构建前数组：[22, 65, 91, 60, 35, 77, 81, 13, 10, 30, 20, 31, 65, 46, 96]
非叶子结点数据：22
左子节点：1
左子节点小于右子节点，指针指向右子节点
子节点大于父节点，进行交换
左子节点：5
左子节点小于右子节点，指针指向右子节点
子节点大于父节点，进行交换
左子节点：13
子节点大于父节点，进行交换
构建后数组：[91, 65, 81, 60, 35, 77, 46, 13, 10, 30, 20, 31, 65, 22, 96]

确认下标为13：[22, 65, 81, 60, 35, 77, 46, 13, 10, 30, 20, 31, 65, 91, 96]
构建前数组：[22, 65, 81, 60, 35, 77, 46, 13, 10, 30, 20, 31, 65, 91, 96]
非叶子结点数据：22
左子节点：1
左子节点小于右子节点，指针指向右子节点
子节点大于父节点，进行交换
左子节点：5
子节点大于父节点，进行交换
左子节点：11
左子节点小于右子节点，指针指向右子节点
子节点大于父节点，进行交换
构建后数组：[81, 65, 77, 60, 35, 65, 46, 13, 10, 30, 20, 31, 22, 91, 96]

确认下标为12：[22, 65, 77, 60, 35, 65, 46, 13, 10, 30, 20, 31, 81, 91, 96]
构建前数组：[22, 65, 77, 60, 35, 65, 46, 13, 10, 30, 20, 31, 81, 91, 96]
非叶子结点数据：22
左子节点：1
左子节点小于右子节点，指针指向右子节点
子节点大于父节点，进行交换
左子节点：5
子节点大于父节点，进行交换
左子节点：11
子节点大于父节点，进行交换
构建后数组：[77, 65, 65, 60, 35, 31, 46, 13, 10, 30, 20, 22, 81, 91, 96]

确认下标为11：[22, 65, 65, 60, 35, 31, 46, 13, 10, 30, 20, 77, 81, 91, 96]
构建前数组：[22, 65, 65, 60, 35, 31, 46, 13, 10, 30, 20, 77, 81, 91, 96]
非叶子结点数据：22
左子节点：1
子节点大于父节点，进行交换
左子节点：3
子节点大于父节点，进行交换
左子节点：7
构建后数组：[65, 60, 65, 22, 35, 31, 46, 13, 10, 30, 20, 77, 81, 91, 96]

确认下标为10：[20, 60, 65, 22, 35, 31, 46, 13, 10, 30, 65, 77, 81, 91, 96]
构建前数组：[20, 60, 65, 22, 35, 31, 46, 13, 10, 30, 65, 77, 81, 91, 96]
非叶子结点数据：20
左子节点：1
左子节点小于右子节点，指针指向右子节点
子节点大于父节点，进行交换
左子节点：5
左子节点小于右子节点，指针指向右子节点
子节点大于父节点，进行交换
构建后数组：[65, 60, 46, 22, 35, 31, 20, 13, 10, 30, 65, 77, 81, 91, 96]

确认下标为9：[30, 60, 46, 22, 35, 31, 20, 13, 10, 65, 65, 77, 81, 91, 96]
构建前数组：[30, 60, 46, 22, 35, 31, 20, 13, 10, 65, 65, 77, 81, 91, 96]
非叶子结点数据：30
左子节点：1
子节点大于父节点，进行交换
左子节点：3
左子节点小于右子节点，指针指向右子节点
子节点大于父节点，进行交换
构建后数组：[60, 35, 46, 22, 30, 31, 20, 13, 10, 65, 65, 77, 81, 91, 96]

确认下标为8：[10, 35, 46, 22, 30, 31, 20, 13, 60, 65, 65, 77, 81, 91, 96]
构建前数组：[10, 35, 46, 22, 30, 31, 20, 13, 60, 65, 65, 77, 81, 91, 96]
非叶子结点数据：10
左子节点：1
左子节点小于右子节点，指针指向右子节点
子节点大于父节点，进行交换
左子节点：5
子节点大于父节点，进行交换
构建后数组：[46, 35, 31, 22, 30, 10, 20, 13, 60, 65, 65, 77, 81, 91, 96]

确认下标为7：[13, 35, 31, 22, 30, 10, 20, 46, 60, 65, 65, 77, 81, 91, 96]
构建前数组：[13, 35, 31, 22, 30, 10, 20, 46, 60, 65, 65, 77, 81, 91, 96]
非叶子结点数据：13
左子节点：1
子节点大于父节点，进行交换
左子节点：3
左子节点小于右子节点，指针指向右子节点
子节点大于父节点，进行交换
构建后数组：[35, 30, 31, 22, 13, 10, 20, 46, 60, 65, 65, 77, 81, 91, 96]

确认下标为6：[20, 30, 31, 22, 13, 10, 35, 46, 60, 65, 65, 77, 81, 91, 96]
构建前数组：[20, 30, 31, 22, 13, 10, 35, 46, 60, 65, 65, 77, 81, 91, 96]
非叶子结点数据：20
左子节点：1
左子节点小于右子节点，指针指向右子节点
子节点大于父节点，进行交换
左子节点：5
构建后数组：[31, 30, 20, 22, 13, 10, 35, 46, 60, 65, 65, 77, 81, 91, 96]

确认下标为5：[10, 30, 20, 22, 13, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]
构建前数组：[10, 30, 20, 22, 13, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]
非叶子结点数据：10
左子节点：1
子节点大于父节点，进行交换
左子节点：3
子节点大于父节点，进行交换
构建后数组：[30, 22, 20, 10, 13, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]

确认下标为4：[13, 22, 20, 10, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]
构建前数组：[13, 22, 20, 10, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]
非叶子结点数据：13
左子节点：1
子节点大于父节点，进行交换
左子节点：3
构建后数组：[22, 13, 20, 10, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]

确认下标为3：[10, 13, 20, 22, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]
构建前数组：[10, 13, 20, 22, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]
非叶子结点数据：10
左子节点：1
左子节点小于右子节点，指针指向右子节点
子节点大于父节点，进行交换
构建后数组：[20, 13, 10, 22, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]

确认下标为2：[10, 13, 20, 22, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]
构建前数组：[10, 13, 20, 22, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]
非叶子结点数据：10
左子节点：1
子节点大于父节点，进行交换
构建后数组：[13, 10, 20, 22, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]

确认下标为1：[10, 13, 20, 22, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]
构建前数组：[10, 13, 20, 22, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]
非叶子结点数据：10
构建后数组：[10, 13, 20, 22, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]

排序后的数组为:[10, 13, 20, 22, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]

7.5 算法分析

• 稳定性：不稳定排序
• 时间复杂度：
  • 最佳：O(nlogn)
  • 最差：O(nlogn)
  • 平均：O(nlogn)
• 空间复杂度：O(1)
• 排序方式：In-place

7.6 应用场景

1. 堆排序所需的辅助空间少于快速排序，并且不会出现快速排序可能出现的最坏情况，适合超大数据量。这两种排序都是不稳定的。

2. 优先级队列

   优先级队列，顾名思义，它首先是一个队列。队列的最大特性就是先进先出。但是，在优先级队列中，出队的顺序不是按照先进先出，而是按照优先级来，优先级高的先出队。

   如何实现一个优先级队列呢？其实有很多方法，不过使用堆来实现是最直接、最高效的。因为堆和优先级队列非常相似。一个堆就可以看做是一个优先级队列。往优先级队列中插入一个元素，就相当于往堆中插入一个元素；从优先级队列中取出最高优先级的元素，就相当于取出堆顶元素。我们来看一下下面这样一个应用场景。

   假如我们有100个小文件，每个文件的大小是100MB。每个文件中存储的都是有序的字符串。我们希望将这些小文件合并成一个有序大文件。这里就会用到优先级队列。 我们将从100个小文件中，各取出一个字符串，然后我们建立小顶堆，那堆顶的元素，也就是优先级队列的队首元素，也就是最小的字符串。我们将这个字符串放到大文件中，并将其从堆中删除。然后再从小文件中取出下一个字符串放入堆中。循环此过程，就可以将100个小文件的数据依次放入到大文件中。

3. 利用堆求topN

   我们可以把求topk的问题抽象成2类。一类是针对静态数据集合，也就是说数据集合事先确定，不会再变。另一类是针对动态数据集合，也就是说数据集合事先不确定，有数据动态地加入到集合中。 针对静态数据集合，如何在包含n个数据的数组中，查找前K大数据呢?我们可以维护一个大小为k的小顶堆，顺序遍历数组，从数组中取出数据和堆顶元素比较。如果比堆顶元素大，我们就把堆顶元素删除，并且将这个元素插入到堆中；如果比堆顶元素小，我们就不做处理，继续遍历数组。这样等数组中的数据都遍历完成之后，堆中的数据就是前K大数据了。 针对动态数据求得topK，也就是实时topK。怎么理解呢？我举个例子。一个数据集合中有两个操作，一个是添加数据，另一个就是询问当前的前K大数据。 如果每次询问前k大数据时，我们都基于当前的数据重新计算的话，那时间复杂度就是O(nlogN)，n表示当前数据的大小。实际上我们可以一直维护一个k大小的小顶堆，当有数据要添加到集合中时，我们就拿它与堆顶元素做对比。如果比堆顶元素大，我们把堆顶元素删除，并将这个元素插入到堆中；如果比堆顶元素小，我们则不做处理。这样，不论何时需要查询前K大数据，我们都可以立刻返回给它。

8、计数排序（Counting Sort）

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

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

8.1 算法步骤

1. 找出数组中的最大值 max、最小值 min；
2. 创建一个新数组 C，其长度是 max-min+1，其元素默认值都为 0；
3. 遍历原数组 A 中的元素 A[i]，以 A[i]-min 作为 C 数组的索引，以 A[i] 的值在 A 中元素出现次数作为 C[A[i]-min] 的值；
4. 对 C 数组变形，新元素的值是该元素与前一个元素值的和，即当 i>1 时 C[i] = C[i] + C[i-1]；
5. 创建结果数组 R，长度和原始数组一样。
6. 从后向前遍历原始数组 A 中的元素 A[i]，使用 A[i] 减去最小值 min 作为索引，在计数数组 C 中找到对应的值 C[A[i]-min]，C[A[i]-min]-1 就是 A[i] 在结果数组 R 中的位置，做完上述这些操作，将 count[A[i]-min] 减小 1。

8.2 算法图解

8.3 代码实现

 /**
     * 8.计数排序
     *
     * @param arr 待排序数组
     * @return 排序后数组
     */
    public static int[] countingSort(int[] arr) {
        if (arr.length < 2) {
            return arr;
        }
        int[] extremum = getMinAndMax(arr);
        int minValue = extremum[0];
        int maxValue = extremum[1];
        int[] countArr = new int[maxValue - minValue + 1];
        int[] result = new int[arr.length];

        for (int i = 0; i < arr.length; i++) {
            countArr[arr[i] - minValue] += 1;
        }
        for (int i = 1; i < countArr.length; i++) {
            countArr[i] += countArr[i - 1];
        }
        for (int i = arr.length - 1; i >= 0; i--) {
            int idx = countArr[arr[i] - minValue] - 1;
            result[idx] = arr[i];
            countArr[arr[i] - minValue] -= 1;
        }
        return result;
    }

    /**
     * 得到数组中的最大值和最小值
     * @param arr 数组
     * @return 返回最大值和最小值
     */
    private static int[] getMinAndMax(int[] arr) {
        int maxValue = arr[0];
        int minValue = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > maxValue) {
                maxValue = arr[i];
            } else if (arr[i] < minValue) {
                minValue = arr[i];
            }
        }
        return new int[] { minValue, maxValue };
    }

8.4 算法分析

• 稳定性：稳定排序
• 时间复杂度：
  • 最佳：O(n+k)
  • 最差：O(n+k)
  • 平均：O(n+k)
• 空间复杂度：O(k)
• 排序方式：Out-place

8.5 应用场景

1.整数排序: Java中的计数排序可以用于对整数数据进行排序,特别是当数据范围较小且数据比较集中时,计数排序表现良好。
2.字符串排序: Java中的字符是可以转换为整数的，因此可以将字符串中的字符转换为对应的整数进行计数排序。这在某些字符串排序场景下是有用的，例如对字符串按照字母顺序进行排序。
3.数据频次统计: Java中的计数排序可以用于统计某个数据集合中每个元素出现的频次。通过计数排序，可以快速获得各个元素的频次信息。

9、桶排序（Bucket Sort）

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：

1. 在额外空间充足的情况下，尽量增大桶的数量
2. 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中

桶排序的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行。

9.1 算法步骤

1. 设置一个 BucketSize，作为每个桶所能放置多少个不同数值；
2. 遍历输入数据，并且把数据依次映射到对应的桶里去；
3. 对每个非空的桶进行排序，可以使用其它排序方法，也可以递归使用桶排序；
4. 从非空桶里把排好序的数据拼接起来。

9.2 算法图解

9.3 代码实现

    /**
     * 9.桶排序
     * @param arr 代排序数组
     * @param bucketSize 每个桶所能放置多少个不同数值
     * @return 排序后数组
     */
    public static List<Integer> bucketSort(List<Integer> arr,int bucketSize) {
        //合法性校验
        if (arr == null || arr.size() < 2 || bucketSize < 1) {
            return arr;
        }
        //找出集合中元素的最大值和最小值
        int max = arr.get(0);
        int min = arr.get(0);
        for (int i = 0; i < arr.size(); i++) {
            if (arr.get(i) > max) {
                max = arr.get(i);
            }
            if (arr.get(i) < min) {
                min = arr.get(i);
            }
        }
        //计算桶的个数   集合中的最小值到最大值 判断桶的个数
        int bucketCount = (max - min) / bucketSize + 1;
        //按照顺序创建桶 创建一个list带下标
        List<List<Integer>> bucketList = new ArrayList<>();
        for (int i = 0; i < bucketCount; i++) {
            bucketList.add(new ArrayList<Integer>());
        }
        //将待排序的集合依次添加到对应的桶中
        //首先找到元素所对应的桶的顺序  再将元素添加到桶中
        for (int j = 0; j < arr.size(); j++) {
            int bucketIndex = (arr.get(j) - min) / bucketSize;
            bucketList.get(bucketIndex).add(arr.get(j));
        }

        //将桶内的元素进行排序
        List<Integer> resultList = new ArrayList<>();
        for (int j = 0; j < bucketList.size(); j++) {
            List<Integer> everyBucket = bucketList.get(j);
            if (everyBucket.size() >0) {
                if (bucketCount == 1) {
                    bucketSize--;
                }
                //递归调用  进行排序
                List<Integer> temp = bucketSort(everyBucket,bucketSize);
                //合并数据
                resultList.addAll(temp);
            }
        }
        return resultList;
    }

9.4 算法分析

• 稳定性：稳定排序
• 时间复杂度：
  • 最佳：O(n+k)
  • 最差：O(n^2)
  • 平均：O(n+k)
• 空间复杂度：O(n+k)
• 排序方式：Out-place

9.5 应用场景

桶排序的适用场景非常明了，那就是在数据分布相对比较均匀或者数据跨度范围并不是很大时，排序的速度还是相当快且简单的。

但是当数据跨度过大时，这个空间消耗就会很大；如果数值的范围特别大，那么对空间消耗的代价肯定也是不切实际的，所以这个算法还有一定的局限性。同样，由于时间复杂度为 O(n+m)，如果 m 比 n 大太多，则从时间上来说，性能也并不是很好。

但是实际上在使用桶排序的过程中，我们会使用类似散列表的方式去实现，这时的空间利用率会高很多，同时时间复杂度会有一定的提升，但是效率还不错。

我们在开发过程中，除了对一些要求特别高并且数据分布较为均匀的情况使用桶排序，还是很少使用桶排序的，所以即使桶排序很简单、很快，我们也很少使用它。

桶排序更多地被用于一些特定的环境，比如数据范围较为局限或者有一些特定的要求，比如需要通过哈希映射快速获取某些值、需要统计每个数的数量。但是这一切都需要确认数据的范围，如果范围太大，就需要巧妙地解决这个问题或者使用其他算法了。

桶排序有相当的限制。因为桶的个数和大小都是人为设置的。而每个桶又要避免空桶的情况。
所以在使用桶排序的时候的要求如下：

• 待排序数列要求偏均匀，
• 桶的设计（即映射函数）兼顾效率和空间，数据能在桶中均匀分配，如待排序数据有1000个，划分10个桶，则每个桶中的元素约100个最好。

10、基数排序

基数排序也是非比较的排序算法，对元素中的每一位数字进行排序，从最低位开始排序，复杂度为 O(n×k)，n 为数组长度，k 为数组中元素的最大的位数；

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

10.1 算法步骤

1. 取得数组中的最大数，并取得位数，即为迭代次数 N（例如：数组中最大数值为 1000，则 N=4）；
2. A 为原始数组，从最低位开始取每个位组成 radix 数组；
3. 对 radix 进行计数排序（利用计数排序适用于小范围数的特点）；
4. 将 radix 依次赋值给原数组；
5. 重复 2~4 步骤 N 次

10.2 算法图解

10.3 代码实现

 /**
     * 10.基数排序
     *
     * @param arr 待排序数组
     * @return 排序后数组
     */
    public static int[] radixSort(int[] arr) {
        if (arr.length < 2) {
            return arr;
        }
        int N = 1;
        int maxValue = arr[0];
        for (int element : arr) {
            if (element > maxValue) {
                maxValue = element;
            }
        }
        while (maxValue / 10 != 0) {
            maxValue = maxValue / 10;
            N += 1;
        }
        for (int i = 0; i < N; i++) {
            List<List<Integer>> radix = new ArrayList<>();
            for (int k = 0; k < 10; k++) {
                radix.add(new ArrayList<>());
            }
            for (int element : arr) {
                int idx = (element / (int) Math.pow(10, i)) % 10;
                radix.get(idx).add(element);
            }
            int idx = 0;
            for (List<Integer> l : radix) {
                for (int n : l) {
                    arr[idx++] = n;
                }
            }
        }
        return arr;
    }

10.4 算法分析

• 稳定性：稳定排序
• 时间复杂度：
  • 最佳：O(n*k)
  • 最差：O(n*2)
  • 平均：O(n*k)
• 空间复杂度：O(n*k)
• 排序方式：Out-place

10.5 应用场景

基数排序就是，当数据量很大，数值也很高，但是数据量之间存在前后关系

比如假设我们有 10 万个手机号码，希望将这 10 万个手机号码从小到大排序

可以先按照最后一位来排序手机号码，然后，再按照倒数第二位重新排序，以此类推，最后按照第一位重新排序。经过 11 次排序之后，手机号码就都有序了。

在每一位的排序中，可以用桶排序或者计数排序
所以如果要排序的数据有 k 位，那我们就需要 k 次桶排序或者计数排序，总的时间复杂度是 O(k*n)。

当 k 不大的时候，比如手机号码排序的例子，k 最大就是 11，所以基数排序的时间复杂度就近似于 O(n)。

指的注意的是，基数排序的底层排序必须是稳定的排序，所以不能用快排