0

我想在整数数组中找到前 3 个最大重复数？

以下是我尝试过但找不到所需结果的代码：

static void Main(string[] args)
    {

      int[,] numbers = {
                           {1, 2, 0, 6 },
                           {5, 6, 7, 0 },
                           {9, 3, 6, 2 },
                           {6, 4, 8, 1 }
                        };           
        int count = 0;
        List<int> checkedNumbers = new List<int>();
        foreach (int t in numbers)
        {
            if (!checkedNumbers.Contains(t))
            {
               foreach (int m in numbers)                   
               {
                   if (m == t)                        
                      {   
                         count++;
                      }
                }
                Console.WriteLine("Number {0} is Repeated {1} Times ", t, count);
               count = 0;
                checkedNumbers.Add(t);
            }           
       }
        Console.ReadLine();
    }
4

4 回答 4

5

您可以使用GroupByLINQ 然后OrderByDescending根据每组中的计数：

var result = list.GroupBy(i => i)
                 .OrderByDescending(g => g.Count())
                 .Select(g => g.Key)
                 .Take(3);

编辑：使用您的代码，您可以OfType用来展平矩阵，然后使用上面的代码：

int[,] numbers = {
                       {1, 2, 0, 6 },
                       {5, 6, 7, 0 },
                       {9, 3, 6, 2 },
                       {6, 4, 8, 1 }
                 };

var list = numbers.OfType<int>();
于 2012-09-12T05:09:03.283 回答
1

暗示：

您可以在 LINQ 的帮助下做到这一点。
这是查找最频繁出现的元素的代码：-

List<int> list = new List<int>() { 1,1,2,2,3,4,5 };

// group by value and count frequency
var query = from i in list
            group i by i into g
            select new {g.Key, Count = g.Count()};

// compute the maximum frequency
int frequency = query.Max(g => g.Count);

// find the values with that frequency
IEnumerable<int> modes = query
                              .Where(g => g.Count == frequency)
                              .Select(g => g.Key);

// dump to console
foreach(var mode in modes) {
    Console.WriteLine(mode);
}

以同样的方式，您也可以找到其他两个。

于 2012-09-12T05:07:33.230 回答
1 
int[] numbers = {1, 2, 3, 5, 6, 32, 2, 4, 42, 2, 4, 4, 5, 6, 3, 4};
var counts = new Dictionary<int, int>();
foreach (var number in numbers)
{
    counts[number] = counts[number] + 1;
}
var top3 = counts.OrderByDescending(x => x.Value).Select(x => x.Key).Take(3);
于 2012-09-12T05:06:32.630 回答
1

我看到现有的答案都没有提供解释，所以我将尝试解释。

您需要做的是计算每个项目在数组中出现的次数。为此，有多种方法（字典、linq 等）。可能最容易使用包含数字的字典，以及它出现的次数：

int numbers[] = {1, 3, 6, 10, 9, 3, 3, 1, 10} ;
Dictionary<int, int> dic = new Dictionary<int, int>();

现在遍历数字中的每个元素，并将其添加到字典中。如果已经添加，只需增加计数值。

foreach (var i in numbers)
{
    dic[i]++; // Same as dic[i] = dic[i]+1;
}

如果字典不存在，它会自动添加一个新项目，所以我们可以简单地做dic[i]++;

接下来，我们需要获得最高的 3 个值。同样，有很多方法可以做到这一点，但最简单的方法是对其进行排序。

var sorted_dic = dic.OrderByDescending(x => x.Value);

现在，前 3 个项目sorted_dic将成为您要查找的 3 个值。有多种方法可以仅获取这 3 个，例如使用以下Take方法：

var first_3 = sorted_dic.Take(3);

现在您可以遍历这 3 个值，例如在屏幕上打印它们：

foreach (var i in first_3)
{
    Console.Write("{0} appeared {1} times.", i.Key, i.Value);
}
于 2012-09-12T05:27:02.603 回答