9

所以我正在尝试制作一个基本程序来学习 C++ 的基础知识，我正在生成 100 个从 0 到 100 的随机数并将它们存储在一个向量中，然后我显示总和、平均值、中位数、众数、高和向量的低点。除了卡住的模式之外，我已经完成了所有其他工作。这是我到目前为止的代码。

int modeFunction()
     {
         numMode = 0;
         count = 0;
         for (int n = 0; n < 100; n++)
         {
             for (int y = 0; y < 100; y++)
             {
                 if (numVector.at(y) == numVector.at(n))
                {
                    numMode = numVector.at(y);
                    count++;
                }
             }

         }
         return numMode;
     }

在那之后我被卡住了，因为在我看来这应该有效，但它没有。它只是输出最后一个数字，通常是 100。任何帮助将不胜感激。

4

7 回答 7

11

由于所有值都在 0 到 100 之间，因此您可以使用直方图有效地找到模式：

std::vector<int> histogram(101,0);
for( int i=0; i<100; ++i )
  ++histogram[ numVector[i] ];
return std::max_element( histogram.begin(), histogram.end() ) - histogram.begin();
于 2011-03-25T23:03:37.007 回答
4

numMode由于 mode 是出现频率最高的数字，除非新数字的计数大于 的计数，否则您不应更改numMode。

编辑：为了澄清，您需要为当前元素和您认为是模式的当前数字保留单独的计数。理想情况下，设置newMode为第一个元素是一个好方法。

此外，模式不一定是唯一的（即“1 1 2 2”）。如果您关心这一点，您可能需要记住这一点。

newMode = element[0]
modeCount = # of occurrence of newMode

for ( i-th element from [1 to end] ) {
   tmpCount = # of occurrence of element[i]
   if tmpCount > modeCount {
     newMode = element[i]
     modeCount = tmpCount
   }
}
于 2011-03-25T22:32:37.613 回答
3

如果元素数量足够少，bmcnett 的方法效果很好。如果您有大量元素，但所有元素值都在一个小范围内，则使用 map/hashmap 效果很好。就像是 

typedef std::pair<int, int> mode_pair;

struct mode_predicate
{
  bool operator()(mode_pair const& lhs, mode_pair const& rhs)
  {
    return lhs.second < rhs.second;
  }
};

int modeFunction()
{
  std::map<int, int> mode_map;
  for (int n = 0; n < 100; n++)
    mode_map[numVector[n]]++;
  mode_predicate mp;
  return std::max_element(mode_map.begin(), mode_map.end(), mp)->first;
}
于 2011-03-25T23:32:47.753 回答
1

替代解决方案。注：未经测试。

int mode1(const std::vector<int>& values)
{   
    int old_mode = 0;
    int old_count = 0;
    for(size_t n=0; n < values.size(); ++n) 
    {
        int mode = values[n];
        int count = std::count(values.begin()+n+1, values.end(), mode);

        if(count > old_count) 
        {
            old_mode = mode;
            old_count = count;
        }
    }
    return old_mode;
}

int mode2(const std::vector<int>& values)
{   
    return std::max_element(values.begin(), values.end(), [](int value)
    {
        return std::count(values.begin(), values.end(), value);
    });
}
于 2011-03-25T22:42:34.430 回答
1

你的算法是错误的 - 它输出数组中的最后一个数字，因为这就是它所能做的。每次 index 处y的数字与 index 处的数字匹配时，n您都会覆盖前一个 的结果n。由于您使用的是相同的循环条件，y并且n对于每个可能的值，嵌套循环中的至少一个点始终相同 - 您将始终以ben结束。numModenumVector.at(99)

您需要更改算法以保存n沿途每个索引的计数（或至少哪个n索引以最大count的结尾），以便您可以在n循环结束时知道哪个条目出现的次数最多。

于 2011-03-25T22:34:08.617 回答
0

众数是指频率最高的数字。逻辑应该是——

//Start of function

int mode = 0, globalCount = 0 ;  
// Start of outer for loop
for i = 0 to length - 1    
   int localCount = 0   

  // Start of inner for loop  
  for j = 0 to length - 1      
     if vec[i] == vec[j]    
     ++localCount    
 // End of Inner for loop 

 if ( localCount > globalCount )  
     globalCount = localCount  
     mode = vec[i]  
// End of outer for loop  

if globalCount > 1 // This should be checked whether vec has repetitions at all
   return mode
else
   return 0

// End of function
于 2011-03-25T22:52:41.197 回答
0 
    int number = array_list[0];
    int mode = number;
    int count = 1;
    int countMode = 1;

    for (int i=1; i<size_of_list; i++)
    {
          if (array_list[i] == number) 
          { // count occurrences of the current number
             count++;
             if (count > countMode) 
                {
                      countMode = count; // mode is the biggest ocurrences
                      mode = number;
                }
          }
          else
          { // now this is a different number
                if (count > countMode) 
                {
                      countMode = count; // mode is the biggest ocurrences
                      mode = number;
                }
               count = 1; // reset count for the new number
               number = array_list[i];
      }
    }
于 2019-06-14T11:44:34.170 回答