删除int数组列表中的重复项

Question

具有int数组的列表，例如：

List<int[]> intArrList = new List<int[]>();
intArrList.Add(new int[3] { 0, 0, 0 });
intArrList.Add(new int[5] { 20, 30, 10, 4, 6 });  //this
intArrList.Add(new int[3] { 1, 2, 5 });
intArrList.Add(new int[5] { 20, 30, 10, 4, 6 });  //this
intArrList.Add(new int[3] { 12, 22, 54 });
intArrList.Add(new int[5] { 1, 2, 6, 7, 8 });
intArrList.Add(new int[4] { 0, 0, 0, 0 });

您将如何删除重复项（重复是指list的元素具有相同的长度和相同的编号）。

在该示例中，我将删除元素{ 20, 30, 10, 4, 6 }因为它被两次发现

我当时正在考虑按元素大小对列表进行排序，然后让每个元素循环进行休息，但是我不确定如何做到这一点。

另一个问题是，如果使用其他结构（例如哈希）会更好...如果可以，如何使用它？

Answer 1

使用GroupBy ：

var result = intArrList.GroupBy(c => String.Join(",", c))
                       .Select(c => c.First().ToList()).ToList();

结果：

{0，0，0}

{20，30，10，4，6}

{1,2,5}

{12，22，54}

{1,2,6,7,8}

{0，0，0，0}

编辑 ：如果要考虑{1,2,3,4}等于{2,3,4,1} ，则需要使用OrderBy如下所示：

var result = intArrList.GroupBy(p => string.Join(", ", p.OrderBy(c => c)))
                       .Select(c => c.First().ToList()).ToList(); 

EDIT2 ：为了帮助理解LINQ GroupBy解决方案的工作方式，请考虑以下方法：

public List<int[]> FindDistinctWithoutLinq(List<int[]> lst)
{
    var dic = new Dictionary<string, int[]>();
    foreach (var item in lst)
    {
        string key = string.Join(",", item.OrderBy(c=>c));

        if (!dic.ContainsKey(key))
        {
            dic.Add(key, item);
        }
    }

    return dic.Values.ToList();
}

Answer 2

您可以定义自己的IEqualityComparer实现，并将其与IEnumerable.Distinct结合使用：

class MyComparer : IEqualityComparer<int[]> 
{
    public int GetHashCode(int[] instance) { return 0; } // TODO: better HashCode for arrays
    public bool Equals(int[] instance, int[] other)
    {
        if (other == null || instance == null || instance.Length != other.Length) return false;

        return instance.SequenceEqual(other);
    }
}

现在编写此代码，以获取列表的唯一值：

var result = intArrList.Distinct(new MyComparer());

但是，如果您想要不同的排列，还应该以这种方式实现比较器：

public bool Equals(int[] instance, int[] other)
{
    if (ReferenceEquals(instance, other)) return true; // this will return true when both arrays are NULL
    if (other == null || instance == null) return false;
    return instance.All(x => other.Contains(x)) && other.All(x => instance.Contains(x));
}

编辑：为获得更好的GetashCode实现，您可以按照@Mick的答案中的建议查看此帖子 。

Answer 3

好代码从这里到这里 。 GetHashCode的更通用实现将使它更通用，但是我相信下面的实现是最可靠的

class Program
{
    static void Main(string[] args)
    {
        List<int[]> intArrList = new List<int[]>();
        intArrList.Add(new int[3] { 0, 0, 0 });
        intArrList.Add(new int[5] { 20, 30, 10, 4, 6 });  //this
        intArrList.Add(new int[3] { 1, 2, 5 });
        intArrList.Add(new int[5] { 20, 30, 10, 4, 6 });  //this
        intArrList.Add(new int[3] { 12, 22, 54 });
        intArrList.Add(new int[5] { 1, 2, 6, 7, 8 });
        intArrList.Add(new int[4] { 0, 0, 0, 0 });

        var test = intArrList.Distinct(new IntArrayEqualityComparer());
        Console.WriteLine(test.Count());
        Console.WriteLine(intArrList.Count());
    }

    public class IntArrayEqualityComparer : IEqualityComparer<int[]>
    {
        public bool Equals(int[] x, int[] y)
        {
            return ArraysEqual(x, y);
        }

        public int GetHashCode(int[] obj)
        {
            int hc = obj.Length;
            for (int i = 0; i < obj.Length; ++i)
            {
                hc = unchecked(hc * 17 + obj[i]);
            }
            return hc;
        }

        static bool ArraysEqual<T>(T[] a1, T[] a2)
        {
            if (ReferenceEquals(a1, a2))
                return true;

            if (a1 == null || a2 == null)
                return false;

            if (a1.Length != a2.Length)
                return false;

            EqualityComparer<T> comparer = EqualityComparer<T>.Default;
            for (int i = 0; i < a1.Length; i++)
            {
                if (!comparer.Equals(a1[i], a2[i])) return false;
            }
            return true;
        }
    }
}

编辑： IEqualityComparer的通用实现，用于任何类型的数组：-

public class ArrayEqualityComparer<T> : IEqualityComparer<T[]>
{
    public bool Equals(T[] x, T[] y)
    {
        if (ReferenceEquals(x, y))
            return true;

        if (x == null || y == null)
            return false;

        if (x.Length != y.Length)
            return false;

        EqualityComparer<T> comparer = EqualityComparer<T>.Default;
        for (int i = 0; i < x.Length; i++)
        {
            if (!comparer.Equals(x[i], y[i])) return false;
        }
        return true;
    }

    public int GetHashCode(T[] obj)
    {
        int hc = obj.Length;
        for (int i = 0; i < obj.Length; ++i)
        {
            hc = unchecked(hc * 17 + obj[i].GetHashCode());
        }
        return hc;
    }
}

Edit2 ：如果整数在数组中的排序没关系，我会

var test = intArrList.Select(a => a.OrderBy(e => e).ToArray()).Distinct(comparer).ToList();

Answer 4

List<int[]> CopyString1 = new List<int[]>();
CopyString1.AddRange(intArrList);
List<int[]> CopyString2 = new List<int[]>();
CopyString2.AddRange(intArrList);
for (int i = 0; i < CopyString2.Count(); i++)
{
    for (int j = i; j < CopyString1.Count(); j++)
    {
        if (i != j && CopyString2[i].Count() == CopyString1[j].Count())
        {
            var cnt = 0;
            for (int k = 0; k < CopyString2[i].Count(); k++)
            {
                if (CopyString2[i][k] == CopyString1[j][k])
                    cnt++;
                else
                    break;
            }
            if (cnt == CopyString2[i].Count())
                intArrList.RemoveAt(i);
        }
    }
}

Answer 5

使用BenchmarkDotNet比较@ S.Akbari和@Mick解决方案的性能

编辑：

SAkbari_FindDistinctWithoutLinq具有对ContainsKey的冗余调用，因此我添加了改进的更快版本：SAkbari_FindDistinctWithoutLinq2

Method |     Mean |     Error |    StdDev |
--------------------------------- |---------:|----------:|----------:|
  SAkbari_FindDistinctWithoutLinq | 4.021 us | 0.0723 us | 0.0676 us |
 SAkbari_FindDistinctWithoutLinq2 | 3.930 us | 0.0529 us | 0.0495 us |
         SAkbari_FindDistinctLinq | 5.597 us | 0.0264 us | 0.0234 us |
            Mick_UsingGetHashCode | 6.339 us | 0.0265 us | 0.0248 us |

BenchmarkDotNet=v0.10.13, OS=Windows 10 Redstone 3 [1709, Fall Creators Update] (10.0.16299.248)
Intel Core i7-7700 CPU 3.60GHz (Kaby Lake), 1 CPU, 8 logical cores and 4 physical cores
Frequency=3515625 Hz, Resolution=284.4444 ns, Timer=TSC
.NET Core SDK=2.1.100
  [Host]     : .NET Core 2.0.5 (CoreCLR 4.6.26020.03, CoreFX 4.6.26018.01), 64bit RyuJIT
  DefaultJob : .NET Core 2.0.5 (CoreCLR 4.6.26020.03, CoreFX 4.6.26018.01), 64bit RyuJIT

基准测试：

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp1
{
    public class Program
    {
        List<int[]> intArrList = new List<int[]>
        {
            new int[] { 0, 0, 0 },
            new int[] { 20, 30, 10, 4, 6 },  //this
            new int[] { 1, 2, 5 },
            new int[] { 20, 30, 10, 4, 6 },  //this
            new int[] { 12, 22, 54 },
            new int[] { 1, 2, 6, 7, 8 },
            new int[] { 0, 0, 0, 0 }
        };

        [Benchmark]
        public List<int[]> SAkbari_FindDistinctWithoutLinq() => FindDistinctWithoutLinq(intArrList);

        [Benchmark]
        public List<int[]> SAkbari_FindDistinctWithoutLinq2() => FindDistinctWithoutLinq2(intArrList);

        [Benchmark]
        public List<int[]> SAkbari_FindDistinctLinq() => FindDistinctLinq(intArrList);

        [Benchmark]
        public List<int[]> Mick_UsingGetHashCode() => FindDistinctLinq(intArrList);

        static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<Program>();
        }

        public static List<int[]> FindDistinctWithoutLinq(List<int[]> lst)
        {
            var dic = new Dictionary<string, int[]>();
            foreach (var item in lst)
            {
                string key = string.Join(",", item.OrderBy(c => c));

                if (!dic.ContainsKey(key))
                {
                    dic.Add(key, item);
                }
            }

            return dic.Values.ToList();
        }

        public static List<int[]> FindDistinctWithoutLinq2(List<int[]> lst)
        {
            var dic = new Dictionary<string, int[]>();

            foreach (var item in lst)
                dic.TryAdd(string.Join(",", item.OrderBy(c => c)), item);

            return dic.Values.ToList();
        }

        public static List<int[]> FindDistinctLinq(List<int[]> lst)
        {
            return lst.GroupBy(p => string.Join(", ", p.OrderBy(c => c)))
                       .Select(c => c.First().ToArray()).ToList();
        }

        public static List<int[]> UsingGetHashCode(List<int[]> lst)
        {
            return lst.Select(a => a.OrderBy(e => e).ToArray()).Distinct(new IntArrayEqualityComparer()).ToList();
        }
    }

    public class IntArrayEqualityComparer : IEqualityComparer<int[]>
    {
        public bool Equals(int[] x, int[] y)
        {
            return ArraysEqual(x, y);
        }

        public int GetHashCode(int[] obj)
        {
            int hc = obj.Length;
            for (int i = 0; i < obj.Length; ++i)
            {
                hc = unchecked(hc * 17 + obj[i]);
            }
            return hc;
        }

        static bool ArraysEqual<T>(T[] a1, T[] a2)
        {
            if (ReferenceEquals(a1, a2))
                return true;

            if (a1 == null || a2 == null)
                return false;

            if (a1.Length != a2.Length)
                return false;

            EqualityComparer<T> comparer = EqualityComparer<T>.Default;
            for (int i = 0; i < a1.Length; i++)
            {
                if (!comparer.Equals(a1[i], a2[i])) return false;
            }
            return true;
        }
    }
}

Answer 6

输入清单；

List<List<int>> initList = new List<List<int>>();
initList.Add(new List<int>{ 0, 0, 0 });
initList.Add(new List<int>{ 20, 30, 10, 4, 6 });  //this
initList.Add(new List<int> { 1, 2, 5 });
initList.Add(new List<int> { 20, 30, 10, 4, 6 });  //this
initList.Add(new List<int> { 12, 22, 54 });
initList.Add(new List<int> { 1, 2, 6, 7, 8 });
initList.Add(new List<int> { 0, 0, 0, 0 });

您可以创建一个结果列表，并且在添加元素之前可以检查它是否已经添加。 我只是比较了列表计数，并使用了p.Except(item).Any()调用来检查列表是否包含该元素。

List<List<int>> returnList = new List<List<int>>();

foreach (var item in initList)
{
    if (returnList.Where(p => !p.Except(item).Any() && !item.Except(p).Any()
                             && p.Count() == item.Count() ).Count() == 0)
    returnList.Add(item);
}

Answer 7

您可以使用HashSet。 HashSet是用于保证唯一性的集合，您可以比较集合，相交，联合上的项目。 等等

优点：无重复项，易于处理数据组，效率更高缺点：您无法在集合中获得特定项，例如：list [0]对HashSets不起作用。 您只能枚举项目。 例如foreach

这是一个例子：

using System;
using System.Collections.Generic;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            HashSet<HashSet<int>> intArrList = new HashSet<HashSet<int>>(new HashSetIntComparer());
            intArrList.Add(new HashSet<int>(3) { 0, 0, 0 });
            intArrList.Add(new HashSet<int>(5) { 20, 30, 10, 4, 6 });  //this
            intArrList.Add(new HashSet<int>(3) { 1, 2, 5 });
            intArrList.Add(new HashSet<int>(5) { 20, 30, 10, 4, 6 });  //this
            intArrList.Add(new HashSet<int>(3) { 12, 22, 54 });
            intArrList.Add(new HashSet<int>(5) { 1, 2, 6, 7, 8 });
            intArrList.Add(new HashSet<int>(4) { 0, 0, 0, 0 });

            // Checking the output
            foreach (var item in intArrList)
            {
                foreach (var subHasSet in item)
                {
                    Console.Write("{0} ", subHasSet);
                }

                Console.WriteLine();
            }            

            Console.Read();
        }

        private class HashSetIntComparer : IEqualityComparer<HashSet<int>>
        {
            public bool Equals(HashSet<int> x, HashSet<int> y)
            {
                // SetEquals does't set anything. It's a method for compare the contents of the HashSet. 
                // Such a poor name from .Net
                return x.SetEquals(y);
            }

            public int GetHashCode(HashSet<int> obj)
            {
                //TODO: implemente a better HashCode
                return base.GetHashCode();
            }
        }
    }
}


Output:
0
20 30 10 4 6
1 2 5
12 22 54
1 2 6 7 8

注意：由于0重复多次，因此HashSet仅将0视为一次。 如果需要在0 0 0 0和0 0 0之间进行区分，则可以将HashSet<HashSet<int>> for HashSet<List<int>>替换HashSet<HashSet<int>> for HashSet<List<int>>并实现对列表的比较器。

您可以使用此链接来学习如何比较列表： https : //social.msdn.microsoft.com/Forums/en-US/2ff3016c-bd61-4fec-8f8c-7b6c070123fa/c-compare-two-lists-of -objects？forum = csharplanguage

如果您想了解有关集合和数据类型的更多信息，那么此课程是学习它的理想场所： https : //app.pluralsight.com/player? course=csharp-collections&author=simon-robinson&name=csharp-collections-fundamentals-m9- sets＆clip = 1＆mode = live

Answer 8

使用MoreLINQ，使用DistinctBy可以非常简单。

var result = intArrList.DistinctBy(x => string.Join(",", x));

与GroupBy答案类似，如果您希望区分顺序，则只需联接中的顺序即可。

var result = intArrList.DistinctBy(x => string.Join(",", x.OrderBy(y => y)));

编辑 ：这是它的实现方式

public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
        {
            if (source == null) throw new ArgumentNullException(nameof(source));
            if (keySelector == null) throw new ArgumentNullException(nameof(keySelector));

            return _(); IEnumerable<TSource> _()
            {
                var knownKeys = new HashSet<TKey>(comparer);
                foreach (var element in source)
                {
                    if (knownKeys.Add(keySelector(element)))
                        yield return element;
                }
            }
        }

因此，如果您不需要MoreLINQ，则可以使用如下方法：

private static IEnumerable<int[]> GetUniqueArrays(IEnumerable<int[]> source)
    {
        var knownKeys = new HashSet<string>();
        foreach (var element in source)
        {
            if (knownKeys.Add(string.Join(",", element)))
                yield return element;
        }
    }