¿Cómo encontrar el modo en Array C #?

Quiero encontrar el modo en una matriz. Sé que tengo que hacer ciclos nesteds para verificar cada valor y ver con qué frecuencia aparece el elemento en la matriz. Entonces tengo que contar la cantidad de veces que aparece el segundo elemento. El siguiente código no funciona, ¿alguien puede ayudarme por favor?

for (int i = 0; i < x.length; i ++) { x[i]++; int high = 0; for (int i = 0; i  high) high = x[i]; } } 

Usar bucles nesteds no es una buena manera de resolver este problema. Tendrá un tiempo de ejecución de O (n ^ 2) – mucho peor que el O (n) óptimo.

Puede hacerlo con LINQ agrupando valores idénticos y luego encontrando el grupo con el recuento más grande:

 int mode = x.GroupBy(v => v) .OrderByDescending(g => g.Count()) .First() .Key; 

Esto es más simple y más rápido. Pero tenga en cuenta que (a diferencia de LINQ to SQL) LINQ to Objects actualmente no optimiza el OrderByDescending cuando solo se necesita el primer resultado. Clasifica completamente todo el conjunto de resultados que es una operación O (n log n).

Es posible que desee este algoritmo O (n) en su lugar. Primero itera una vez a través de los grupos para encontrar el conteo máximo, y luego una vez más para encontrar la primera clave correspondiente para ese conteo:

 var groups = x.GroupBy(v => v); int maxCount = groups.Max(g => g.Count()); int mode = groups.First(g => g.Count() == maxCount).Key; 

También puede usar la extensión MaxBy del método MoreLINQ para mejorar aún más la solución, de modo que solo requiera iterar a través de todos los elementos una vez.

Una solución no LINQ:

 int[] x = new int[] { 1, 2, 1, 2, 4, 3, 2 }; Dictionary counts = new Dictionary(); foreach( int a in x ) { if ( counts.ContainsKey(a) ) counts[a] = counts[a]+1 else counts[a] = 1 } int result = int.MinValue; int max = int.MinValue; foreach (int key in counts.Keys) { if (counts[key] > max) { max = counts[key]; result = key; } } Console.WriteLine("The mode is: " + result); 

Como principiante, esto puede no tener demasiado sentido, pero vale la pena proporcionar una solución basada en LINQ.

 x .GroupBy(i => i) //place all identical values into groups .OrderByDescending(g => g.Count()) //order groups by the size of the group desc .Select(g => g.Key) //key of the group is representative of items in the group .First() //first in the list is the most frequent (modal) value 

Say, x array tiene elementos como a continuación:

 int[] x = { 1, 2, 6, 2, 3, 8, 2, 2, 3, 4, 5, 6, 4, 4, 4, 5, 39, 4, 5 }; 

a. Obtener el mayor valor:

 int high = x.OrderByDescending(n => n).First(); 

segundo. Obtener modal:

 int mode = x.GroupBy(i => i) //Grouping same items .OrderByDescending(g => g.Count()) //now getting frequency of a value .Select(g => g.Key) //selecting key of the group .FirstOrDefault(); //Finally, taking the most frequent value