数据结构与算法（八）：排序

发表于 | 分类于
字数统计: 6.4k

什么是排序？

排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。

1.排序的分类

排序分为两类：

  • 内部排序：若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。
  • 外部排序：若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。

一般来说，外部排序只有数据量极大时会使用，一般情况下排序指的都是内部排序。

image-20200627110216492

2.空间复杂度

1.类似于时间复杂度的讨论，一个算法的空间复杂度(Space Complexity)定义为该算法所耗费的存储空间，它也是问题规模n的函数。

2.空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元，例如快速排序和归并排序算法就属于这种情况。

3.在做算法分析时，主要讨论的是时间复杂度。从用户使用体验上看，更看重的程序执行的速度。一些缓存产品(redis, memcache)和算法(基数排序)本质就是用空间换时间。

3.排序的稳定

待排序的记录序列中可能存在两个或两个以上关键字相等的记录。排序前的序列中arr[i]领先于arr[j]（即i<j）。若在排序后的序列中arr[i]仍然领先于arr[j]，则称所用的方法是稳定的。

比如int数组[1,1,1,6,4]中arr[0]，arr[1]，arr[2]的值相等，在排序时不改变其序列，则称所用的方法是稳定的。

  • 稳定的排序：冒泡排序，插入排序，归并排序，基数排序，计数排序
  • 不稳定的排序：快速排序，希尔排序，选择排序，堆排序

稳定性设计到排序的现实意义，举个例子：

例如要排序的内容是一组原本按照价格高低排序的对象，如今需要按照销量高低排序，使用稳定性算法，可以使得想同销量的对象依旧保持着价格高低的排序展现，只有销量不同的才会重新排序。

更多关于稳定性的理解可以参考这个

4.各排序时间复杂度概览

排序法 平均时间 最差情形 是否稳定 优先选择条件
冒泡排序 O(n^2) O(n^2) 稳定 n小时较好
交换排序 O(n^2) O(n^2) 不稳定 n小时较好
选择排序 O(n^2) O(n^2) 不稳定 n小时较好
插入排序 O(n^2) O(n^2) 稳定 大部分已排序时较好
基数排序 O(logRB) O(logRB) 稳定 B是真数（0-9）,R是基数(个十百)
希尔排序 O(nlogn) O(ns)1<s<2 不稳定 s是所选分组
快速排序 O(nlogn) O(n2) 不稳定 n大时较好
归并排序 O(nlogn) O(nlogn) 稳定 n大时较好
堆排序 O(nlogn) O(nlogn) 不稳定 n大时较好

一、冒泡排序

冒泡排序是一种简单的排序算法，它也是一种稳定排序算法。其实现原理是重复扫描待排序序列，并比较每一对相邻的元素，当该对元素顺序不正确时进行交换。一直重复这个过程，直到没有任何两个相邻元素可以交换，就表明完成了排序。

1.举个例子

要对10,-1,8,3这四个数进行排序：

第一次排序：

  • -1,10,8,3 //比较10和-1，逆序则交换

  • -1,8,10,3 //比较10和8

  • -1,8,3,10 //比较10和3

    第一次排序结束，确定了四个数里最大的数的位置

第二次排序：

  • -1,8,3,10 //比较-1和8，不逆序所以不需要移动

  • -1,3,8,10 //比较8和3

    由于已经确定了10为最大数，所以只需要比较到倒数第二位。

    第二次排序结束，确定了第二大的数的位置

第三次排序：

  • -1,3,8,10 //比较-1和3

    由于已经确定了第三和第四大的数，所以只需要比较到倒数第三位。

    第三次排序结束，确定了第三大的数，故第一大的数也随之确定

2.思路

  • 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
  • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
  • 针对所有的元素重复以上的步骤，除了最后一个；
  • 重复步骤1~3，直到排序完成。

3.实现代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/**
 * 输入一串无序数组，对其进行冒泡排序
 * @param arr
 * @return
 */
public static int[] sort(int[] arr) {
    //如果某次排序不发生交换，说明上一次排序前已经为有序
    boolean isChange = false;

    //根据数组长度决定一共需要排序几次
    int round = arr.length - 1;
    for (int i = 0; i < round; i++) {
        //每次排序需要对比到第几位
        for (int j = 0; j < round - i; j++) {
            //对比大小
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;

                //发生交换
                isChange = true;
            }
        }

        //判断本次排序是否发生交换
        if (!isChange) {
            System.out.println("第" + (i + 1) + "次排序无交换，第" + i + "次排序已为有序！");
            return arr;
        }else {
            isChange = false;
        }
        System.out.println("第" + (i + 1) + "次排序：" + Arrays.toString(arr));
    }
    return arr;
}

//{-1, 52, 9, 13, -5, 7}排序运行结果
第1次排序：[-1, 9, 13, -5, 7, 52]
第2次排序：[-1, 9, -5, 7, 13, 52]
第3次排序：[-1, -5, 7, 9, 13, 52]
第4次排序：[-5, -1, 7, 9, 13, 52]
第5次排序无交换，第4次排序已为有序！

二、选择排序

选择排序，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的。

1.举个例子

选择排序（select sorting）也是一种简单的排序方法。 它的基本思想是： 第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换; 第二次从arr[1]~arr[n-1]中选取最小值，与arr[1]交换; 第三次从arr[2]~arr[n-1]中选取最小值，与arr[2]交换; … 第i次从arr[i-1]~arr[n-1]中选取最小值，与arr[i-1]交换; … 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换, 总共通过n-1次，得到一个按排序码从小到大排列的有序序列。

2.思路

  • 需要进行n-1轮排序
  • 若要为第i个数排序，就先默认第i个元素为最小数，记录其大小和下标
  • 接着从第i+1到第n个数开始依次比较，如果有数小于最小数，则用该数替换原最小数和其下标
  • 第i轮比较结束后，让找出的最小数与第i个数交换位置

3.代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/**
 * 输入一串无序数组，对其进行选择排序
 * @param arr
 * @return
 */
public static int[] sort(int[] arr) {
    for (int i = 0; i < arr.length -1; i++) {
        //用于存放每次选择中最小数的下标，最小值默认为第一个数为i
        int minNumIndex = i;

        //从（i+1,arr.length）的范围中筛选最小的数
        for (int j = i + 1; j < arr.length; j++) {
            //如果范围内有数比现有minNum小，则替换下标
            if (arr[j] < arr[minNumIndex]) {
                minNumIndex = j;
            }
        }
        //一次选择结束，将（i+1,arr.length）的范围中的最小数与arr[i]交换位置
        int temp = arr[minNumIndex];
        arr[minNumIndex] = arr[i];
        arr[i] = temp;

        System.out.println("第" + (i + 1) + "轮：" + Arrays.toString(arr));
    }

    return arr;
}

//{-1, 52, 9, 13, -5, 7}排序运行结果
第1轮后:[-5, 52, 9, 13, -1, 7]
第2轮后:[-5, -1, 9, 13, 52, 7]
第3轮后:[-5, -1, 7, 13, 52, 9]
第4轮后:[-5, -1, 7, 9, 52, 13]
第5轮后:[-5, -1, 7, 9, 13, 52]

4.与冒泡排序比较

同样对长度80000的数字进行排序，选择排序比冒泡排序快不少，原因在于选择排序每次排序只移动指针，找到位置后才进行一次元素交换，而冒泡需要多次交换。

换句话说，要排序的数组越长，冒泡每次排序元素要移动的次数就越多，与选择排序的差距就越明显。

这个同样能解释希尔排序的两种实现方式的速度差距。

1
2
3
4
5
6
7
8
9
10
11
//冒泡排序交换值，交换n次值
temp = arr[j];
arr[j + gap] = temp;
arr[j] = arr[j + gap]
    
//插入排序交换值，交换n次指针
arr[j] = arr[j - gap]
//然后交换1次值
temp = arr[j];
arr[j + gap] = temp;
arr[j] = arr[j + gap]

三、插入排序

插入排序，是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表

1.举个例子

有数组{5,2,4,6,1,3}要进行排序，

  • 从第二位往前看，5比2大，且5为第一个数，于是5后移，把2插入5前。现在是{2,5,4,6,1,3}
  • 从第三位往前看，5比4大，于是5后移，继续往前看，2比4小，所以把4插入原先5的位置。现在是{2,4,5,6,1,3}
  • 从第四位往前看，4比6小，于是6就不动了。现在是{2,4,5,6,1,3}
  • 从第五位往前看，6比1小，于是6后移，继续往前看，5比1小，5后移，继续往前看.....2比1小，2后移，又2为第一个数，于是把1插入原本2的位置。现在是{1,2,4,5,6,3}
  • 从第六位往前看，6比3小，于是6后移，继续往前看，.....3比2大，于是把3插入原先4的位置。排序完成。

2.思路分析

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

3.代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/**
 * 输入一串无序数组，对其进行插入排序
 * @param arr
 * @return
 */
public static int[] sort(int[] arr) {
    //需要从第二位开始，避免i-1出现控制针
    for (int i = 1; i < arr.length; i++) {
        //指向当前插入位置前一个元素的指针
        int pre = i - 1;
        //当前处理元素的值
        int val = arr[i];

        // 让比当前元素大的元素不断的后移，直到到头了或者找到了比当前元素小的元素
        while (pre >= 0 && arr[pre] > val) {
            //前一个元素往后移
            arr[pre + 1] = arr[pre];
            //继续往前移动
            pre--;
        }

        //跳出循环时即找到了当前元素的正确插入位置
        //将该位置的值赋成处理元素的值
        arr[pre + 1] = val;

        System.out.println("第" + (i + 1) + "轮：" + Arrays.toString(arr));
    }

    return arr;
}

//{-1, 52, 9, 13, -5, 7}排序运行结果
第2轮：[-1, 52, 9, 13, -5, 7]
第3轮：[-1, 9, 52, 13, -5, 7]
第4轮：[-1, 9, 13, 52, -5, 7]
第5轮：[-5, -1, 9, 13, 52, 7]
第6轮：[-5, -1, 7, 9, 13, 52]

四、希尔排序

希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。

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

1.举个例子

2.思路

  • 将数组除于2进行分组，得到gap组数字
  • 对gap组数字进行插入排序，由于数据共分为gap组，所以同一组相邻的数字在数组中的位置总是相隔gap
  • 遍历gap组数字，表现在数组上就是从gap遍历到arr.length

3.代码实现

有两种实现思路，一种是交换法，一种是移位法，

先说结论：移位法比交换法快，原因在于：

交换法思路有点类似于冒泡排序，需要不断的比较并交换数值，

而移位法即选择排序，仅仅遍历赋值后移动指针，找到插入位置后，再把元素插入到有序表，而不是多次交换加入有序表。

1
2
3
4
5
6
7
//交换法交换n次值
temp = arr[j];
arr[j + gap] = temp;
arr[j] = arr[j + gap]
    
//位移法移动n次指针后只交换一次值
arr[j] = arr[j - gap]

3.1交换法实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/**
 * 输入一串无序数组，对其进行希尔排序
 * 注意，此方法为移位法
 * @param arr
 * @return
 */
public static int[] sort(int[] arr) {
    int temp = 0;
    int count = 0;
    // 将数组每次对半分分成多组，组数逐渐缩小
    // gap为每次分组后的同组元素的间隔，比如分成5组，那同组元素间隔即为5，即位置是i和i+5的元素是一组
    for (int gap = arr.length / 2; gap > 0; gap /= 2) {
        // 从第gap个元素开始，逐步遍历其所在的组，即从第一组开始向后遍历
        // 第gap个元素即为第一组的最后一个元素，也就是i即表示某组的最后一个位置
        for (int i = gap; i < arr.length; i++) {
            // 接着遍历同组元素，即一组有几个元素就遍历几次
            // j=i-gap即获得第某组的倒数第二个元素位置
            // 向前遍历，每隔gap个元素就对比一次大小
            for (int j = i - gap; j >= 0; j = j - gap) {
                //如果当前元素大于后一个元素,就交换位置
                if (arr[j] > arr[j + gap]) {
                    temp = arr[j];
                    arr[j] = arr[j + gap];
                    arr[j + gap] = temp;
                }
            }
        }

        System.out.println("第" + (++count) + "轮：" + Arrays.toString(arr));
    }


    return arr;
}

//{-1, 52, 9, 13, -5, 7}排序运行结果
第1轮：[-1, -5, 7, 13, 52, 9]
第2轮：[-5, -1, 7, 9, 13, 52]

3.2 移位法实现

下面是通过移位法实现的排序，比交换法更快更稳定：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/**
 * 输入一串无序数组，对其进行希尔排序
 * 注意，此方法为移位法
 * @param arr
 * @return
 */
public static int[] sortByMove(int[] arr) {
    int count = 0;
    // 将数组每次对半分分成多组，组数逐渐缩小
    // gap为每次分组后的同组元素的间隔，比如分成5组，那同组元素间隔即为5，即位置是i和i+5的元素是一组
    for (int gap = arr.length / 2; gap > 0; gap /= 2) {

        //从第gap个元素开始，逐个对其所在组进行插入排序
        for (int i = gap; i < arr.length; i++) {
            int j = i;
            int temp = arr[j];
            //如果某组最后一个元素比前一个元素小
            if (arr[j] < arr[j - gap]) {
                //将同组元素不断后移，直到该元素找到位置或者到头为止
                while (j - gap >= 0 && arr[j - gap] > temp) {
                    arr[j] = arr[j - gap];
                    j = j - gap;
                }

                //当找到位置时插入元素
                arr[j] = temp;
            }
        }

        System.out.println("第" + (++count) + "轮：" + Arrays.toString(arr));

    }

    return arr;
}

五、快速排序

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

1.举个例子

  • 先选择一个中间位置数11，分别将数组中比11大和比11小的数放到左右两个数组中
  • 对两个数组分别选一个中间位置数，也就是5和21，各自再根据比中间数小或者比中间数大再次分为两个数组。以此类推

2.思路

  • 把长度为n的输入序列分成两个长度为n/2的子序列
  • 对这两个子序列分别采用归并排序；
  • 将两个排序好的子序列合并成一个最终的排序序列
  • 对左支和右支可通过递归实现排序

3.代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
public static int[] sort(int[] arr) {
    sort(arr, 0, arr.length - 1);
    return arr;
}

/**
 * 输入一串无序数组，并根据给定的左右指针对指定的范围其进行排序
 * @param arr
 * @param left
 * @param right
 * @return
 */
public static int[] sort(int[] arr, int left, int right) {

    //左右指针
    int l = left;
    int r = right;

    //找到中间数
    int pivot = arr[(left + right) / 2];
    //用于元素交换的临时变量
    int temp;

    //将比中间数小的放左边，比中间数大的放右边
    while (l < r) {
        // 从左往右遍历，寻找比中间数大的数
        while (arr[l] < pivot) {
            l++;
        }
        // 从右往左遍历，寻找比中间数小的数
        while (arr[r] > pivot) {
            r--;
        }

        // 如果l > r，即左指针右指针都越过了中间数，说明两边数都已经有序
        // 如果l = r，即可能存在多个与中间数同值的元素的情况下，左右指针一起指向了同一边的同一个元素，也说明两边数都已经有序
        if (l >= r) {
            break;
        }

        //交换元素
        temp = arr[l];
        arr[l] = arr[r];
        arr[r] = temp;

        //如果交换完后，发现现在右侧有一个与中间数相同的数，右指针前移一位
        if (arr[l] == pivot) {
            r -= 1;
        }
        //如果交换完后，发现现在左侧有一个与中间数相同的数，左指针后移一位
        if (arr[r] == pivot) {
            l += 1;
        }
    }

    //防止死循环
    if (l == r) {
        l += 1;
        r -= 1;
    }

    //向右递归
    if (left < r) {
        sort(arr, l, right);
    }
    //向左递归
    if (right > l) {
        sort(arr, left, r);
    }

    return arr;
}

六、归并排序

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

1.举个例子

我们以上图最后一次合并为例：

以上多个有序数组间的合并需要进行多次，通过递归完成

2.思路

  • 把长度为n的数组分成两个长度为n/2的子数组；
  • 如果子数组仍然长度大于1，就重复步骤1直到所有数组都被拆分完毕
  • 将拆分后的元素两两合并为一个有序数组，然后相邻两个数组A，B进行合并：
    1. 创建一个新数组，然后遍历B数组并与A数组第一位进行比较，如果该数字比A数组第一小则放入新数组第一位
    2. 否则将A数组第一位放入新数组
  • 重复上面步骤3直到A，B数组所有元素都有序放入新数组，即合并完成
  • 重复步骤3，直到所有数组都最终都被合并为一个有序数组

3.代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
public static int[] sort(int[] arr) {
    int temp[] = new int[arr.length];
    return sort(arr, 0, arr.length - 1, temp);
}

/**
 * 合并排序
 * @param arr 排序的原始数组
 * @param left 左边有序序列的初始索引
 * @param right 右边索引
 * @param temp 临时存储的中转数组
 */
public static int[] sort(int[] arr, int left, int right, int[] temp) {
    if (left < right) {
        //获取中间索引
        int mid = (left + right) / 2;
        //向左递归分解
        sort(arr, left, mid, temp);
        //向右递归分解
        sort(arr, mid + 1, right, temp);
        // 先左遍历到最左边，然后向右遍历，当l=r时触发排序
        merge(arr, left, mid, right, temp);
    }
    return arr;
}

/**
 * 合并的方法
 *
 * @param arr 排序的原始数组
 * @param left 左边有序序列的初始索引
 * @param mid 中间索引
 * @param right 右边索引
 * @param temp 临时存储的中转数组
 */
public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
    //左边有序序列的初始索引
    int i = left;
    //中间索引
    int j = mid+1;
    //temp的索引
    int t = 0;

    //先把左右两边有序的数据按照规则填充到temp数组，直到左右两边的有序序列，有一边处理完毕为止
    while (i <= mid && j <= right) {
        //如果左边的有序序列的当前元素小于等于右边有序序列的当前元素
        if (arr[i] <= arr[j]) {
            temp[t] = arr[i];
            t += 1;
            i += 1;
        } else {
            //否则将右边有序序列的当前元素填充到temp数组
            temp[t] = arr[j];
            t += 1;
            j += 1;
        }
    }

    //左边的有序序列还有剩余的元素，就全部填充到temp数组
    while (i <= mid) {
        temp[t] = arr[i];
        t += 1;
        i += 1;
    }
    //右边的有序序列还有剩余的元素，就全部填充到temp数组
    while (j <= right) {
        temp[t] = arr[j];
        t += 1;
        j += 1;
    }

    //将temp数组里的有序元素拷贝回arr数组
    //从左边开始拷贝， 注意：不是每次都拷贝所有
    t = 0;
    int tempLeft = left;
    //第一次合并：templeft = 0，right = 1。 第二次合并：templeft = 2，right = 3。 最后一次：templeft = 0，right = 7
    while (tempLeft <= right) {
        arr[tempLeft] = temp[t];
        t += 1;
        tempLeft += 1;
    }
}

七、基数排序

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

1.举个例子

2.思路

  • 取得数组中的最大数，并取得位数
  • 准备一个长度为10，内部一位数组长度为arr.length的二维数组，可以理解为10个高度为arr.length的桶
  • 遍历数组，根据数组中个位数决定要放在哪个桶，即如果个位数为1就放入1号桶，为2就放入2号桶，直到数组所有元素分配完毕
  • 遍历桶将桶中数字放回原数组，然后清空桶。即完成了个位数的排序
  • 重复步骤3和步骤4，但是排序依据从个位数换成十位数，然后百位数.....以此类推，直到数组最大位数

3.代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/**
 * 获取数组中的最大数的位数
 * @param arr
 * @return
 */
public static int getMaxDigit(int[] arr) {
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return String.valueOf(max).length();
}

/**
 * 基数排序
 * @param arr 排序的原始数组
 * @param left 左边有序序列的初始索引
 * @param right 右边索引
 * @param temp 临时存储的中转数组
 */
public static int[] sort(int[] arr) {
    //设置二维数组用于表示桶
    //第一层数组下标即表示存放某数位为x的数字的桶，比如下标为2的桶用于存放个位数为2的数字；下标为0的桶用于存放十位数为0的数字
    //第二层数组即表示桶高度
    int[][] bucket = new int[10][arr.length];

    //表示某个桶内用几个元素，比如bucketElementCount[0]即表示bucket[0]桶有几个元素
    //由于数字下标从0开始，所以这同时也表示了桶下一个元素的插入下标，比如bucketElementCount[0]=1，就意味着bucket[0]下一个元素应该插到bucket[0][1]去
    int[] bucketElementCount = new int[10];

    //最大数有几位就循环排序几次
    for (int i = 0, n = 1; i <= getMaxDigit(arr); i++, n *= 10) {
        //遍历元素并归类到桶中
        for (int j = 0; j < arr.length; j++) {
            //获取元素某数位的数字
            //根据遍历，获取数字的个位，十位数，百位数......
            int digitOfElement = arr[j] / n % 10;
            //将其归类到桶中
            bucket[digitOfElement][bucketElementCount[digitOfElement]] = arr[j];
            //提高桶高度
            bucketElementCount[digitOfElement]++;
        }

        //按顺序将每一个桶中元素取出并放入原集合
        int index = 0;
        for (int k = 0; k < bucketElementCount.length; k++) {
            //如果桶中有元素就取出
            if (bucketElementCount[k] != 0) {
                //遍历桶中元素并放入数组
                for (int l = 0; l < bucketElementCount[k]; l++) {
                    arr[index++] = bucket[k][l];
                }
            }
            //清空桶
            bucketElementCount[k] = 0;
        }
    }

    return arr;
}

4.基数排序注意事项：

  • 基数排序是典型的空间换时间，当排序的数字过多的时候可能会发生OutOfMemoryError（实测八千万时报错）

  • 基数排序要排负数的时候需要加以改进：

    将数组中的负数单独摘出并取绝对值后进行排序，然后倒序插入排序完的整数数组，并且在插入过程加上负号

八、堆排序

参照二叉树部分

0%