Question

我正在阅读有关计算排序的信息，其中一个步骤是

for(i = 1 to k) 
   c[i] = c[i]+c[i-1];

为什么我们需要这一步？

为什么我们不能使用它

for(i = 0 to k)
    while(c[i]--)
        Output i/Use i as key.

我想到的一个问题是我们是否想要数据本身（可能就像一个引用特定索引的字符串）。

但是，我们可以使用2d Vector。这种方法有什么不好，我们将数据从0到99排序。

int a[100];
for(int i = 0 ; i < 100; ++i)
    a[i] = 0;
string s;
vector<vector<string>> data(100);
int temp;
for(int i = 0 ; i < n ; ++i){
    cin>>temp;
    a[temp]++;
    getline(cin,s);
    data[temp].push_back(s);
}

for(int i = 0 ; i < 100; ++i){
    int current = 0;
    while(a[i]--){
        cout<<data[i][current]<<" ";
        ++current;
    }
}

Answer 1

编辑：我已根据评论对此答案进行了重大修改。

有两种情况可能需要使用计数排序。首先，您可能有一组要排序的实际数字，目标是对这些数字进行排序。其次，您可能有一组要排序的值，每个值都根据某个固定范围内的数字键进行排序。

在第一种情况下 - 你纯粹对数字进行排序 - 你没有理由需要将直方图转换为累积直方图。由于数字只是数字，因此您可以对数组进行排序，而不是将初始值重新排列为排序顺序，而只是根据频率直方图生成新的数字列表。例如，您可以这样做：

/* Initialize histogram. */
const unsigned kMaxValue = 100;
std::vector<unsigned> counts(kMaxValue);

/* Read values. */
const unsigned kNumValues = 100;
for (unsigned i = 0; i < kNumValues; i++) {
    unsigned nextValue;
    std::cin >> nextValue; // Don't forget error-checking!

    counts[nextValue]++;
}

/* Output values. */
std::vector<unsigned> result;
result.reserve(kNumValues);
for (unsigned i = 0; i < counts.size(); i++) {
    for (unsigned j = 0; j < counts[i]; j++) {
        result.push_back(i);
    }
}

请注意，添加到result向量的数字不会从输入中读取，而是仅使用循环计数器生成。

在第二种情况下 - 你有要排序的元素，每个元素都有一个键 - 它不可能使用上述方法，因为你不能仅通过计数来重新生成元素。相反，您需要做一些更聪明的事情，实际上需要重新排列输入序列中的元素。

这是频率直方图的概念所在。基本思想如下 - 我们想要为输入数组中的每个元素确定该元素应该在排序数组中结束的索引。让我们假设我们首先得到输入数组的频率直方图H.该直方图具有H [i]告诉我们有关键i有多少不同元素的属性。现在，假设我们制作累积频率直方图C，其中C [i] = C [0] + C [1] + ... + C [i]。在这种情况下，C [i]告诉我们输入数组中有多少元素的键小于或等于它。

想象一下，你只有输入数组和累积频率直方图。你能用它做什么？好吧，假设你有一些来自原始数组的元素A [i]。基于累积频率直方图，我们知道阵列中存在C [i]元素，其键小于或等于A [i]。因此，如果我们想重新排序输入数组以便所有内容都按排序顺序排列，我们可以将元素A [i]放在位置C [key（A [i]）] - 1，因为有C [key（A [ i]）] - 1个小于或等于它的元素。假设数组中没有重复的值，遍历数组A并根据此公式重新定位所有内容将正确地按顺序排列数组。

如果我们有重复，事情会有点复杂。假设有两个元素A [i]和A [j]，其中key（A [i]）= key（A [j]）。在这种情况下，我们不能将两个元素放在位置C [key（A [i]）] - 1，因为它们会发生冲突。但是，我们可以做到以下几点。我们将其中一个元素放在位置C [key（A [i]）] - 1处，然后通过从C [key（A [i]）]中减去1来破坏性地修改C数组。然后，当我们看到元素A [j]时，我们将它放在位置C [key（A [j]）] - 1，这是一个空槽。直观地，具有累积频率直方图的整个想法是能够通过存储在具有给定键的任何特定项目之前将有多少对象来立即知道在何处定位对象。每当我们看到带有某个键的项目时，我们想要指出对于具有相同键的任何未来项目，将会有更少的项目在它之前。

那么为什么要向后扫描呢？我们可以很容易地进行正向扫描，但向后扫描的优势在于它可以稳定地分析元素。也就是说，如果您有多个具有相同键的元素，则它们在输出序列中的输出顺序与输入序列中的顺序相同。

这里有一些代码展示了如何使用它：

/* Initialize histogram. */
const unsigned kMaxValue = 100;
std::vector<unsigned> counts(kMaxValue);

/* Read values. Each value will be a string with an associated key. */
const unsigned kNumValues = 100;
std::vector<std::pair<unsigned, std::string>> elems;
elems.reserve(kNumValues);

for (unsigned i = 0; i < kNumValues; i++) {
    unsigned key;
    std::cin >> key; // Don't forget error-checking!

    std::string value;
    std::cin >> value;       // Don't forget error-checking!
    elems.push_back(std::make_pair<key, value>);

    counts[key]++;
}

/* Transform histogram into cumulative histogram. */
for (unsigned i = 1; i < counts.size(); i++) {
   counts[i] += counts[i - 1];
}

/* Output values. */
std::vector<unsigned> result(kNumValues);
for (unsigned i = counts.size() - 1; i >= 0 && i < counts.size(); i--) { // See note
    result[--counts[elems[i].first]] = elems[i].second;
}

由于使用无符号值倒计时，循环有点奇怪。 This question详细说明了如何正确处理。

计数排序：为什么我们需要先前计数的总和？

1 个答案: