【排序算法】排序算法-计数排序(Counting Sort)

概述

• 冒泡、选择、插入、归并、快速、希尔、堆排序，都是基于比较的排序
  • 平均复杂度最低是O(nlog(n))
• 计数、桶、基数排序，都不是基于比较的排序
  • 是典型的空间换时间，在某些时候，平均时间复杂度可以比O(nlog(n))更低

核心思想

• 统计每个整数在序列中出现的次数，进而推导出每个整数在有序序列中的索引

执行流程

• 首先需要找出需要排序的数组或者集合arr中的最大值max
• 创建一个max + 1 长度的数组counts[]
• 遍历数组,统计数组中不同值的个数,数组中每遍历一个值arr[i],就令counts[arr[i]]++;
• 然后再遍历counts数组,将不为0的索引处的值依次放到arr数组中

示例

代码(版本1)

public class CountingSort {

    public static void sort(int[] arr) {
        //找出最大值
        int max = arr[0];
        //数组长度
        int n = arr.length;
        for (int i = 1; i < n; ++i) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        //开辟内存空间,存储每个整数出现的次数
        int[] counts = new int[1 + max];
        //统计每个整数出现的次数
        for (int i = 0; i < n; ++i) {
            ++counts[arr[i]];
        }

        //根据整数出现的次数,对整数进行排序
        int index = 0;
        for (int i = 0; i < counts.length; ++i) {
            while (counts[i]-- > 0) {
                arr[index++] = i;
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = new int[]{7,1,2,3,4,5,6,6,7};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

测试

存在问题

• 无法对负整数进行排序
• 及其浪费内存空间
• 是个不稳定的排序

代码(版本2)(解决上面的问题)

public static void sort(int[] arr) {
        int n = arr.length;
        if (n <= 1) {
            return;
        }

        //寻找最值
        int max = arr[0];
        int min = arr[0];
        for (int i = 1; i < n; ++i) {
            max = Math.max(max, arr[i]);
            min = Math.min(min, arr[i]);
        }

        //开辟内存空间,存储次数
        int[] counts = new int[max - min + 1];
        //统计每个整数出现的次数, arr数组中元素对应在counts数组中的索引是arr[i] - min;
        for (int i = 0; i < n; ++i) {
            ++counts[arr[i] - min];
        }

        //counts数组不再保存次数,将其改为前缀和
        for (int i = 1; i < counts.length; ++i) {
            counts[i] += counts[i - 1];
        }

        //使用新数组暂存所有的元素
        int[] newArray = new int[n];
        int i = n - 1;
        //从后往前遍历元素,将它放到有序数组中的合适位置,为了保证稳定性
        while (i >= 0) {
            //--counts[arr[i] - min]: 找到arr[i]的新位置
            newArray[--counts[arr[i] - min]] = arr[i];
            --i;
        }

        //将有序数组赋值回原数组
        while (++i < n) {
            arr[i] = newArray[i];
        }

    }

复杂度

• 时间复杂度: O(n + k),n为元素个数,k为元素[min, max]的范围大小
• 空间复杂度: O(n + k),n为元素个数,k为元素[min, max]的范围大小

测试

执行流程(图解)

• 原数组
  
• 求出数组中的min和max,定义一个新的counts数组,大小为max - min + 1,用来存放每个元素出现的次数
  
• 求出counts数组的前缀和
  
• 然后从右往左遍历原数组
• 右边第一个元素5,对应counts数组的前缀和为4,4自减,就得到的5在数组中的下标3并放进去,这里会使用一个新数组暂存数据
  
• 然后遍历到4,4对应counts数组中的前缀和为2,–2,所以4对应的索引为1
  
• 然后遍历7,7在counts数组中对应的前缀和是7,7–,所以新的索引位置为6
  
• 。。。
• 然后同上,最后结果为
  

使用场景

• 对具有一定范围的数进行排序