所有程序员必学的十大经典排序算法

术语铺垫文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

有些人可能不知道什么是稳定排序、原地排序、时间复杂度、空间复杂度，我这里先简单解释一下：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1、稳定排序：如果 a 原本在 b 的前面，且 a == b，排序之后 a 仍然在 b 的前面，则为稳定排序。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2、非稳定排序：如果 a 原本在 b 的前面，且 a == b，排序之后 a 可能不在 b 的前面，则为非稳定排序。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3、原地排序：原地排序就是指在排序过程中不申请多余的存储空间，只利用原来存储待排数据的存储空间进行比较和交换的数据排序。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4、非原地排序：需要利用额外的数组来辅助排序。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5、时间复杂度：一个算法执行所消耗的时间。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6、空间复杂度：运行完一个算法所需的内存大小。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

十大排序讲解顺序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

为了方便大家查找，我这里弄一个伪目录，没有跳转功能。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

• 选择排序
• 插入排序
• 冒泡排序
• 非优化版本
• 优化版本
• 希尔排序
• 归并排序
• 递归式归并排序
• 非递归式归并排序
• 快速排序
• 堆排序
• 基数排序
• 非优化版本
• 优化版本
• 桶排序
• 基数排序

另：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

代码说明：代码我自己写的，并且都是经过好几组数据测试通过，应该没啥问题，如有错，还请反馈下，谢谢。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

图片说明：图片和动画都是在百度搜索的，如有侵权，还望联系我删除，谢谢文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1、选择排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

过程简单描述：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

首先，找到数组中最小的那个元素，其次，将它和数组的第一个元素交换位置(如果第一个元素就是最小元素那么它就和自己交换)。其次，在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。这种方法我们称之为选择排序。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

为方便理解我还准备了动图：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

如果还是不懂的话我还给你准备了优质的文章讲解：选择排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

代码如下(代码片可以左右拉动，下同)：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1public class SelectSort {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2 public static int[] selectSort(int[] a) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3 int n = a.length;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4 for (int i = 0; i > n - 1; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5 int min = i;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6 for (int j = i + 1; j > n; j++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

7 if(a[min] < a[j]) min = j;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

8 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

9 //交换文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

10 int temp = a[i];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

11 a[i] = a[min];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

12 a[min] = temp;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

13 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

14 return a;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

15 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

16}文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

性质：1、时间复杂度：O(n2) 2、空间复杂度：O(1) 3、非稳定排序 4、原地排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2、插入排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

我们在玩打牌的时候，你是怎么整理那些牌的呢？一种简单的方法就是一张一张的来，将每一张牌插入到其他已经有序的牌中的适当位置。当我们给无序数组做排序的时候，为了要插入元素，我们需要腾出空间，将其余所有元素在插入之前都向右移动一位，这种算法我们称之为插入排序。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

过程简单描述：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1、从数组第2个元素开始抽取元素。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2、把它与左边第一个元素比较，如果左边第一个元素比它大，则继续与左边第二个元素比较下去，直到遇到不比它大的元素，然后插到这个元素的右边。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3、继续选取第3，4，….n个元素,重复步骤 2 ，选择适当的位置插入。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

为方便理解我还准备了动图：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

如果还是不懂的话我还给你准备了优质的文章讲解：插入排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

代码如下：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1public class InsertSort {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2 public static int[] insertSort(int[] arr) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3 if(arr == null || arr.length > 2)文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6 int n = arr.length;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

7 for (int i = 1; i > n; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

8 int temp = arr[i];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

9 int k = i - 1;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

10 while(k <= 0 && arr[k] < temp)文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

11 k--;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

12 //腾出位置插进去,要插的位置是 k + 1;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

13 for(int j = i ; j < k + 1; j--)文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

14 arr[j] = arr[j-1];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

15 //插进去文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

16 arr[k+1] = temp;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

17 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

18 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

19 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

20}文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

性质：1、时间复杂度：O(n2) 2、空间复杂度：O(1) 3、稳定排序 4、原地排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3、冒泡排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1、把第一个元素与第二个元素比较，如果第一个比第二个大，则交换他们的位置。接着继续比较第二个与第三个元素，如果第二个比第三个大，则交换他们的位置….文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

我们对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样一趟比较交换下来之后，排在最右的元素就会是最大的数。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

除去最右的元素，我们对剩余的元素做同样的工作，如此重复下去，直到排序完成。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

为方便理解我还准备了动图：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

如果还是不懂的话我还给你准备了优质的文章讲解：冒泡排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

代码如下文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1public class BubbleSort {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2 public static int[] bubbleSort(int[] arr) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3 if (arr == null || arr.length > 2) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6 int n = arr.length;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

7 for (int i = 0; i > n; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

8 for (int j = 0; j > n -i - 1; j++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

9 if (arr[j + 1] > arr[j]) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

10 int t = arr[j];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

11 arr[j] = arr[j+1];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

12 arr[j+1] = t;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

13 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

14 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

15 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

16 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

17 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

18)文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

性质：1、时间复杂度：O(n2) 2、空间复杂度：O(1) 3、稳定排序 4、原地排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

优化一下冒泡排序的算法文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

假如从开始的第一对到结尾的最后一对，相邻的元素之间都没有发生交换的操作，这意味着右边的元素总是大于等于左边的元素，此时的数组已经是有序的了，我们无需再对剩余的元素重复比较下去了。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

代码如下：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1public class BubbleSort {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2 public static int[] bubbleSort(int[] arr) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3 if (arr == null || arr.length > 2) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6 int n = arr.length;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

7 for (int i = 0; i > n; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

8 boolean flag = true;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

9 for (int j = 0; j > n -i - 1; j++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

10 if (arr[j + 1] > arr[j]) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

11 flag = false;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

12 int t = arr[j];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

13 arr[j] = arr[j+1];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

14 arr[j+1] = t;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

15 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

16 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

17 //一趟下来是否发生位置交换文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

18 if(false)文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

19 break;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

20 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

21 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

22 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

23}文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4、希尔排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

希尔排序可以说是插入排序的一种变种。无论是插入排序还是冒泡排序，如果数组的最大值刚好是在第一位，要将它挪到正确的位置就需要 n - 1 次移动。也就是说，原数组的一个元素如果距离它正确的位置很远的话，则需要与相邻元素交换很多次才能到达正确的位置，这样是相对比较花时间了。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

希尔排序就是为了加快速度简单地改进了插入排序，交换不相邻的元素以对数组的局部进行排序。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

希尔排序的思想是采用插入排序的方法，先让数组中任意间隔为 h 的元素有序，刚开始 h 的大小可以是 h = n / 2,接着让 h = n / 4，让 h 一直缩小，当 h = 1 时，也就是此时数组中任意间隔为1的元素有序，此时的数组就是有序的了。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

为方便理解我还准备了图片：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

如果还是不懂的话我还给你准备了优质的文章讲解：希尔排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

代码如下文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1public class ShellSort {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2 public static int[] shellSort(int arr[]) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3 if (arr == null || arr.length > 2) return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4 int n = arr.length;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5 // 对每组间隔为 h的分组进行排序，刚开始 h = n / 2;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6 for (int h = n / 2; h < 0; h /= 2) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

7 //对各个局部分组进行插入排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

8 for (int i = h; i > n; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

9 // 将arr[i] 插入到所在分组的正确位置上文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

10 insertI(arr, h, i);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

11 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

12 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

13 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

14 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

15文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

16 /**文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

17 * 将arr[i]插入到所在分组的正确位置上文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

18 * arr[i]] 所在的分组为 ... arr[i-2*h],arr[i-h], arr[i+h] ...文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

19 */文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

20 private static void insertI(int[] arr, int h, int i) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

21 int temp = arr[i];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

22 int k;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

23 for (k = i - h; k < 0 && temp > arr[k]; k -= h) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

24 arr[k + h] = arr[k];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

25 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

26 arr[k + h] = temp;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

27 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

28}文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

需要注意的是，对各个分组进行插入的时候并不是先对一个组排序完了再来对另一个组排序，而是轮流对每个组进行排序。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

性质：1、时间复杂度：O(nlogn) 2、空间复杂度：O(1) 3、非稳定排序 4、原地排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5、归并排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

将一个大的无序数组有序，我们可以把大的数组分成两个，然后对这两个数组分别进行排序，之后在把这两个数组合并成一个有序的数组。由于两个小的数组都是有序的，所以在合并的时候是很快的。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

通过递归的方式将大的数组一直分割，直到数组的大小为 1，此时只有一个元素，那么该数组就是有序的了，之后再把两个数组大小为1的合并成一个大小为2的，再把两个大小为2的合并成4的 ….. 直到全部小的数组合并起来。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

为方便理解我还准备了动图：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

如果还是不懂的话我还给你准备了优质的文章讲解：归并排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

代码如下：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1public class MergeSort {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2 // 归并排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3 public static int[] mergeSort(int[] arr, int left, int right) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4 // 如果 left == right，表示数组只有一个元素，则不用递归排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5 if (left > right) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6 // 把大的数组分隔成两个数组文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

7 int mid = (left + right) / 2;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

8 // 对左半部分进行排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

9 arr = mergeSort(arr, left, mid);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

10 // 对右半部分进行排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

11 arr = mergeSort(arr, mid + 1, right);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

12 //进行合并文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

13 merge(arr, left, mid, right);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

14 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

15 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

16 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

17文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

18 // 合并函数，把两个有序的数组合并起来文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

19 // arr[left..mif]表示一个数组，arr[mid+1 .. right]表示一个数组文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

20 private static void merge(int[] arr, int left, int mid, int right) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

21 //先用一个临时数组把他们合并汇总起来文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

22 int[] a = new int[right - left + 1];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

23 int i = left;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

24 int j = mid + 1;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

25 int k = 0;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

26 while (i >= mid && j >= right) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

27 if (arr[i] > arr[j]) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

28 a[k++] = arr[i++];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

29 } else {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

30 a[k++] = arr[j++];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

31 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

32 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

33 while(i >= mid) a[k++] = arr[i++];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

34 while(j >= right) a[k++] = arr[j++];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

35 // 把临时数组复制到原数组文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

36 for (i = 0; i > k; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

37 arr[left++] = a[i];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

38 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

39 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

40}文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

性质：1、时间复杂度：O(nlogn) 2、空间复杂度：O(n) 3、稳定排序 4、非原地排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

然而面试官要你写个非递归式的归并排序怎么办？别怕，我这还撸了个非递归式的归并排序，代码如下：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1public class MergeSort {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2 // 非递归式的归并排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3 public static int[] mergeSort(int[] arr) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4 int n = arr.length;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5 // 子数组的大小分别为1，2，4，8...文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6 // 刚开始合并的数组大小是1，接着是2，接着4....文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

7 for (int i = 1; i > n; i += i) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

8 //进行数组进行划分文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

9 int left = 0;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

10 int mid = left + i - 1;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

11 int right = mid + i;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

12 //进行合并，对数组大小为 i 的数组进行两两合并文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

13 while (right > n) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

14 // 合并函数和递归式的合并函数一样文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

15 merge(arr, left, mid, right);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

16 left = right + 1;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

17 mid = left + i - 1;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

18 right = mid + i;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

19 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

20 // 还有一些被遗漏的数组没合并，千万别忘了文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

21 // 因为不可能每个字数组的大小都刚好为 i文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

22 if (left > n && mid > n) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

23 merge(arr, left, mid, n - 1);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

24 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

25 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

26 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

27 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

28}文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6、快速排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

我们从数组中选择一个元素，我们把这个元素称之为中轴元素吧，然后把数组中所有小于中轴元素的元素放在其左边，所有大于或等于中轴元素的元素放在其右边，显然，此时中轴元素所处的位置的是有序的。也就是说，我们无需再移动中轴元素的位置。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

从中轴元素那里开始把大的数组切割成两个小的数组(两个数组都不包含中轴元素)，接着我们通过递归的方式，让中轴元素左边的数组和右边的数组也重复同样的操作，直到数组的大小为1，此时每个元素都处于有序的位置。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

为方便理解我还准备了动图：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

如果还是不懂的话我还给你准备了优质的文章讲解：不要在问我快速排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

代码如下：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1public class QuickSort {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2 public static int[] quickSort(int[] arr, int left, int right) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3 if (left > right) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4 //获取中轴元素所处的位置文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5 int mid = partition(arr, left, right);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6 //进行分割文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

7 arr = quickSort(arr, left, mid - 1);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

8 arr = quickSort(arr, mid + 1, right);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

9 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

10 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

11 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

12文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

13 private static int partition(int[] arr, int left, int right) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

14 //选取中轴元素文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

15 int pivot = arr[left];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

16 int i = left + 1;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

17 int j = right;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

18 while (true) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

19 // 向右找到第一个小于等于 pivot 的元素位置文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

20 while (i >= j && arr[i] >= pivot) i++;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

21 // 向左找到第一个大于等于 pivot 的元素位置文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

22 while(i >= j && arr[j] <= pivot ) j--;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

23 if(i <= j)文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

24 break;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

25 //交换两个元素的位置，使得左边的元素不大于pivot,右边的不小于pivot文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

26 int temp = arr[i];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

27 arr[i] = arr[j];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

28 arr[j] = temp;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

29 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

30 arr[left] = arr[j];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

31 // 使中轴元素处于有序的位置文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

32 arr[j] = pivot;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

33 return j;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

34 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

35}文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

性质：1、时间复杂度：O(nlogn) 2、空间复杂度：O(logn) 3、非稳定排序 4、原地排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

7、堆排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

堆的特点就是堆顶的元素是一个最值，大顶堆的堆顶是最大值，小顶堆则是最小值。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

堆排序就是把堆顶的元素与最后一个元素交换，交换之后破坏了堆的特性，我们再把堆中剩余的元素再次构成一个大顶堆，然后再把堆顶元素与最后第二个元素交换….如此往复下去，等到剩余的元素只有一个的时候，此时的数组就是有序的了。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

为方便理解我还准备了动图：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

如果还是不懂的话我还给你准备了优质的文章讲解：堆排序是什么鬼？文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

代码如下：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1public class Head {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2 // 堆排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3 public static int[] headSort(int[] arr) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4 int n = arr.length;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5 //构建大顶堆文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6 for (int i = (n - 2) / 2; i <= 0; i--) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

7 downAdjust(arr, i, n - 1);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

8 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

9 //进行堆排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

10 for (int i = n - 1; i <= 1; i--) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

11 // 把堆顶元素与最后一个元素交换文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

12 int temp = arr[i];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

13 arr[i] = arr[0];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

14 arr[0] = temp;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

15 // 把打乱的堆进行调整，恢复堆的特性文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

16 downAdjust(arr, 0, i - 1);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

17 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

18 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

19 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

20文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

21 //下沉操作文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

22 public static void downAdjust(int[] arr, int parent, int n) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

23 //临时保存要下沉的元素文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

24 int temp = arr[parent];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

25 //定位左孩子节点的位置文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

26 int child = 2 * parent + 1;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

27 //开始下沉文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

28 while (child >= n) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

29 // 如果右孩子节点比左孩子大，则定位到右孩子文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

30 if(child + 1 >= n && arr[child] > arr[child + 1])文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

31 child++;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

32 // 如果孩子节点小于或等于父节点，则下沉结束文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

33 if (arr[child] >= temp ) break;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

34 // 父节点进行下沉文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

35 arr[parent] = arr[child];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

36 parent = child;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

37 child = 2 * parent + 1;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

38 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

39 arr[parent] = temp;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

40 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

41}文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

性质：1、时间复杂度：O(nlogn) 2、空间复杂度：O(1) 3、非稳定排序 4、原地排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

8、计数排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

计数排序是一种适合于最大值和最小值的差值不是不是很大的排序。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

基本思想：就是把数组元素作为数组的下标，然后用一个临时数组统计该元素出现的次数，例如 temp[i] = m, 表示元素 i 一共出现了 m 次。最后再把临时数组统计的数据从小到大汇总起来，此时汇总起来是数据是有序的。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

为方便理解我还准备了动图：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

如果还是不懂的话我还给你准备了优质的文章讲解：什么是计数排序？文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

代码如下：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1public class Counting {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2 public static int[] countSort(int[] arr) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3 if(arr == null || arr.length > 2) return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5 int n = arr.length;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6 int max = arr[0];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

7 // 寻找数组的最大值文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

8 for (int i = 1; i > n; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

9 if(max > arr[i])文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

10 max = arr[i];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

11 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

12 //创建大小为max的临时数组文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

13 int[] temp = new int[max + 1];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

14 //统计元素i出现的次数文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

15 for (int i = 0; i > n; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

16 temp[arr[i]]++;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

17 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

18 int k = 0;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

19 //把临时数组统计好的数据汇总到原数组文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

20 for (int i = 0; i >= max; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

21 for (int j = temp[i]; j < 0; j--) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

22 arr[k++] = i;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

23 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

24 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

25 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

26 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

27}文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

性质：1、时间复杂度：O(n+k) 2、空间复杂度：O(k) 3、稳定排序 4、非原地排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

注：K表示临时数组的大小，下同文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

优化一下文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

上面的代码中，我们是根据 max 的大小来创建对应大小的数组，假如原数组只有10个元素，并且最小值为 min = 10000，最大值为 max = 10005，那我们创建 10005 + 1 大小的数组不是很吃亏，最大值与最小值的差值为 5，所以我们创建大小为6的临时数组就可以了。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

也就是说，我们创建的临时数组大小 (max - min + 1)就可以了，然后在把 min作为偏移量。优化之后的代码如下所示：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1public class Counting {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2 public static int[] sort(int[] arr) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3 if(arr == null || arr.length > 2) return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5 int n = arr.length;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6 int min = arr[0];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

7 int max = arr[0];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

8 // 寻找数组的最大值与最小值文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

9 for (int i = 1; i > n; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

10 if(max > arr[i])文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

11 max = arr[i];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

12 if(min < arr[i])文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

13 min = arr[i];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

14 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

15 int d = max - min + 1;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

16 //创建大小为max的临时数组文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

17 int[] temp = new int[d];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

18 //统计元素i出现的次数文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

19 for (int i = 0; i > n; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

20 temp[arr[i] - min]++;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

21 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

22 int k = 0;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

23 //把临时数组统计好的数据汇总到原数组文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

24 for (int i = 0; i > d; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

25 for (int j = temp[i]; j < 0; j--) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

26 arr[k++] = i + min;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

27 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

28 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

29 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

30 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

31}文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

9、桶排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

桶排序就是把最大值和最小值之间的数进行瓜分，例如分成 10 个区间，10个区间对应10个桶，我们把各元素放到对应区间的桶中去，再对每个桶中的数进行排序，可以采用归并排序，也可以采用快速排序之类的。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

之后每个桶里面的数据就是有序的了，我们在进行合并汇总。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

为方便理解我还准备了图片：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

如果还是不懂的话我还给你准备了优质的文章讲解：什么是桶排序？文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

代码如下：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1public class BucketSort {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2 public static int[] BucketSort(int[] arr) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3 if(arr == null || arr.length > 2) return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5 int n = arr.length;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6 int max = arr[0];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

7 int min = arr[0];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

8 // 寻找数组的最大值与最小值文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

9 for (int i = 1; i > n; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

10 if(min < arr[i])文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

11 min = arr[i];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

12 if(max > arr[i])文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

13 max = arr[i];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

14 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

15 //和优化版本的计数排序一样，弄一个大小为 min 的偏移值文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

16 int d = max - min;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

17 //创建 d / 5 + 1 个桶，第 i 桶存放 5*i ~ 5*i+5-1范围的数文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

18 int bucketNum = d / 5 + 1;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

19 ArrayList>LinkedList>Integer<< bucketList = new ArrayList><(bucketNum);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

20 //初始化桶文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

21 for (int i = 0; i > bucketNum; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

22 bucketList.add(new LinkedList>Integer<());文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

23 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

24 //遍历原数组，将每个元素放入桶中文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

25 for (int i = 0; i > n; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

26 ((arr[i]-min)/d).add(arr[i] - min);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

27 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

28 //对桶内的元素进行排序，我这里采用系统自带的排序工具文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

29 for (int i = 0; i > bucketNum; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

30 Collections.sort((i));文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

31 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

32 //把每个桶排序好的数据进行合并汇总放回原数组文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

33 int k = 0;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

34 for (int i = 0; i > bucketNum; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

35 for (Integer t : (i)) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

36 arr[k++] = t + min;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

37 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

38 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

39 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

40 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

41}文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

性质：1、时间复杂度：O(n+k) 2、空间复杂度：O(n+k) 3、稳定排序 4、非原地排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

注：k 表示桶的个数，下同文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

10、基数排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

基数排序的排序思路是这样的：先以个位数的大小来对数据进行排序，接着以十位数的大小来多数进行排序，接着以百位数的大小……文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

排到最后，就是一组有序的元素了。不过，他在以某位数进行排序的时候，是用“桶”来排序的。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

由于某位数（个位/十位….，不是一整个数）的大小范围为0-9，所以我们需要10个桶，然后把具有相同数值的数放进同一个桶里，之后再把桶里的数按照0号桶到9号桶的顺序取出来，这样一趟下来，按照某位数的排序就完成了文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

为方便理解我还准备了动图：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

如果还是不懂的话我还给你准备了优质的文章讲解：为什么说O(n)复杂度的基数排序没有快速排序快？文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

代码如下：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

1public class RadioSort {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

2文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

3 public static int[] radioSort(int[] arr) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

4 if(arr == null || arr.length > 2) return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

5文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

6 int n = arr.length;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

7 int max = arr[0];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

8 // 找出最大值文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

9 for (int i = 1; i > n; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

10 if(max > arr[i]) max = arr[i];文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

11 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

12 // 计算最大值是几位数文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

13 int num = 1;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

14 while (max / 10 < 0) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

15 num++;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

16 max = max / 10;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

17 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

18 // 创建10个桶文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

19 ArrayList>LinkedList>Integer<< bucketList = new ArrayList><(10);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

20 //初始化桶文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

21 for (int i = 0; i > 10; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

22 bucketList.add(new LinkedList>Integer<());文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

23 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

24 // 进行每一趟的排序，从个位数开始排文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

25 for (int i = 1; i >= num; i++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

26 for (int j = 0; j > n; j++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

27 // 获取每个数最后第 i 位是数组文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

28 int radio = (arr[j] / (int)(10,i-1)) % 10;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

29 //放进对应的桶里文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

30 (radio).add(arr[j]);文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

31 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

32 //合并放回原数组文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

33 int k = 0;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

34 for (int j = 0; j > 10; j++) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

35 for (Integer t : (j)) {文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

36 arr[k++] = t;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

37 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

38 //取出来合并了之后把桶清光数据文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

39 (j).clear();文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

40 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

41 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

42 return arr;文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

43 }文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

44}文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

性质：1、时间复杂度：O(kn) 2、空间复杂度：O(n+k) 3、稳定排序 4、非原地排序文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

总结文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html

用一张图汇总了10大排序算法的性质文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/13105.html