线性排序的概念

线性排序算法包括桶排序、计数排序、基数排序。

线性排序算法的时间复杂度为O(n)。

线性排序的特点

此3种排序算法都不涉及元素之间的比较操作，是非基于比较的排序算法。

对排序数据的要求很苛刻，重点掌握此3种排序算法的适用场景。

桶排序

算法原理

  • 将要排序的数据分到几个有序的桶里，每个桶里的数据再单独进行快速排序
  • 桶内排完序之后，再把每个桶里的数据按照顺序依次取出，组成的序列就是有序的了

使用条件

  • 要排序的数据需要很容易就能划分成m个桶，并且桶与桶之间有着天然的大小顺序
  • 数据在各个桶之间分布是均匀的

代码实现

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
/**
 * 桶排序 
 * BucketSort
 */
public class BucketSort {

    private int[] buckets;
    private int[] array;
    //声明成绩在1-10范围的10个桶
    public BucketSort(int range,int[] array){
        this.buckets = new int[range];
        this.array = array;
    }

    public void sort(){
        if(array!=null && array.length >0){
            for (int i = 0; i < array.length; i++) {
                buckets[array[i]]++;
            }
        }
    }

    public void sortOut(){
        for (int i = 0; i < buckets.length; i++) {
            for (int j = 0; j < buckets[i]; j++) {
                System.out.print(i +" \t");
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {5,7,3,5,4,8,6,4,1,2};
        BucketSort bucketSort = new BucketSort(10, array);
        bucketSort.sort()
        bucketSort.sortOut();
    }

}

适用场景

  • 桶排序比较适合用在外部排序中
  • 外部排序就是数据存储在外部磁盘且数据量大，但内存有限无法将整个数据全部加载到内存中
应用案例

  • 需求描述

    有10GB的订单数据，需按订单金额（假设金额都是正整数）进行排序，但内存有限，仅几百MB

  • 解决思路

    • 扫描一遍文件，看订单金额所处数据范围，比如1元-10万元，那么就分100个桶
    • 第一个桶存储金额1-1000元之内的订单，第二个桶存1001-2000元之内的订单，依次类推
    • 每个桶对应一个文件，并按照金额范围的大小顺序编号命名（00，01，02，…，99）
    • 将100个小文件依次放入内存并用快排排序
    • 所有文件排好序后，只需按照文件编号从小到大依次读取每个小文件并写到大文件中即可

  • 若单个文件无法全部载入内存，则针对该文件继续细分数据过多的部分，按照前面的思路进行处理

计数排序

算法原理

  • 计数其实就是桶排序的一种特殊情况
  • 当要排序的n个数据所处范围并不大时，比如最大值为k，则分成k个桶
  • 每个桶内的数据值都是相同的，就省掉了桶内排序的时间

代码实现

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
// 计数排序，a 是数组，n 是数组大小。假设数组中存储的都是非负整数。
public void countingSort(int[] a, int n) {
  if (n <= 1) return;
 
  // 查找数组中数据的范围
  int max = a[0];
  for (int i = 1; i < n; ++i) {
    if (max < a[i]) {
      max = a[i];
    }
  }
 
  int[] c = new int[max + 1]; // 申请一个计数数组 c，下标大小 [0,max]
  for (int i = 0; i <= max; ++i) {
    c[i] = 0;
  }
 
  // 计算每个元素的个数，放入 c 中
  for (int i = 0; i < n; ++i) {
    c[a[i]]++;
  }
 
  // 依次累加
  for (int i = 1; i <= max; ++i) {
    c[i] = c[i-1] + c[i];
  }
 
  // 临时数组 r，存储排序之后的结果
  int[] r = new int[n];
  // 计算排序的关键步骤，有点难理解
  for (int i = n - 1; i >= 0; --i) {
    int index = c[a[i]]-1;
    r[index] = a[i];
    c[a[i]]--;
  }
 
  // 将结果拷贝给 a 数组
  for (int i = 0; i < n; ++i) {
    a[i] = r[i];
  }
}

案例分析

假设只有8个考生分数在0-5分之间，成绩存于数组A[8] = [2，5，3，0，2，3，0，3]。

使用大小为6的数组C[6]表示桶，下标对应分数，即0，1，2，3，4，5。

C[6]存储的是考生人数，只需遍历一边考生分数，就可以得到C[6] = [2，0，2，3，0，1]。

对C[6]数组顺序求和则C[6]=[2，2，4，7，7，8]，c[k]存储的是小于等于分数k的考生个数。

数组R[8] = [0，0，2，2，3，3，3，5]存储考生名次。那么如何得到R[8]的呢？

从后到前依次扫描数组A，比如扫描到3时，可以从数组C中取出下标为3的值7，也就是说，到目前为止，包括自己在内，分数小于等于3的考生有7个，也就是说3是数组R的第7个元素（也就是数组R中下标为6的位置）。

当3放入数组R后，小于等于3的元素就剩下6个了，相应的C[3]要减1变成6。

以此类推，当扫描到第二个分数为3的考生时，就会把它放入数组R中第6个元素的位置（也就是下标为5的位置）。当扫描完数组A后，数组R内的数据就是按照分数从小到大排列的了。

使用条件

  • 只能用在数据范围不大的场景中，若数据范围k比要排序的数据n大很多，就不适合用计数排序
  • 计数排序只能给非负整数排序，其他类型需要在不改变相对大小情况下，转换为非负整数
  • 比如如果考试成绩精确到小数后一位，就需要将所有分数乘以10，转换为整数

基数排序

算法原理

以排序10万个手机号为例来说明

  • 比较两个手机号码a，b的大小，如果在前面几位中a已经比b大了，那后面几位就不用看了借助稳定排序算法的思想，可以先按照最后一位来排序手机号码，然后再按照倒数第二位来重新排序，以此类推，最后按照第一个位重新排序
  • 经过11次排序后，手机号码就变为有序的了
  • 每次排序有序数据范围较小，可以使用桶排序或计数排序来完成

使用条件

  • 要求数据可以分割独立的“位”来比较
  • 位之间由递进关系，如果a数据的高位比b数据大，那么剩下的地位就不用比较了
  • 每一位的数据范围不能太大，要可以用线性排序，否则基数排序的时间复杂度无法做到O(n)