如何从向量或数组中选择最常见的数字？（Top5 toLIST）C++

我有一个带整数的向量。我想选择最常见的数字。我想列出前五名。例如：

std::vector<int> numbers = {32, 32, 32, 12, 12, 11, 11, 11, 9};

最常见的数字是：前1:32、前2:11、前3:12、前4:9

选择它们后，我想将其存储到另一个向量中：最常见的数字。

您可以创建一个无序地图mp，在这里可以存储每个数字的计数，如mp[32]=3

接下来，您需要找到前五个元素

时间复杂度：Omlogm：您可以按降序对地图进行排序，您必须使用额外的向量，并获取前5个元素

时间复杂度：Om：或者您可以在整个映射上迭代5次，以获得顶级文件元素。每次迭代时，都会找到频率最高的数字，这在前五位向量中还没有出现

---

m：地图中的条目数。

有很多方法可以实现这一点。其中之一可能是

std::vector numbers = {32, 32, 32, 12, 12, 11, 11, 11, 9};
int maxNumber = *std::max_element(numbers.begin(), numbers.end())
std::vector<int> occurrences(maxNumber + 1, 0);
for(auto& value : numbers)
{
   occurrences[value]++;
}

---

然后，您只需要在跟踪索引的同时对数组进行排序。这是另一个问题的主题。

我已经做了这个例子，并把评论放在了一起。它至少需要C++11

#include <map>
#include <vector>
#include <iostream>
#include <algorithm>

int main(void) {
  std::map<int, int> ans;
  std::vector<int> numbers = {32, 32, 32, 12, 12, 11, 11, 11, 9};
  std::vector<std::pair<int, int>> sorted;
  std::vector<int> common;
  // Step 1 Accumulate into a map, counting occurrences
  for (auto number : numbers) {
    ans[number]++;
  }
  // Step 2 Make a linear list, putting the count first then the value
  for (auto& ent : ans) {
    sorted.emplace_back(ent.second, ent.first);
  }
  // Step 3 sort it, by count ascending
  std::sort(std::begin(sorted), std::end(sorted));

  // Step 4 Get commonest 5 (or fewer)
  for (int i = 1; i<= 5; ++i) {
    int index = sorted.size() - i;
    if (index >= 0) {
      common.push_back(sorted[index].second);
    }
  }

  // Step 5 print out
  for (auto i : common) {
    std::cout << i << std::endl;
  }
  return 0;
}

---

这是另一个算法，任何k加上一个合适的缓存位置的代价都会增加

1.首先将所有元素存储在

2.将成对向量中的所有元素转储到

std::vector<std::pair<int, int>> temp;  
for(const auto& ele: m) {
 temp.emplace_back(ele.first ,  ele.second);   
}

3.现在使用第n_元素在

std::nth_element( temp.begin(), temp.begin()+k ,
temp.end(), [](const auto& p1, const auto& p2) {
        // Strict weak ordering
        if (p1.second > p2.second) {
            return true;
        }  if (p1.second < p2.second) {  
            return false;
        }
        return p1.first > p2.first; // We have to print large element first
    } );

4.显示输出

std::for_each( temp.begin(), temp.begin() +k - 1, [](const auto & p) {
    std::cout << p.first << " ";
});

---

你可以这样做：创建一个集合，这样你就可以去掉重复项，然后找到向量中集合中每个项的频率，用这个结果创建一个类似int的对，int将该对推到向量中，最后使用你自己的谓词对其排序： 现在，对于顶部的x，如果您确定这会产生什么后果，您可以执行for循环或调整向量大小

std::vector<int> numbers{32, 32, 32, 12, 12, 11, 11, 11, 9};
std::set<int> mySet(numbers.begin(), numbers.end());
std::vector<std::pair<int, int>> result{};

for(const auto& x : mySet)
{
    result.push_back(std::make_pair(x , std::count(numbers.begin(), numbers.end(), x)));
}
std::sort(result.begin(), result.end(), [](const std::pair<int, int>& a, const std::pair<int, int>& b){return (b.second < a.second);});
//result.resize(3);
std::cout << "Top: " << std::endl;
for(const auto& x : result)
{
   std::cout << x.first << ':' << x.second << std::endl;
}

结果将是：

顶部：11:3 32:3 12:2 9:1

---

我们不需要完全分类。部分排序就可以了。这太过分了，应该选择std:：unordered\u映射prefered@POW明白了，在这种情况下，无序的_图是首选。部分排序就可以了。加上std：：count是一个线性函数。您的第一个循环是N*N最坏的情况。在4种情况下，请分别使用std:：for__n@Verthais谢谢，是的，std:：for_每一个都可以使用。不确定哪个libstdc++有它。如果唯一数字少于k，它会打印出垃圾，不是吗？

std::vector<int> numbers{32, 32, 32, 12, 12, 11, 11, 11, 9};
std::set<int> mySet(numbers.begin(), numbers.end());
std::vector<std::pair<int, int>> result{};

for(const auto& x : mySet)
{
    result.push_back(std::make_pair(x , std::count(numbers.begin(), numbers.end(), x)));
}
std::sort(result.begin(), result.end(), [](const std::pair<int, int>& a, const std::pair<int, int>& b){return (b.second < a.second);});
//result.resize(3);
std::cout << "Top: " << std::endl;
for(const auto& x : result)
{
   std::cout << x.first << ':' << x.second << std::endl;
}