blocks|key|107641|text|这样如何：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|107642|var+most+=+list.GroupBy(i=>i).OrderByDescending(grp=>grp.Count())
++++++.Select(grp=>grp.Key).First();|code-block|syntax|javascript|107643|或者在查询语法中：|107644|var+most+=+(from+i+in+list
++++++++++++group+i+by+i+into+grp
++++++++++++orderby+grp.Count()+descending
++++++++++++select+grp.Key).First();|107645|当然，如果您要重复使用此方法，则可以添加一个扩展方法：|107646|public+static+T+MostCommon<T>(this+IEnumerable<T>+list)
{
++++return+...+//+previous+code
}|107647|然后，您可以使用：|107648|var+most+=+list.MostCommon();|107649|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

How about:

<pre><code>var most = list.GroupBy(i=&gt;i).OrderByDescending(grp=&gt;grp.Count())
 .Select(grp=&gt;grp.Key).First();
</code></pre>

or in query syntax:

<pre><code>var most = (from i in list
 group i by i into grp
 orderby grp.Count() descending
 select grp.Key).First();
</code></pre>

Of course, if you will use this repeatedly, you could add an extension method:

<pre><code>public static T MostCommon&lt;T&gt;(this IEnumerable&lt;T&gt; list)
{
 return ... // previous code
}
</code></pre>

Then you can use:

<pre><code>var most = list.MostCommon();
</code></pre>

blocks|key|3325903|text|不确定lambda表达式，但我会|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3325904|3325905|Sort+the+list+O(n+|ordered-list-item|3325906|+n)|3325907|Scan+the+list+O(n)+list+the+log+|3325908|3325909|+it+|3325910|+O(n)+reporting每个数字都具有该游程长度。|3325911|3325912|这是因为可能有不止一个出现次数最多的数字。|3325913|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|X|8|@]|9|@]|A|$]]|$1|J|3|-4|5|E|7|Y|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|Z|8|@]|9|@]|A|$]]|$1|M|3|N|5|E|7|10|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|11|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|12|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|S|$]]

Not sure about the lambda expressions, but I would

<ol>
<li>Sort the list [O(n log n)]</li>
<li>Scan the list [O(n)] finding the longest run-length.</li>
<li>Scan it again [O(n)] reporting each number having that run-length.</li>
</ol>

This is because there could be more than one most-occurring number.

blocks|key|107752|text|有人想要一个有联系的解决方案。下面是对此的尝试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|107753|int+indicator+=+0

var+result+=
++list.GroupBy(i+=>+i)
++++.Select(g+=>+new+{i+=+g.Key,+count+=+g.Count()}
++++.OrderByDescending(x+=>+x.count)
++++.TakeWhile(x+=>
++++{
++++++if+(x.count+==+indicator+%7C%7C+indicator+==+0)
++++++{
++++++++indicator+=+x.count;
++++++++return+true;
++++++}
++++++return+false;
++++})
++++.Select(x+=>+x.i);|code-block|syntax|javascript|107754|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Someone asked for a solution where there's ties. Here's a stab at that:

<pre><code>int indicator = 0

var result =
 list.GroupBy(i =&gt; i)
 .Select(g =&gt; new {i = g.Key, count = g.Count()}
 .OrderByDescending(x =&gt; x.count)
 .TakeWhile(x =&gt;
 {
 if (x.count == indicator || indicator == 0)
 {
 indicator = x.count;
 return true;
 }
 return false;
 })
 .Select(x =&gt; x.i);
</code></pre>

blocks|key|3326031|text|摘自我的答案here|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3326032|public+static+IEnumerable<T>+Mode<T>(this+IEnumerable<T>+input)
{++++++++++++
++++var+dict+=+input.ToLookup(x+=>+x);
++++if+(dict.Count+==+0)
++++++++return+Enumerable.Empty<T>();
++++var+maxCount+=+dict.Max(x+=>+x.Count());
++++return+dict.Where(x+=>+x.Count()+==+maxCount).Select(x+=>+x.Key);
}

var+modes+=+{+}.Mode().ToArray();+//returns+{+}
var+modes+=+{+1,+2,+3+}.Mode().ToArray();+//returns+{+1,+2,+3+}
var+modes+=+{+1,+1,+2,+3+}.Mode().ToArray();+//returns+{+1+}
var+modes+=+{+1,+2,+3,+1,+2+}.Mode().ToArray();+//returns+{+1,+2+}|code-block|syntax|javascript|3326033|我在上面的方法和David+B's+TakeWhile之间进行了性能测试。|style|CODE|3326034|3326035|源={+}，迭代=+1000000|blockquote|3326036|3326037|我的-300ms，David的-930ms来源={1+}，迭代=+1000000|3326038|我的-1070ms，大卫的-1560ms来源=+100%2B+int，有2个副本，迭代=+10000|3326039|我的-300ms，大卫的-500ms源=+10000个随机整数，大约有100%2B个副本，迭代=+1000次|3326040|我的-+1280毫秒，大卫的-+1400毫秒|3326041|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/16818909/661933|1|https://stackoverflow.com/a/356453/661933^0|6|4|0|0|0|I|9|8|9|1|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@$A|1A|B|1B|1|1C]]|C|$]]|$1|D|3|E|5|F|7|1D|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1E|8|@$A|1F|B|1G|K|L]]|9|@$A|1H|B|1I|1|1J]]|C|$]]|$1|M|3|-4|5|6|7|1K|8|@]|9|@]|C|$]]|$1|N|3|O|5|P|7|1L|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]|$1|R|3|S|5|6|7|1N|8|@]|9|@]|C|$]]|$1|T|3|U|5|6|7|1O|8|@]|9|@]|C|$]]|$1|V|3|W|5|6|7|1P|8|@]|9|@]|C|$]]|$1|X|3|Y|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|Z|3|-4|5|6|7|1R|8|@]|9|@]|C|$]]]|10|$11|$5|12|13|14|C|$15|16]]|17|$5|12|13|14|C|$15|18]]]]

Taken from my answer <a href="https://stackoverflow.com/a/16818909/661933">here</a>:

<pre><code>public static IEnumerable&lt;T&gt; Mode&lt;T&gt;(this IEnumerable&lt;T&gt; input)
{ 
 var dict = input.ToLookup(x =&gt; x);
 if (dict.Count == 0)
 return Enumerable.Empty&lt;T&gt;();
 var maxCount = dict.Max(x =&gt; x.Count());
 return dict.Where(x =&gt; x.Count() == maxCount).Select(x =&gt; x.Key);
}

var modes = { }.Mode().ToArray(); //returns { }
var modes = { 1, 2, 3 }.Mode().ToArray(); //returns { 1, 2, 3 }
var modes = { 1, 1, 2, 3 }.Mode().ToArray(); //returns { 1 }
var modes = { 1, 2, 3, 1, 2 }.Mode().ToArray(); //returns { 1, 2 }
</code></pre>

I went for a performance test between the above approach and <a href="https://stackoverflow.com/a/356453/661933">David B's</a> <code>TakeWhile</code>.

<blockquote>
 source = { }, iterations = 1000000 
 mine - 300 ms, David's - 930 ms 
 
 source = { 1 }, iterations = 1000000 
 mine - 1070 ms, David's - 1560 ms 
 
 source = 100+ ints with 2 duplicates, iterations = 10000 
 mine - 300 ms, David's - 500 ms 
 
 source = 10000 random ints with about 100+ duplicates, iterations = 1000 
 mine - 1280 ms, David's - 1400 ms
</blockquote>

blocks|key|920708|text|这是另一个答案，看起来很快。我认为Nawfal's+answer通常更快，但这可能会影响它在长序列中的表现。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|920709|public+static+IEnumerable<T>+Mode<T>(
++++this+IEnumerable<T>+source,
++++IEqualityComparer<T>+comparer+=+null)
{
++++var+counts+=+source.GroupBy(t+=>+t,+comparer)
++++++++.Select(g+=>+new+{+g.Key,+Count+=+g.Count()+})
++++++++.ToList();

++++if+(counts.Count+==+0)
++++{
++++++++return+Enumerable.Empty<T>();
++++}

++++var+maxes+=+new+List<int>(5);
++++int+maxCount+=+1;

++++for+(var+i+=+0;+i+<+counts.Count;+i%2B%2B)
++++{
++++++++if+(counts[i].Count+<+maxCount)
++++++++{
++++++++++++continue;
++++++++}

++++++++if+(counts[i].Count+>+maxCount)
++++++++{
++++++++++++maxes.Clear();
++++++++++++maxCount+=+counts[i].Count;
++++++++}

++++++++maxes.Add(i);
++++}

++++return+maxes.Select(i+=>+counts[i].Key);
}|code-block|syntax|javascript|920710|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/16850071/659190^0|H|F|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Here is another answer, which seems to be fast. I think <a href="https://stackoverflow.com/a/16850071/659190">Nawfal's answer</a> is generally faster but this might shade it on long sequences.

<pre><code>public static IEnumerable&lt;T&gt; Mode&lt;T&gt;(
 this IEnumerable&lt;T&gt; source,
 IEqualityComparer&lt;T&gt; comparer = null)
{
 var counts = source.GroupBy(t =&gt; t, comparer)
 .Select(g =&gt; new { g.Key, Count = g.Count() })
 .ToList();

 if (counts.Count == 0)
 {
 return Enumerable.Empty&lt;T&gt;();
 }

 var maxes = new List&lt;int&gt;(5);
 int maxCount = 1;

 for (var i = 0; i &lt; counts.Count; i++)
 {
 if (counts[i].Count &lt; maxCount)
 {
 continue;
 }

 if (counts[i].Count &gt; maxCount)
 {
 maxes.Clear();
 maxCount = counts[i].Count;
 }

 maxes.Add(i);
 }

 return maxes.Select(i =&gt; counts[i].Key);
}
</code></pre>

Is there a quick and nice way using linq?

Find the most occurring number in a List<int>

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有没有使用linq的又快又好的方法？

问查找List<int>中出现次数最多的数字
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问查找List<int>中出现次数最多的数字EN