在 C# 中查找列表中重复项的最快方法

Question

我知道关于这个主题有很多类似的问题，但我找不到我正在寻找的答案。这是我的要求。

我有一长串字符串（很容易超过 50,000 甚至 100K 项），我需要在其中找到重复项。但是仅仅查找重复项是行不通的；我真正想做的是遍历列表并在每个项目的末尾添加一个增量索引以指示项目重复的次数。为了更好地说明，让我举个例子。我的列表实际上包含路径，所以示例大致类似。

我原来的列表：

AAA\BBB
AAA\CCC
AAA\CCC
BBB\XXX
BBB
BBB\XXX
BBB\XXX

添加了索引的调整列表：

AAA\BBB[1]
AAA\CCC[1]
AAA\CCC[2]
BBB\XXX[1]
BBB[1]
BBB\XXX[2]
BBB\XXX[3]

首先我使用 Linq 尝试了以下方法：

List<string> originalList = new List<string>();
List<string> duplicateItems = new List<string>();

// pathList is a simple List<string> that contains my paths.
foreach (string item in pathList)
{
    // Do some stuff here and pick 'item' only if it fits some criteria.
    if (IsValid(item))
    {
        originalList.Add(item);
        int occurences = originalList.Where(x => x.Equals(item)).Count();
        duplicateItems.Add(item + "[" + occurences + "]");
    }
}

这工作得很好，给了我想要的结果。问题是考虑到我的列表可以包含 10 万个项目，它的速度非常慢。所以我环顾四周，了解到 HashSet 可能是一种可能更有效的替代方案。但我不太清楚如何使用它来获得我想要的结果。

我想我可以试试这样的：

HashSet<string> originalList = new HashSet<string>();
List<string> duplicateItems = new List<string>();

foreach (string item in pathList)
{
    // Do some stuff here and pick 'item' only if it fits some criteria.
    if (IsValid(item))
    {
        if (!originalList.Add(item))
        {
            duplicateItems.Add(item + "[" + ??? + "]");
        }
    }
}

稍后我可以将“[1]”添加到 HashSet 中的所有项目，但是如何在将项目添加到我的重复列表时正确地获得索引（上面标有通用混淆符号，???） ?我无法保留可以传递给我的方法的引用 int，因为可能有数百个不同的重复项，每个重复的次数都不同，如我的示例所示。

我还能使用 HashSet，还是有更好的方法来实现我的目标？即使是指向正确方向的轻微指针也会有很大帮助。

Answer 1

你可以试试这个，虽然我还没有进行性能测试：

List<string> originalList = new List<string>()
{
    @"AAA\BBB",
    @"AAA\CCC",
    @"AAA\CCC",
    @"BBB\XXX",
    @"BBB",
    @"BBB\XXX",
    @"BBB\XXX"
};
List<string> outputList = new List<string>();

foreach(var g in originalList.GroupBy(x => x).Select(x => x.ToList()))
{   
    var index = 1;  
    foreach(var item in g)
    {
        outputList.Add(string.Format("{0}[{1}]", item, index++));
    }
}

小提琴here

Answer 2

您可以只使用 Group() 将字符串拉在一起，然后使用 value 和 count 的组合来投影这些组。

鉴于您的字符串列表：

var listOfStrings;
var grouped = listOfStrings.GroupBy(x => x);
var groupedCount = grouped.Select(x => new {key = x.Key, count = group.Count()});

Answer 3

由于您要求最快，最好的 IMO 将使用 foreach 循环并计数 Dictionary<string, int>。它与HashSet 具有相同的时间复杂度，并且比LINQ GroupBy 使用更少的内存：

var counts = new Dictionary<string, int>(pathList.Count); // specify max capacity to avoid rehashing
foreach (string item in pathList)
{
    // Do some stuff here and pick 'item' only if it fits some criteria.
    if (IsValid(item))
    {
        int count;
        counts.TryGetValue(item, out count);
        counts[item] = ++count;
        duplicateItems.Add(item + "[" + count + "]");
    }
}

Answer 4

这个怎么样？

    static IEnumerable<string> MyCounter(IEnumerable<string> data)
    {
        var myDic = new Dictionary<string, int>();
        foreach (var d in data)
        {
            if (!myDic.ContainsKey(d))
                myDic[d] = 1;
            else
                myDic[d] = myDic[d] + 1 ;
            yield return d +"[" + myDic[d] + "]";
        }
    }

Answer 5

您可以遍历列表并使用字典来获取计数，如下所示：

private int GetCount(IDictionary<string, int> counts, string item)
{
  int count;
  if (!counts.TryGetValue(item, out count))
    count = 0;
  count++;
  counts[item] = count;
  return count;
}

private IEnumerable<string> GetItems(IEnumerable<string> items)
{
  // Initialize dict for counts with appropriate comparison
  var counts = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
  foreach(var item in items)
    yield return string.Format("{0}[{1}]", item, GetCount(counts, item));
}

Answer 6

你可以使用这个清晰易懂的代码：

public static void Main()
{
    var originalList  = new List<string>()
    {
        @"AAA\BBB",
        @"AAA\CCC",
        @"AAA\CCC",
        @"BBB\XXX",
        @"BBB",
        @"BBB\XXX",
        @"BBB\XXX"
    };

    var outputList = originalList.GroupBy(x => x).SelectMany(x => x.Select((y, i) => string.Format("{0}[{1}]", y, i + 1)));     

    Console.WriteLine(string.Join("\n", outputList));
}