Java 中的计数排序-Counting Sort

appte_1219

已于 2023-11-17 18:34:19 修改

阅读量9.4k

点赞数

分类专栏：算法-排序文章标签： java 算法排序算法

于 2023-11-17 18:06:54 首次发布

本文链接：https://blog.csdn.net/ljmlh1219/article/details/134468203

版权

算法-排序专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1. 概述

像 Merge Sort 这样的通用排序算法对输入不做任何假设，因此在最坏的情况下它们无法击败 O（n log n）。相反，计数排序对输入有一个假设，使其成为线性时间排序算法。

在本教程中，我们将熟悉计数排序的机制，然后在 Java 中实现它。

2. 计数排序

与大多数经典排序算法相反，计数排序不会通过比较元素来对给定的输入进行排序。相反，**它假定输入元素是 [0， k] 范围内的 n 个整数。**当 k = O（n）时，计数排序将在 O（n）时间内运行。

请注意，我们不能将计数排序用作通用排序算法。但是，当输入与此假设一致时，它非常快！

2.1. 频率阵列

假设我们要对一个值在 [0， 5] 范围内的输入数组进行排序：
在这里插入图片描述

首先，我们应该计算输入数组中每个数字的出现次数。如果我们用数组 C 表示计数，则 C[i] 表示输入数组中数字 i 的频率：

例如，由于 5 在输入数组中出现了 3 次，因此索引 5 的值等于 3。

现在给定数组 C，我们应该确定每个输入元素小于或等于多少个元素。例如：

一个元素小于或等于零，或者换句话说，只有一个零值，等于 C[0]
两个元素小于或等于一个，等于 C[0] + C[1]
四个值小于或等于 2，即等于 C[0] + C[1] + C[2]

因此，如果我们继续计算 C 中 n 个连续元素的总和，我们可以知道输入数组中有多少元素小于或等于数字 n-1。 无论如何，通过应用这个简单的公式，我们可以将 C 更新如下：
在这里插入图片描述

2.2. 算法

现在我们可以使用辅助数组 C 对输入数组进行排序。以下是计数排序的工作原理：

它反向迭代输入数组
对于每个元素 i，C[i] – 1 表示数字 i 在排序数组中的位置。这是因为存在小于或等于 i 的 C[i] 元素
然后，它在每轮结束时递减 C[i]

为了对示例输入数组进行排序，我们应该首先从数字 5 开始，因为它是最后一个元素。根据 C[5]，有 11 个元素小于或等于数字 5。

所以，5 应该是 11第元素，因此索引为 10：

在这里插入图片描述
由于我们将 5 移动到排序数组中，我们应该递减 C[5]。下一个相反顺序的元素是 2。由于有 4 个元素小于或等于 2，因此这个数字应该是 4第元素：

同样，我们可以为下一个元素 0 找到正确的位置：

如果我们继续反向迭代并适当地移动每个元素，我们最终会得到如下结果：
在这里插入图片描述

3. 计数排序 – Java 实现

3.1. 计算频率阵列

首先，给定一个元素的输入数组和 k，我们应该计算数组 C：

int[] countElements(int[] input, int k) {
    int[] c = new int[k + 1];
    Arrays.fill(c, 0);

    for (int i : input) {
        c[i] += 1;
    }

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

    return c;
}

让我们分解方法签名：

input 表示我们将要排序的数字数组
输入数组是 [0， k] 范围内的整数数组，因此 k 表示输入中的最大数字
返回类型是表示 C数组的整数数组

以下是 countElements 方法的工作原理：

首先，我们初始化了 C 数组。由于 [0， k] 范围包含 k+1 个数字，我们正在创建一个能够包含 k+1 个数字的数组
然后，对于输入中的每个数字，我们正在计算该数字的频率
最后，我们将连续的元素相加，以了解有多少元素小于或等于特定数字

此外，我们可以验证 countElements 方法是否按预期工作：

@Test
void countElements_GivenAnArray_ShouldCalculateTheFrequencyArrayAsExpected() {
    int k = 5;
    int[] input = { 4, 3, 2, 5, 4, 3, 5, 1, 0, 2, 5 };
    
    int[] c = CountingSort.countElements(input, k);
    int[] expected = { 1, 2, 4, 6, 8, 11 };
    assertArrayEquals(expected, c);
}

3.2. 对输入数组进行排序

现在我们可以计算频率数组了，我们应该能够对任何给定的数字集进行排序：

int[] sort(int[] input, int k) {
    int[] c = countElements(input, k);

    int[] sorted = new int[input.length];
    for (int i = input.length - 1; i >= 0; i--) {
        int current = input[i];
	sorted[c[current] - 1] = current;
	c[current] -= 1;
    }

    return sorted;
}

排序方法的工作原理如下：

首先，它计算 C 数组
然后，它反向迭代输入数组，对于输入中的每个元素，在排序数组中找到其正确的位置。这我第元素应为C[i]第元素。由于 Java 数组是零索引的，因此 C[i]-1 条目是C[i]第元素 – 例如，sorted[5] 是排序数组中的第六个元素
每次我们找到匹配项时，它都会递减相应的 C[i] 值

同样，我们可以验证排序方法是否按预期工作：

@Test
void sort_GivenAnArray_ShouldSortTheInputAsExpected() {
    int k = 5;
    int[] input = { 4, 3, 2, 5, 4, 3, 5, 1, 0, 2, 5 };

    int[] sorted = CountingSort.sort(input, k);

    // Our sorting algorithm and Java's should return the same result
    Arrays.sort(input);
    assertArrayEquals(input, sorted);
}

4. 重新审视计数排序算法

4.1. 复杂性分析

大多数经典的排序算法（如合并排序）仅通过比较输入元素来对任何给定的输入进行排序。 这些类型的排序算法称为比较排序。在最坏的情况下，比较排序至少需要 O（n log n）来对 n 个元素进行排序。

另一方面，计数排序不会通过比较输入元素来对输入进行排序，因此它显然不是比较排序算法。

让我们看看对输入进行排序需要花费多少时间：

它在 O（n+k）时间内计算 C 数组：它一次迭代一个大小为 n 的输入数组，然后迭代 O（k）中的 C——所以总共是 O（n+k）
计算 C 后，它通过迭代输入数组并在每次迭代中执行一些原始操作来对输入进行排序。因此，实际的排序操作需要 O（n）
总的来说，计数排序需要 O（n+k）时间才能运行：