以下是计数排序的详细解析，包含基础实现、常见变体的完整代码示例，以及各变体的对比表格：

---

一、计数排序基础实现

原理

通过统计每个元素的出现次数，按顺序累加得到每个元素的最终位置，并填充到结果数组中。

代码示例

public class CountingSort {
    void sort(int[] arr) {
        if (arr.length == 0) return;

        // 找到数据范围
        int min = Arrays.stream(arr).min().getAsInt();
        int max = Arrays.stream(arr).max().getAsInt();
        int range = max - min + 1;

        // 统计每个元素出现的次数
        int[] count = new int[range];
        for (int num : arr) {
            count[num - min]++;
        }

        // 累加统计结果，得到每个元素的最终位置
        for (int i = 1; i < count.length; i++) {
            count[i] += count[i - 1];
        }

        // 反向填充结果数组以保持稳定性
        int[] output = new int[arr.length];
        for (int i = arr.length - 1; i >= 0; i--) {
            int num = arr[i];
            output[count[num - min] - 1] = num;
            count[num - min]--;
        }

        // 将结果复制回原数组
        System.arraycopy(output, 0, arr, 0, arr.length);
    }
}

复杂度分析

• 时间复杂度：O(n + k)（n为元素数量，k为值域范围）。
• 空间复杂度：O(k)。
• 稳定性：稳定（相同值的元素相对顺序不变）。

---

二、常见变体及代码示例

1. 支持负数的计数排序

改进点：通过偏移量处理负数，扩展适用范围。
适用场景：数据包含负值。

public class CountingSortWithNegatives {
    void sort(int[] arr) {
        if (arr.length == 0) return;

        int min = Arrays.stream(arr).min().getAsInt();
        int max = Arrays.stream(arr).max().getAsInt();
        int range = max - min + 1;

        int[] count = new int[range];
        for (int num : arr) {
            count[num - min]++; // 偏移量为min
        }

        for (int i = 1; i < count.length; i++) {
            count[i] += count[i - 1];
        }

        int[] output = new int[arr.length];
        for (int i = arr.length - 1; i >= 0; i--) {
            int num = arr[i];
            output[count[num - min] - 1] = num;
            count[num - min]--;
        }

        System.arraycopy(output, 0, arr, 0, arr.length);
    }
}

2. 原地计数排序

改进点：尝试在原数组上操作，减少额外空间。
适用场景：内存受限场景（但可能牺牲时间效率）。

public class InPlaceCountingSort {
    void sort(int[] arr) {
        if (arr.length == 0) return;

        int min = Arrays.stream(arr).min().getAsInt();
        int max = Arrays.stream(arr).max().getAsInt();
        int range = max - min + 1;

        int[] count = new int[range];
        for (int num : arr) {
            count[num - min]++;
        }

        // 直接在原数组上填充
        int index = 0;
        for (int i = 0; i < count.length; i++) {
            while (count[i] > 0) {
                arr[index++] = i + min;
                count[i]--;
            }
        }
    }
}

3. 并行计数排序

改进点：利用多线程加速计数统计。
适用场景：超大数据集或并行计算环境。

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

public class ParallelCountingSort {
    void sort(int[] arr) {
        if (arr.length == 0) return;

        int min = Arrays.stream(arr).min().getAsInt();
        int max = Arrays.stream(arr).max().getAsInt();
        int range = max - min + 1;
        int[] count = new int[range];

        // 并行统计
        ForkJoinPool pool = new ForkJoinPool();
        pool.invoke(new CountTask(arr, count, 0, arr.length - 1, min));

        // 累加统计结果
        for (int i = 1; i < count.length; i++) {
            count[i] += count[i - 1];
        }

        int[] output = new int[arr.length];
        for (int i = arr.length - 1; i >= 0; i--) {
            int num = arr[i];
            output[count[num - min] - 1] = num;
            count[num - min]--;
        }

        System.arraycopy(output, 0, arr, 0, arr.length);
    }

    // 并行统计任务
    private static class CountTask extends RecursiveAction {
        private final int[] arr;
        private final int[] count;
        private final int start;
        private final int end;
        private final int min;

        CountTask(int[] arr, int[] count, int start, int end, int min) {
            this.arr = arr;
            this.count = count;
            this.start = start;
            this.end = end;
            this.min = min;
        }

        @Override
        protected void compute() {
            if (end - start < 1000) { // 小区间直接统计
                for (int i = start; i <= end; i++) {
                    count[arr[i] - min]++;
                }
            } else {
                int mid = (start + end) / 2;
                invokeAll(new CountTask(arr, count, start, mid, min),
                        new CountTask(arr, count, mid + 1, end, min));
            }
        }
    }
}

---

三、变体对比表格

变体名称	时间复杂度	空间复杂度	稳定性	主要特点	适用场景
基础计数排序	O(n + k)	O(k)	稳定	简单易实现，适用于小范围数据	值域较小且无负数的场景
支持负数的计数排序	O(n + k)	O(k)	稳定	扩展支持负数，需计算最小值	数据包含负值的场景
原地计数排序	O(n + k)	O(k)	稳定	减少输出数组的使用，直接修改原数组	内存受限但时间允许的场景
并行计数排序	O(n/k + k)（并行）	O(k)	稳定	利用多线程加速统计步骤	超大数据集或高性能计算环境

---

四、关键选择原则

1. 基础场景：优先使用基础计数排序，因其简单且适用于小范围数据。
2. 负数支持：当数据包含负值时，需使用支持负数的变体。
3. 内存限制：原地排序适合内存紧张但允许额外统计数组的场景。
4. 性能优化：并行计数排序适用于超大数据集或并行计算环境。
5. 稳定性需求：所有变体均稳定，适用于需保持元素相对顺序的场景（如排序带键值的记录）。

通过选择合适的变体，可在特定场景下优化性能或扩展适用性。例如，并行计数排序在大数据集上显著提升速度，而支持负数的变体扩展了算法的通用性。