C#函数，尝试查找数组中出现最多的数字'；行不通

好的，我试着做一个函数，它将查看一个数字数组，并返回出现次数最多的数字。我试图通过设置计数器和for循环来实现这一点，但每次运行它时，它总是返回值9，即使它不在那里

public static int ModalNumber(int[] numbers)
{
int ones = 0;
int twos = 0;
int threes = 0;
int fours = 0;
int fives = 0;
int sixes = 0;
int sevens = 0;
int eights = 0;
int nines = 0;
int zeroes = 0;
for (int i = 0; i < 10; i++)
  {
    if (numbers[i] == 0)
      {
        zeroes++;
      }
    else if (numbers[i] == 1)
      {
        ones++;
      }
    else if (numbers[i] == 2)
      {
        twos++;
      }
    else if (numbers[i] == 3)
      {
        threes++;
      }
    else if (numbers[i] == 4)
      {
        fours++;
      }
    else if (numbers[i] == 5)
      {
        fives++;
      }
    else if (numbers[i] == 6)
      {
        sixes++;
      }
    else if (numbers[i] == 7)
      {
        sevens++;
      }
    else if (numbers[i] == 8)
      {
        eights++;
      }
    else if (numbers[i] == 1)
      {
        nines++;
      }
  }
  if (Convert.ToBoolean(zeroes >> ones & twos & threes & fours & fives & sixes & sevens & eights & nines))
    {
      return 0;
    }
  else if (Convert.ToBoolean(ones >> zeroes & twos & threes & fours & fives & sixes & sevens & eights & nines))
    {
      return 1;
    }
  else if (Convert.ToBoolean(twos >> zeroes & ones & threes & fours & fives & sixes & sevens & eights & nines))
    {
      return 2;
    }
  else if (Convert.ToBoolean(threes >> zeroes & ones & twos & fours & fives & sixes & sevens & eights & nines))
    {
      return 3;
    }
  else if (Convert.ToBoolean(fours >> zeroes & ones & twos & fours & fives & sixes & sevens & eights & nines))
    {
      return 4;
    }
  else if (Convert.ToBoolean(fives >> zeroes & ones & twos & threes & fours & sixes & sevens & eights & nines))
    {
      return 5;
    }
  else if (Convert.ToBoolean(sixes >> zeroes & ones & twos & threes & fours & fives & sevens & eights & nines))
    {
      return 6;
    }
  else if (Convert.ToBoolean(sevens >> zeroes & ones & twos & threes & fours & fives & sevens & eights & nines))
    {
      return 7;
    }
  else if (Convert.ToBoolean(eights >> zeroes & ones & twos & threes & fours & fives & sixes & sevens & nines))
    {
      return 8;
    }
  else
    {
      return 9;
    }

publicstaticintmodalnumber（int[]number）
{
整数=0；
int-twos=0；
int-threes=0；
int-fours=0；
整数五=0；
六位数=0；
整数七=0；
八分之一=0；
整数=0；
整数零=0；
对于（int i=0；i<10；i++）
{
如果（数字[i]==0）
{
零++；
}
else if（数字[i]==1）
{
1++；
}
else if（数字[i]==2）
{
twos++；
}
else if（数字[i]==3）
{
三S++；
}
else if（数字[i]==4）
{
fours++；
}
else if（数字[i]==5）
{
五个++；
}
else if（数字[i]==6）
{
六++；
}
else if（数字[i]==7）
{
七++；
}
else if（数字[i]==8）
{
八个++；
}
else if（数字[i]==1）
{
nines++；
}
}
如果（将.ToBoolean转换为（零>>一、二、三、四、五、六、七、八、九））
{
返回0；
}
else if（将.ToBoolean转换为（一>>零、二、三、四、五、六、七、八、九））
{
返回1；
}
else if（将.ToBoolean转换为（两个>>零和一个&三个&四个&五个&六个&七个&八个&九个））
{
返回2；
}
else if（将.ToBoolean转换为（三个>>零和一个&两个&四个&五个&六个&七个&八个&九个））
{
返回3；
}
else if（将.ToBoolean转换为（四个>>零和一个&两个&四个&五个&六个&七个&八个&九个））
{
返回4；
}
else if（将.ToBoolean转换为（五、一、二、三、四、六、七、八、九））
{
返回5；
}
else if（将.ToBoolean转换为（六、一、二、三、四、五、七、八、九））
{
返回6；
}
else if（将.ToBoolean转换为（七、一、二、三、四、五、七、八、九））
{
返回7；
}
else if（将.ToBoolean（八个>>零、一、二、三、四、五、六、七、九））
{
返回8；
}
其他的
{
返回9；
}

---

我很抱歉这个函数有这么长，但是基本上这个函数使用了一个数字数组，这个数组是由使用程序的人输入的。我知道这不是问题所在，因为我写了一些代码，在程序运行时显示它。有人能建议一种更有效的方法吗？谢谢这是我将如何做的（我不会给你代码，因为它显然是家庭作业）：

• 为可能的条目数创建一个数组（当有十种可能性时，使用

  int[10]

  ）。更好的选择是使用字典来存储计数，但现在我们将使用简单的方法
• 对于每个数字，增加刚刚创建的数组中的数字作为值（因此，如果要增加值9的查找项目数，请设置array[9]）
• 迭代数组，记住找到的最高数字的索引。您还必须存储该最高数字作为下次检查的参考点

---

这应该可以使用LINQ选择阵列中最常出现的数字：

numbers.GroupBy(i => i).OrderByDescending(group => group.Count()).First().Key;

在处理数组、列表或序列时，我建议您尝试考虑在基于集合的操作方面需要做些什么，因为这通常会简化解决方案。在这种情况下，您需要将数组中的不同值与它们出现的次数相关联，然后取出现次数最多的值。这可以e通过将整数集合按其标识进行分组（

GroupBy（i=>i）

），然后计算每个组中出现的次数（

group=>group.Count（）

），按计数降序排列，并取第一个元素

以防万一，因为您实际上说了“返回出现频率最高的数字”，如果您实际想要的是数字而不是出现频率最高的数字，您可以相应地更改解决方案：

numbers.SelectMany(i => i.ToString().Select(c => Int32.Parse(c.ToString())))
    .GroupBy(i => i).OrderByDescending(group => group.Count())
    .First()
    .Key;

---

我不想为你做作业，但我已经有了

static int Most(int[] numbers)
{
    int[] count = new int[10];
    foreach (int n in numbers)
    {
        if (n > 9 || n < 0)
            throw new ArgumentOutOfRangeException();
        count[n]++;
    }
    int max = count[0];
    int maxP = 0;
    for(int p = 1; p < 10; p++)
    {                
        if (count[p] > max)
        {
            max = count[p];
            maxP = p;
        }
    }
    return maxP;
}

静态int-Most（int[]数字）
{
int[]计数=新的int[10]；
foreach（整数n，以数字表示）
{
如果（n>9 | | n<0）
抛出新ArgumentOutOfRangeException（）；
计数[n]++；
}
int max=计数[0]；
int maxP=0；
对于（int p=1；p<10；p++）
{                
如果（计数[p]>最大值）
{
最大值=计数[p]；
maxP=p；
}
}
返回maxP；
}

我对此投了反对票，因为它是由一个简单的打字错误引起的。

if（number[I]==1）{nines++；}

-

1

不发音为

9

。我还建议使用数组而不是10个变量。此外，

和

&

不是那样使用的。查看一些C教程。你假设数组大小始终为10。这并不适合做家庭作业，但它确实可以完成任务：）。@KrzysztofSkowronek--Actually，它将只在实现

IEquatable

或与

ObjectEqualityComparer

一起工作的数据类型上工作，以便正确地对元素进行分组。