查找字符串中出现次数最多的字符？

Question

例如，我有一个字符串：

"abbbbccd"

b 出现次数最多。使用 C++ 时，处理此问题的最简单方法是将每个字符插入到 map 中。我必须在 C# 中做同样的事情吗？有没有一种使用 LINQ 的优雅方法？

Answer 1

input.GroupBy(x => x).OrderByDescending(x => x.Count()).First().Key

注意：

• 如果您需要它在 .Net 的古代 (2.0) 版本上工作，请考虑 LinqBridge 。如果您无法使用 C# 3.0（针对 .Net 2.0），由于缺少 lambda 支持，您可能最好使用其他解决方案。 xanatos 答案中介绍了另一个 .Net 2.0+ 选项。
• 对于 "aaaabbbb" 的情况，只会返回其中之一（感谢 xanatos 的评论）。如果您需要最大计数的所有元素，请改用 Albin 的解决方案。
• 由于对这个 O(n log n) 解决方案进行排序。如果您需要更好的方法 - 通过线性搜索找到最大值，而不是首先排序，这将给出 O(n)。请参阅LINQ：如何对集合中所有对象的属性执行 .Max() 并返回具有最大值的对象

Answer 2

这是因为有人要求2.0版本，所以没有LINQ。

Dictionary<char, int> dict = new Dictionary<char, int>();

int max = 0;

foreach (char c in "abbbbccccd")
{
    int i;
    dict.TryGetValue(c, out i);
    i++;
    if (i > max)
    {
        max = i;
    }
    dict[c] = i;
}

foreach (KeyValuePair<char, int> chars in dict)
{
    if (chars.Value == max)
    {
        Console.WriteLine("{0}: {1}", chars.Key, chars.Value);
    }
}

相反，这适用于 LINQ 版本。它将提取配对的“最佳”（aaaabbbb == a，b）。如果 str == String.Empty 则不起作用。

var str = "abbbbccccd";

var res = str.GroupBy(p => p).Select(p => new { Count = p.Count(), Char = p.Key }).GroupBy(p => p.Count, p => p.Char).OrderByDescending(p => p.Key).First();

foreach (var r in res) {
    Console.WriteLine("{0}: {1}", res.Key, r);
}

Answer 3

string testString = "abbbbccd";
var charGroups = (from c in testString
                    group c by c into g
                    select new
                    {
                        c = g.Key,
                        count = g.Count(),
                    }).OrderByDescending(c => c.count);
foreach (var group in charGroups)
{
    Console.WriteLine(group.c + ": " + group.count);
}

Answer 4

受斯蒂芬的回答启发，几乎相同：

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 = "abc".Mode().ToArray(); //returns { a, b, c }
var modes = "aabc".Mode().ToArray(); //returns { a }
var modes = "aabbc".Mode().ToArray(); //returns { a, b }

更新：对此答案与Jodrell的 回答（发布版本，调试器分离，哦，是的）

来源=“”；

迭代次数 = 1000000

结果：

this - 280 ms
Jodrell's - 900 ms

来源=“aabc”;

迭代次数 = 1000000

结果：

this - 1800 ms
Jodrell's - 3200 ms

源 = 相当大的字符串 - 3500+ 字符

迭代次数 = 10000

结果：

this - 3200 ms
Jodrell's - 3000 ms

Answer 5

编辑3

这是我的最后一个答案，我认为它（只是）遮蔽了Nawfal在较长序列上的性能。

然而，鉴于 Nawfal 的答案 的复杂性降低，并且其更通用的性能，特别是与问题相关，我会选择那个。

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++)
    {
        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);
}

---

编辑 2

---

编辑

---

---

如果您想要一个高效的通用解决方案，则需要考虑多个项目可能具有相同频率，从此扩展开始，

IOrderedEnumerable<KeyValuePair<int, IEnumerable<T>>>Frequency<T>(
    this IEnumerable<T> source,
    IComparer<T> comparer = null)
{
    return source.GroupBy(t => t, comparer)
        .GroupBy(
            g => g.Count(),
            (k, s) => new KeyValuePair<int, IEnumerable<T>>(
                k,
                s.Select(g => g.First())))
        .OrderByDescending(f => f.Key);
}

此扩展适用于以下所有场景

var mostFrequent = string.Empty.Frequency().FirstOrDefault();

var mostFrequent = "abbbbccd".Frequency().First();

，或者

var mostFrequent = "aaacbbbcdddceee".Frequency().First();

请注意，mostFrequent 是 KeyValuePair>。

---

如果您愿意，您可以将其简化为另一个扩展，

public static IEnumerable<T> Mode<T>(
    this IEnumerable<T> source,
    IEqualityComparer<T> comparer = null)
{
    var mode = source.GroupBy(
            t => t,
            (t, s) => new { Value = t, Count = s.Count() }, comparer)
        .GroupBy(f => f.Count)
        .OrderbyDescending(g => g.Key).FirstOrDefault();

    return mode == null ? Enumerable.Empty<T>() : mode.Select(g => g.Value);
}

显然可以使用它，因此，

var mostFrequent = string.Empty.Mode();

var mostFrequent = "abbbbccd".Mode();

var mostFrequent = "aaacbbbcdddceee".Mode();

这里 mostFrequent 是一个 IEnumerable。

Answer 6

找到最简单且没有内置函数的

示例代码和链接

public char MostOccurringCharInString(string charString)
{
int mostOccurrence = -1;
char mostOccurringChar = ' ';
foreach (char currentChar  in charString)
{
    int foundCharOccreence = 0;
    foreach (char charToBeMatch in charString)
    {
        if (currentChar == charToBeMatch)
            foundCharOccreence++;
    }
    if (mostOccurrence < foundCharOccreence)
    {
        mostOccurrence = foundCharOccreence;
        mostOccurringChar = currentChar;
    }
 }
  return mostOccurringChar;
}

了解有关如何获得最大出现次数以及流程的更多信息。

如何获取字符串中出现的最大字符数和最大出现次数

Answer 7

#simplified expression using LINQ#
string text = "abccdeeef";
int length = text.ToCharArray().GroupBy(x => x).OrderByDescending(x => 
x.Count()).First().Count();

Answer 8

有许多不同的方法可以解决这个问题。

1. Linq
2. 词典
3. 使用系统。

您可以根据自己的喜好进行选择。列举其中之一。

  private static void CalculateMaxCharCountUsingArray(string actualString)
        {
            char[] charArray = actualString.ToCharArray();

            int[] arr = new int[256];
            int maxCount = 0;
            char maxChar = ' ';
            foreach (var r in charArray)
            {
                arr[r] = arr[r] + 1;
                if (maxCount < arr[r])
                {
                    maxCount = arr[r];
                    maxChar = r;
                }
            }
            Console.WriteLine("This character " + maxChar + " that appeared maximum times : " + maxCount);

            IEnumerable<char> distinctCharArray = charArray.Distinct();

            foreach(var r in distinctCharArray)
            {
                Console.WriteLine("This character " + r + " that appeared  times " + arr[r]  + " in a string");

            }
        }

我从下面的链接中了解到了所有这些内容，供您参考。

Answer 9

代码：

class CharCount
{
    public void CountCharacter()
    {
        int n;
        Console.WriteLine("enter the no. of elements: ");
        n = Convert.ToInt32(Console.ReadLine());

        char[] chararr = new char[n];
        Console.WriteLine("enter the elements in array: ");
        for (int i = 0; i < n; i++)
        {
            chararr[i] = Convert.ToChar(Console.ReadLine());
        }
        Dictionary<char, int> count = chararr.GroupBy(x => x).ToDictionary(g => g.Key, g => g.Count());

        foreach(KeyValuePair<char, int> key in count)
        {
            Console.WriteLine("Occurrence of {0}: {1}",key.Key,key.Value);
        }

        Console.ReadLine();
    }
}

Answer 10

        //find most occuring character and count from below string

        string totest = "abcda12Zernn111y";

        string maxOccuringCharacter = "";
        int maxOccurence = 0;string currentLoopCharacter = ""; string updatedStringToTest = "";int cnt = 0;

        for (int i = 0; i < totest.Length; i++)
        {
            currentLoopCharacter = totest[i].ToString();
            updatedStringToTest = totest.Replace(currentLoopCharacter, "");

            cnt = totest.Length - updatedStringToTest.Length;

            if (cnt > maxOccurence)
            {
                maxOccuringCharacter = currentLoopCharacter;
                maxOccurence = cnt;
            }

            totest = updatedStringToTest;
        }

        Console.WriteLine("The most occuring character is {0} and occurence was {1}", maxOccuringCharacter, maxOccurence.ToString());
        Console.ReadLine();

Answer 11

这是 Femaref 的解决方案，经过修改后，如果多个字母的计数匹配，则返回多个字母。它不再是一句台词，但仍然相当简洁，并且应该具有相当的性能。

    public static IEnumerable<char> GetMostFrequentCharacters(this string str)
    {
        if (string.IsNullOrEmpty(str))
            return Enumerable.Empty<char>();

        var groups = str.GroupBy(x => x).Select(x => new { Letter = x.Key, Count = x.Count() }).ToList();
        var max = groups.Max(g2 => g2.Count);
        return groups.Where(g => g.Count == max).Select(g => g.Letter);
    }

Answer 12

使用 LINQ 和字典数据结构作为查找列表的不同方法：

        var str = "abbbbccd";
        var chrArr = str.ToCharArray();
        Dictionary<char, int> dic = new Dictionary<char, int>();
        foreach (char a in chrArr)
        {
            if (dic.ContainsKey(a))
                dic[a]++;
            else
                dic.Add(a, 1);
        }
        int count = dic.Values.Max();
        char val = dic.Where(d => d.Value == count).FirstOrDefault().Key;