Java数据结构：计数排序/Counting Sort（第七周）

题目来源：大工慕课 链接
作者：Caleb Sung

关于计数排序

计数排序是一种非常快捷的稳定性强的排序方法，时间复杂度O(n+k)，其中n为要排序的数的个数，k为要排序的数的组大值。计数排序对一定量的整数排序时候的速度非常快，一般快于其他排序算法。但计数排序局限性比较大，只限于对整数进行排序。计数排序是消耗空间发杂度来获取快捷的排序方法，其空间发展度为O(K)，同理K为要排序的最大值。

基本思想

计数排序的基本思想为：一组数在排序之前先统计这组数中其他数小于这个数的个数，则可以确定这个数的位置。例如要排序的数为 7 4 2 1 5 3 1 5；则比7小的有7个数，所有7应该在排序好的数列的第八位，同理3在第四位，对于重复的数字，1在1位和2位（暂且认为第一个1比第二个1小），5和1一样位于6位和7位。

实现方法

首先需要三个数组，第一个数组记录A要排序的数列大小为n，第二个数组B要记录比某个数小的其他数字的个数所以第二个数组的大小应当为K（数列中最大数的大小），第三个数组C为记录排序好了的数列的数组，大小应当为n。
接着需要确定数组最大值并确定B数组的大小。并对每个数由小到大的记录数列中每个数的出现次数。因为是有小到大通过出现次数可以通过前面的所有数的出现次数来确定比这个数小的数的个数，从而确定其位置。
对于重复的数，每排好一个数则对其位置数进行减减操作，以此对完成其余相同的数字进行排位。

参考代码

public class Homework_ds6 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] ar = new int[10];
        for (int i = 0; i < ar.length; i++)
            ar[i] = (int) (Math.random() * 101);
        System.out.println("The random array is:");
        for (int i : ar)
            System.out.print(i + "  ");
        System.out.println();
        CountingSort cs = new CountingSort(ar);
        int[] arr = new int[ar.length];
        arr = cs.sort();
        System.out.println("The array after counting-sorting is:");
        for (int i : arr)
            System.out.print(i + "  ");

    }

}

class CountingSort {
    private int[] array;

    public CountingSort(int[] array) {
        this.array = array;
    }

    public int[] sort() {
        int[] c = new int[findMax(array.length - 1) + 1];
        int[] b = new int[array.length];
        for (int i = 0; i < c.length; i++)
            c[i] = 0;
        for (int i = 0; i < array.length; i++)
            c[array[i]]++;
        for (int i = 1; i < c.length; i++)
            c[i] += c[i - 1];
        for (int i = array.length - 1; i >= 0; i--) {
            b[c[array[i]] - 1] = array[i];
            c[array[i]]--;
        }
        return b;
    }

    private int findMax(int l) {
        if (l == 0)
            return array[0];
        else
            return (array[l] > findMax(l - 1)) ? array[l] : findMax(l - 1);
    }
}

这就是传说中的时间复杂度只有O（n）的排序算法。