Question

我在.NET 3.5项目中有一个类型字符串列表。该列表中包含数千个字符串，但为了简洁起见，我们会说它只有5个字符串。

List<string> lstStr = new List<string>() {
            "Apple", "Banana", "Coconut", "Coconut", "Orange"};

假设列表已排序（如上所述）。我需要的是一个LINQ查询，它将删除不重复的所有字符串。所以结果会给我一个只包含两个“椰子”字符串的列表。

这可能与LINQ查询有关吗？如果不是那么我将不得不诉诸一些复杂的for循环，我可以这样做，但我不想，除非我不得不这样做。

Answer 1

var dupes = lstStr.Where(x => lstStr.Sum(y => y==x ? 1 : 0) > 1);

OR

var dupes = lstStr.Where((x,i) => (   (i > 0 && x==lstStr[i-1]) 
                                   || (i < lstStr.Count-1 && x==lstStr[i+1]));

请注意，第一个列出了 O（n²）时间（但不假设排序列表）的每个元素的列表。第二个是 O（n）（并假定排序列表）。

Answer 2

这应该有效，并且是O（N）而不是另一个的O（N ^ 2）。（注意，这确实使用了列表已排序的事实，因此这确实是一项要求）。

IEnumerable<T> OnlyDups<T>(this IEnumerable<T> coll) 
   where T: IComparable<T>
{
     IEnumerator<T> iter = coll.GetEnumerator();
     if (iter.MoveNext())
     {
         T last = iter.Current;
         while(iter.MoveNext())
         {
             if (iter.Current.CompareTo(last) == 0)
             {
                  yield return last;
                  do 
                  {
                       yield return iter.Current;
                  }
                  while(iter.MoveNext() && iter.Current.CompareTo(last) == 0);
             }
             last = iter.Current;
         }
}

像这样使用：

IEnumerable<string> onlyDups = lstStr.OnlyDups();

或

List<string> onlyDups = lstStr.OnlyDups().ToList();

Answer 3

这应该有效，并且是O（N）而不是另一个的O（N ^ 2）。（注意，这确实使用了列表已排序的事实，因此这确实是一项要求）。

IEnumerable<T> OnlyDups<T>(this IEnumerable<T> coll) 
   where T: IComparable<T>
{
     IEnumerator<T> iter = coll.GetEnumerator();
     if (iter.MoveNext())
     {
         T last = iter.Current;
         while(iter.MoveNext())
         {
             if (iter.Current.CompareTo(last) == 0)
             {
                  yield return last;
                  do 
                  {
                       yield return iter.Current;
                  }
                  while(iter.MoveNext() && iter.Current.CompareTo(last) == 0);
             }
             last = iter.Current;
         }
}

像这样使用：

IEnumerable<string> onlyDups = lstStr.OnlyDups();

或

List<string> onlyDups = lstStr.OnlyDups().ToList();

Answer 4

var temp = new List<string>();

foreach(var item in list)
{
    var stuff = (from m in list
                 where m == item
                 select m);
    if (stuff.Count() > 1)
    {
        temp = temp.Concat(stuff);
    }
}

仅查询重复列表

4 个答案: