Question

get_number()返回一个整数。我将调用它30次并计算返回的不同整数的数量。我的计划是将这些数字放入std::array<int,30>，对其进行排序，然后使用std::unique。

这是一个很好的解决方案吗？还有更好的吗？这段代码将成为我程序的瓶颈。

我认为应该有一个基于哈希的解决方案，但是当我只有30个元素时，它的开销可能太大了？

修改我将 unique 更改为 distinct 。例如：

{1,1,1,1} => 1
{1,2,3,4} => 4
{1,3,3,1} => 2

Answer 1

我会使用std::set<int>因为它更简单：

std::set<int> s;
for(/*loop 30 times*/)
{
   s.insert(get_number());
}
std::cout << s.size() << std::endl; // You get count of unique numbers

如果您想计算每个唯一号码的返回时间，我建议map

std::map<int, int> s;
for(int i=0; i<30; i++)
{
  s[get_number()]++;
}

cout << s.size() << std::endl;  // total count of distinct numbers returned

for (auto it : s)
{
  cout << it.first << " " << it.second<< std::endl;  // each number and return counts
}

Answer 2

最简单的解决方案是使用std::map：

std::map<int, size_t> counters;

for (size_t i = 0; i != 30; ++i) {
    counters[getNumber()] += 1;
}

std::vector<int> uniques;
for (auto const& pair: counters) {
    if (pair.second == 1) { uniques.push_back(pair.first); }
}

// uniques now contains the items that only appeared once.

Answer 3

使用std::map，std::set或std::sort算法会给您O(n*log(n))的复杂性。对于少量到大量的元素，它是完全正确的。 但是你使用一个已知的整数范围，这为许多优化打开了大门。

正如您所说（在评论中）您的整数范围已知并且简短：[0..99]。我建议实施修改后的计数排序。请参阅：http://en.wikipedia.org/wiki/Counting_sort

您可以在排序时自行计算不同项目的数量，从而无需进行std::unique调用。整个复杂性将是O(n)。另一个优点是所需的内存与输入项的数量无关。如果您有30.000.000.000个整数要排序，则不需要一个补充字节来计算不同的项目。

即使允许的整数值范围很大，[0..10.000.000]所消耗的内存也会非常低。实际上，优化版本每个允许的整数值可能消耗低至1位。这不到2 MB内存或笔记本电脑RAM的1/1000。

这是一个简短的示例程序：

#include <cstdlib>
#include <algorithm>
#include <iostream>
#include <vector>

// A function returning an integer between [0..99]
int get_number()
{
    return rand() % 100;
}


int main(int argc, char* argv[])
{
    // reserves one bucket for each possible integer
    // and initialize to 0
    std::vector<int> cnt_buckets(100, 0);
    int nb_distincts = 0;

    // Get 30 numbers and count distincts
    for(int i=0; i<30; ++i)
    {
        int number = get_number();
        std::cout << number << std::endl;
        if(0 == cnt_buckets[number])
            ++ nb_distincts;

        // We could optimize by doing this only the first time
        ++ cnt_buckets[number];
    }

    std::cerr << "Total distincts numbers: " << nb_distincts << std::endl;
}

你可以看到它有效：

$ ./main | sort | uniq | wc -l
Total distincts numbers: 26
26

Answer 4

最简单的方法就是使用std::set。

std::set<int> s;
int uniqueCount = 0;

for( int i = 0; i < 30; ++i )
{
    int n = get_number();

    if( s.find(n) != s.end() ) {
        --uniqueCount;
        continue;
    }

    s.insert( n );
}

// now s contains unique numbers
// and uniqueCount contains the number of unique integers returned

Answer 5

使用array和sort似乎不错，但如果您只需要计算不同的值，则unique可能有点矫枉过正。以下函数应返回排序范围内的不同值的数量。

template<typename ForwardIterator>
size_t distinct(ForwardIterator begin, ForwardIterator end) {
  if (begin == end) return 0;

  size_t count = 1;
  ForwardIterator prior = begin;
  while (++begin != end)
  {
    if (*prior != *begin)
      ++count;

    prior = begin;
  }
  return count;
}

与基于set - 或map的方法相比，这个方法不需要任何堆分配，并且元素连续存储在内存中，因此它应该更快。渐近时间复杂度为O(N log N)，与使用关联容器时相同。我敢打赌，使用std::sort后跟std::unique的原始解决方案比使用std::set要快得多。

Answer 6

尝试一套，尝试无序套装，尝试排序和独特，尝试其他看似有趣的东西。

然后测量每一个。如果您想要最快的实现，那么尝试实际代码并了解其真正的功能是无可替代的。

您的特定平台和编译器以及其他细节肯定会很重要，因此请在尽可能接近生产中运行的环境中进行测试。

计算不同数字数量的时间有效方法

6 个答案: