计数排序（Counting Sort）是一种非比较型的排序算法，适用于对整数或有限范围内的数据进行排序。它的核心思想是通过统计每个元素的出现次数，然后根据统计结果将元素放回正确的位置。计数排序的时间复杂度为 O(n + k)，其中 n 是待排序元素的数量，k 是数据的范围大小。

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

1. 计数排序的特征

当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 Θ(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。

由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序中的算法来排序数据范围很大的数组。

通俗地理解，例如有 10 个年龄不同的人，统计出有 8 个人的年龄比 A 小，那 A 的年龄就排在第 9 位,用这个方法可以得到其他每个人的位置,也就排好了序。当然，年龄有重复时需要特殊处理（保证稳定性），这就是为什么最后要反向填充目标数组，以及将每个数字的统计减去 1 的原因。

 算法的步骤如下：

  1. 统计频率：遍历待排序的列表，统计每个元素出现的次数，存储在一个计数数组中。

  2. 累加频率：将计数数组中的值累加，得到每个元素在排序后列表中的最后一个位置。

  3. 构建有序列表：遍历待排序的列表，根据计数数组中的位置信息，将元素放到正确的位置。

  4. 输出结果：将排序后的列表输出。

2. 动图演示

假设有一个待排序的列表 [4, 2, 2, 8, 3, 3, 1]，数据的范围是 1 到 8，计数排序的过程如下：

  1. 统计频率：

    • 初始化计数数组 count，大小为 9（范围 0-8）。

    • 遍历列表，统计每个元素的出现次数：

      • count[1] = 1

      • count[2] = 2

      • count[3] = 2

      • count[4] = 1

      • count[8] = 1

    • 计数数组：[0, 1, 2, 2, 1, 0, 0, 0, 1]。

  2. 累加频率：

    • 将计数数组中的值累加，得到每个元素的最终位置：

      • count[1] = 1

      • count[2] = 1 + 2 = 3

      • count[3] = 3 + 2 = 5

      • count[4] = 5 + 1 = 6

      • count[8] = 6 + 1 = 7

    • 累加后的计数数组：[0, 1, 3, 5, 6, 6, 6, 6, 7]。

  3. 放置元素：

    • 初始化结果数组 output，大小为 7。

    • 遍历原始列表，根据计数数组中的位置信息，将元素放入结果数组：

      • 元素 4：count[4] = 6，放入 output[5]，count[4] -= 1。

      • 元素 2：count[2] = 3，放入 output[2]，count[2] -= 1。

      • 元素 2：count[2] = 2，放入 output[1]，count[2] -= 1。

      • 元素 8：count[8] = 7，放入 output[6]，count[8] -= 1。

      • 元素 3：count[3] = 5，放入 output[4]，count[3] -= 1。

      • 元素 3：count[3] = 4，放入 output[3]，count[3] -= 1。

      • 元素 1：count[1] = 1，放入 output[0]，count[1] -= 1。

    • 结果数组：[1, 2, 2, 3, 3, 4, 8]。

  4. 输出结果：

    • 排序后的列表：[1, 2, 2, 3, 3, 4, 8]。

实例

def counting_sort(arr):
    # 找到列表中的最大值
    max_val = max(arr)
    # 初始化计数数组
    count = [0] * (max_val + 1)
    # 统计每个元素的出现次数
    for num in arr:
        count[num] += 1
    # 累加计数数组，得到每个元素的最终位置
    for i in range(1, len(count)):
        count[i] += count[i - 1]
    # 初始化结果数组
    output = [0] * len(arr)
    # 反向遍历原始列表，将元素放入结果数组
    for num in reversed(arr):
        output[count[num] - 1] = num
        count[num] -= 1
    return output

# 示例
arr = [4, 2, 2, 8, 3, 3, 1]
sorted_arr = counting_sort(arr)
print(sorted_arr)  # 输出: [1, 2, 2, 3, 3, 4, 8]

时间复杂度

  • 统计频率：O(n)，遍历列表一次。

  • 累加频率：O(k)，遍历计数数组一次。

  • 放置元素：O(n)，遍历列表一次。

  • 总时间复杂度：O(n + k)，其中 n 是列表长度，k 是数据的范围大小。

空间复杂度

  • O(n + k)，需要额外的计数数组和结果数组。

优缺点

  • 优点：

    • 时间复杂度为 O(n + k)，当 k 较小时，性能优异。

    • 稳定排序算法（相同元素的相对顺序不会改变）。

  • 缺点：

    • 仅适用于整数或有限范围内的数据。

    • 当数据范围 k 很大时，空间复杂度较高。

适用场景

  • 数据范围较小的整数排序。

  • 需要稳定排序算法的场景。

  • 适合外部排序（如对磁盘文件进行排序）。

代码实现

JavaScript

实例

function countingSort(arr, maxValue) {
    var bucket = new Array(maxValue+1),
        sortedIndex = 0;
        arrLen = arr.length,
        bucketLen = maxValue + 1;

    for (var i = 0; i < arrLen; i++) {
        if (!bucket[arr[i]]) {
            bucket[arr[i]] = 0;
        }
        bucket[arr[i]]++;
    }

    for (var j = 0; j < bucketLen; j++) {
        while(bucket[j] > 0) {
            arr[sortedIndex++] = j;
            bucket[j]--;
        }
    }

    return arr;
}

Python

实例

def countingSort(arr, maxValue):
    bucketLen = maxValue+1
    bucket = [0]*bucketLen
    sortedIndex =0
    arrLen = len(arr)
    for i in range(arrLen):
        if not bucket[arr[i]]:
            bucket[arr[i]]=0
        bucket[arr[i]]+=1
    for j in range(bucketLen):
        while bucket[j]>0:
            arr[sortedIndex] = j
            sortedIndex+=1
            bucket[j]-=1
    return arr

Go

实例

func countingSort(arr []int, maxValue int) []int {
        bucketLen := maxValue + 1
        bucket := make([]int, bucketLen) // 初始为0的数组

        sortedIndex := 0
        length := len(arr)

        for i := 0; i < length; i++ {
                bucket[arr[i]] += 1
        }

        for j := 0; j < bucketLen; j++ {
                for bucket[j] > 0 {
                        arr[sortedIndex] = j
                        sortedIndex += 1
                        bucket[j] -= 1
                }
        }

        return arr
}

Java

实例

public class CountingSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int maxValue = getMaxValue(arr);

        return countingSort(arr, maxValue);
    }

    private int[] countingSort(int[] arr, int maxValue) {
        int bucketLen = maxValue + 1;
        int[] bucket = new int[bucketLen];

        for (int value : arr) {
            bucket[value]++;
        }

        int sortedIndex = 0;
        for (int j = 0; j < bucketLen; j++) {
            while (bucket[j] > 0) {
                arr[sortedIndex++] = j;
                bucket[j]--;
            }
        }
        return arr;
    }

    private int getMaxValue(int[] arr) {
        int maxValue = arr[0];
        for (int value : arr) {
            if (maxValue < value) {
                maxValue = value;
            }
        }
        return maxValue;
    }

}

PHP

实例

function countingSort($arr, $maxValue = null)
{
    if ($maxValue === null) {
        $maxValue = max($arr);
    }
    for ($m = 0; $m < $maxValue + 1; $m++) {
        $bucket[] = null;
    }

    $arrLen = count($arr);
    for ($i = 0; $i < $arrLen; $i++) {
        if (!array_key_exists($arr[$i], $bucket)) {
            $bucket[$arr[$i]] = 0;
        }
        $bucket[$arr[$i]]++;
    }

    $sortedIndex = 0;
    foreach ($bucket as $key => $len) {
       
        if($len !== null){
            for($j = 0; $j < $len; $j++){
                $arr[$sortedIndex++] = $key;
            }
        }
    }

    return $arr;
}

C

实例

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void print_arr(int *arr, int n) {
        int i;
        printf("%d", arr[0]);
        for (i = 1; i < n; i++)
                printf(" %d", arr[i]);
        printf("\n");
}

void counting_sort(int *ini_arr, int *sorted_arr, int n) {
        int *count_arr = (int *) malloc(sizeof(int) * 100);
        int i, j, k;
        for (k = 0; k < 100; k++)
                count_arr[k] = 0;
        for (i = 0; i < n; i++)
                count_arr[ini_arr[i]]++;
        for (k = 1; k < 100; k++)
                count_arr[k] += count_arr[k - 1];
        for (j = n; j > 0; j--)
                sorted_arr[--count_arr[ini_arr[j - 1]]] = ini_arr[j - 1];
        free(count_arr);
}

int main(int argc, char **argv) {
        int n = 10;
        int i;
        int *arr = (int *) malloc(sizeof(int) * n);
        int *sorted_arr = (int *) malloc(sizeof(int) * n);
        srand(time(0));
        for (i = 0; i < n; i++)
                arr[i] = rand() % 100;
        printf("ini_array: ");
        print_arr(arr, n);
        counting_sort(arr, sorted_arr, n);
        printf("sorted_array: ");
        print_arr(sorted_arr, n);
        free(arr);
        free(sorted_arr);
        return 0;
}

参考地址：

https://github.com/hustcc/JS-Sorting-Algorithm/blob/master/8.countingSort.md

https://zh.wikipedia.org/wiki/%E8%AE%A1%E6%95%B0%E6%8E%92%E5%BA%8F