C++ 在列表中查找最常见的元素（C+；+；STL）？

我有一个程序，我必须在整数列表中找到最常见的元素。我使用下面的程序执行此操作，但问题是，我怀疑擦除函数与

countrepeation（）

函数中的迭代器增量弄乱了。我的问题是如何解决这个问题，或者如果不是这个问题，是什么问题

---

提前谢谢

这可能就是您想要的：

#include <iostream>
#include <list>
#include <vector>
#include <map>

using namespace std;

list <char> l;
map<char, int> ans;
int main()
{
    char c;
   do{
       c = getchar();
       l.push_back(c);
   }while(c != '0');
   for(auto chr: l){
       ans[chr]++;
   }
   char ch;
   int mx = 0;
   for(auto k: ans){
       if(k.second > mx)
       {
           ch = k.first;
           mx = k.second;
       }
   }
   cout<<ch<<" : "<<mx;
}

#包括
#包括
#包括
#包括
使用名称空间std；
清单l；
地图；
int main（）
{
字符c；
做{
c=getchar（）；
l、 推回（c）；
}而（c！=“0”）；
用于（自动颜色：l）{
ans[chr]++；
}
char ch；
int mx=0；
用于（自动k:ans）{
如果（k秒>mx）
{
ch=k.第一；
mx=k秒；
}
}
cout这可能是您正在寻找的：

#include <iostream>
#include <list>
#include <vector>
#include <map>

using namespace std;

list <char> l;
map<char, int> ans;
int main()
{
    char c;
   do{
       c = getchar();
       l.push_back(c);
   }while(c != '0');
   for(auto chr: l){
       ans[chr]++;
   }
   char ch;
   int mx = 0;
   for(auto k: ans){
       if(k.second > mx)
       {
           ch = k.first;
           mx = k.second;
       }
   }
   cout<<ch<<" : "<<mx;
}

#包括
#包括
#包括
#包括
使用名称空间std；
清单l；
地图；
int main（）
{
字符c；
做{
c=getchar（）；
l、 推回（c）；
}而（c！=“0”）；
用于（自动颜色：l）{
ans[chr]++；
}
char ch；
int mx=0；
用于（自动k:ans）{
如果（k秒>mx）
{
ch=k.第一；
mx=k秒；
}
}
cout您有几个问题。首先，正如您所怀疑的，是不正确地使用了
erase
。当您删除迭代器时，它会使迭代器无效。之后使用迭代器都是未定义的行为。由于
erase
返回下一个有效迭代器，您可以像

for (START = l.begin(); START != l.end();) { // do not increment here
    if (*START) {
        counter++;
        START = l.erase(START); // erase and get next
    }
    else
    {
        ++START; // go to next
    }
}

因此，现在至少可以在列表中循环。不幸的是，在
main
中仍然会有一个无效的迭代器。您将
START
从
main
传递到
countrepeation
，当该迭代器从列表中删除时，就会有一个无效的迭代器。您需要做的是获得一个新的
begin
迭代器每次迭代都从列表中删除r，因为您总是删除第一个元素

for (START = l.begin(); START != l.end(); START = l.begin()) {
    m.push_back(countRepetition(START));
}


另一个问题是，只需检查字符是否不是
0
。如果要计算重复次数，则需要确保检查迭代器是否是同一个字符。我将留给您实现


我还想指出，有一种更简单的方法来完成所有这些。一个
std:：map
可以让你非常容易地构建一个直方图。将它与
std:：max_元素
结合起来，你就可以按照

int main()
{
    std::map<char, int> histogram;
    while ('0' != (number = getchar()))
        ++histogram[number]; // add to map, increment count of occurances

    auto most_frequent = *std::max_element(histogram.begin(), 
                                           histogram.end(), 
                                           [](const auto& lhs, const auto& rhs) { return lhs.second < rhs.second; }).first;
    std::cout << most_frequent;    
    return 0;
}

intmain（）
{
地图直方图；
而（'0'！=（number=getchar（）））
++直方图[数字]；//添加到地图，增加发生次数
auto most_frequency=*std:：max_元素（histogram.begin（），
直方图。结束（），
[]（const auto&lhs，const auto&rhs）{返回lhs.secondstd:：cout您有两个问题。首先，正如您所怀疑的，是不正确地使用了
擦除
。当您擦除迭代器时，它会使迭代器无效。之后使用迭代器都是未定义的行为。由于
擦除
返回下一个有效迭代器，您可以像

for (START = l.begin(); START != l.end();) { // do not increment here
    if (*START) {
        counter++;
        START = l.erase(START); // erase and get next
    }
    else
    {
        ++START; // go to next
    }
}

因此，现在至少可以在列表中循环。不幸的是，在
main
中仍然会有一个无效的迭代器。您将
START
从
main
传递到
countrepeation
，当该迭代器从列表中删除时，就会有一个无效的迭代器。您需要做的是获得一个新的
begin
迭代器每次迭代都从列表中删除r，因为您总是删除第一个元素

for (START = l.begin(); START != l.end(); START = l.begin()) {
    m.push_back(countRepetition(START));
}


另一个问题是，只需检查字符是否不是
0
。如果要计算重复次数，则需要确保检查迭代器是否是同一个字符。我将留给您实现


我还想指出，有一种更简单的方法来完成所有这些。一个
std:：map
可以让你非常容易地构建一个直方图。将它与
std:：max_元素
结合起来，你就可以按照

int main()
{
    std::map<char, int> histogram;
    while ('0' != (number = getchar()))
        ++histogram[number]; // add to map, increment count of occurances

    auto most_frequent = *std::max_element(histogram.begin(), 
                                           histogram.end(), 
                                           [](const auto& lhs, const auto& rhs) { return lhs.second < rhs.second; }).first;
    std::cout << most_frequent;    
    return 0;
}

intmain（）
{
地图直方图；
而（'0'！=（number=getchar（）））
++直方图[数字]；//添加到地图，增加发生次数
auto most_frequency=*std:：max_元素（histogram.begin（），
直方图。结束（），
[]（const auto&lhs，const auto&rhs）{返回lhs.secondstd：：cout您的问题是在任何地方都使用全局变量。
全局开始在两个循环中更改，因此您只访问第一个循环一次，然后在第二个函数中再次更改它，并且不会再次执行第一个循环

为什么要使用全局变量？你不应该使用它们，而应该使用局部变量。
你的问题是你在任何地方都使用全局变量。
全局开始在两个循环中更改，因此您只访问第一个循环一次，然后在第二个函数中再次更改它，并且不会再次执行第一个循环

为什么要使用全局变量？不应该使用它们，而应该使用局部变量。
在
countrepeation
中，START
是函数局部变量，而不是全局变量。在
中，countrepeation
中，START
是函数局部变量，而不是全局变量。