Question

我有这样的字典对象：

var dictionary = new Dictionary<string, List<int>()>;

键的数量不是很大，但值中的整数列表可能非常大（大约为1000）

给定一个键列表（键列表），我需要计算每个键出现的每个整数的次数，并按频率返回它们。

输出：

{int1, count1}
{int2, count2}
...

这是我提出的解决方案：

var query = _keylist.SelectMany(
             n=>_dictionary[n]).Group(g=>g).Select(
                 g=> new[] {g.key, g.count}).OrderByDescending(g=>g[1]);

即使此查询产生了所需的结果，它也不是非常有效。是否有一种聪明的方法可以用较少的处理产生相同的结果？

Answer 1

从算法的空间和时间使用的角度来看，我认为唯一不理想的是当你实际上不需要组时使用GroupBy（只有组计数）。您可以改用以下扩展方法。

public static Dictionary<K, int> CountBy<T, K>(
    this IEnumerable<T> source,
    Func<T, K> keySelector)
{
    return source.SumBy(keySelector, item => 1);
}

public static Dictionary<K, int> SumBy<T, K>(
    this IEnumerable<T> source,
    Func<T, K> keySelector,
    Func<T, int> valueSelector)
{
    if (source == null)
    {
        throw new ArgumentNullException("source");
    }
    if (keySelector == null)
    {
        throw new ArgumentNullException("keySelector");
    }
    var dictionary = new Dictionary<K, int>();
    foreach (var item in source)
    {
        var key = keySelector(item);
        int count;
        if (!dictionary.TryGetValue(key, out count))
        {
            count = 0;
        }
        dictionary[key] = count + valueSelector(item);
    }
    return dictionary;
}

请注意，优点是列举了数字列表但未存储。仅存储计数。另请注意，在您的情况下甚至不需要keySelector参数，我只包含它以使扩展方法更加通用。

用法如下。

var query = _keylist
    .Select(k => _dictionary[k])
    .CountBy(n => n)
    .OrderByDescending(p => p.Value);

这将为您提供KeyValuePair<int, int>序列，其中Key是原始列表中的数字，Value是计数。

为了更有效地处理一系列查询，您可以预处理数据。

Dictionary<string, Dictionary<int, int>> preprocessedDictionary
    = _dictionary.ToDictionary(p => p.Key, p => p.Value.CountBy(n => n));

现在，您可以更有效地执行查询。

var query = _keylist
    .SelectMany(k => preprocessedDictionary[k])
    .SumBy(p => p.Key, p => p.Value)
    .OrderByDescending(p => p.Value);

Answer 2

我会这样做：

var query =
    from k in _keylist
    from v in dictionary[k]
    group v by v into gvs
    let result = new
    {
        key = gvs.Key,
        count = gvs.Count(),
    }
    orderby result.count descending
    select result;

对我来说，这非常简单明了，非常值得接受使用LINQ的任何（次要）性能。

并且不会创建大型组列表的替代方法是：

var query =
    _keylist
        .SelectMany(k => dictionary[k])
        .Aggregate(
            new Dictionary<int, int>(),
            (d, v) =>
            {
                if (d.ContainsKey(v))
                {
                    d[v] += 1;
                }
                else
                {
                    d[v] = 1;
                }
                return d;
            })
    .OrderByDescending(kvp => kvp.Value)
    .Select(kvp => new
    {
        key = kvp.Key,
        count = kvp.Value,
    });

字典＆LT;＆GT;值计数c＃

2 个答案: