Question

假设我们有一个“A学生”列表和一个“B学生”列表。然后，我们将这两个列表添加到更通用的列表中，称为“学生”。然后，有人决定通过在通用“学生”列表中添加重复的“A学生”列表来使我们的生活变得复杂。删除“A学生”重复列表之一的最有效方法是什么？请注意，涉及两个自定义类。

代码中的通用学生列表称为lstStudents。这是我要从中删除任何重复项的列表。

（我试图提出一个更好的例子，但这是我现在能做的最好的。）

我不必使用LINQ，但它可用。 MoreLinq也可以使用。

以下是我的课程：

public class Student
{
    public Student(string _name, int _age, Exam _lastExam)
    {
        name = _name;
        age = _age;
        lastExam = _lastExam;
    }

    public string name { get; set; }
    public int age { get; set; }
    public Exam lastExam { get; set; }
}

public class Exam
{
    public Exam(int _correct, int _possible)
    {
        correct = _correct;
        possible = _possible;
    }

    public int correct { get; set; }
    public int possible { get; set; }
}

这是创建混乱的代码：

List<List<Student>> lstStudents = new List<List<Student>>();
List<Student> lstAStudents = new List<Student>();
List<Student> lstDuplicateAStudents = new List<Student>();
List<Student> lstBStudents = new List<Student>();

// Create a list of some A students
lstAStudents.Add(new Student("Alex", 14, new Exam(98,100)));
lstAStudents.Add(new Student("Kim", 13, new Exam(96, 100)));
lstAStudents.Add(new Student("Brian", 14, new Exam(92, 100)));
lstStudents.Add(lstAStudents);

// Create a duplicate list of A students
lstDuplicateAStudents.Add(new Student("Alex", 14, new Exam(98, 100)));
lstDuplicateAStudents.Add(new Student("Kim", 13, new Exam(96, 100)));
lstDuplicateAStudents.Add(new Student("Brian", 14, new Exam(92, 100)));
lstStudents.Add(lstDuplicateAStudents);

// Create a list of some B students
lstBStudents.Add(new Student("John", 13, new Exam(88, 100)));
lstBStudents.Add(new Student("Jenny", 13, new Exam(80, 100)));
lstBStudents.Add(new Student("Jamie", 15, new Exam(81, 100)));
lstStudents.Add(lstBStudents);

Answer 1

可能你可以拿一个会积累唯一列表的集合：

var set = new HashSet<List<Student>>(new CustomComparer());
foreach (List<List<Student>> list in source)
{
  if (set.Contains(list))
    continue;
  set.Add(list)
}


public class CustomComparer : IEqualityComparer<List<Student>>
{
   public bool Equals(List<Student> one, List<Student> two)
   {
     if (one.Count != two.Count) return false;

     // simplest possible code to compare two lists
     // warning: runs in O(N*logN) for each compare
     return one.OrderBy(s=>s).SequenceEqual(two.OrderBy(s=>s));
   }

   public int GetHashCodeList<Student> item)
   {
     int ret = -1;
     foreach (var s in item)
       ret ^= s.GetHashCode();
     return ret;
   }
}

此解决方案的主要问题是用于比较两个列表＆lt;＆gt;的代码。包含不同顺序的相同元素的列表是否相同？如果是，我们需要通过预先对每个列表进行排序来更改顺序（以节省比较时间），或者每次对每个列表的副本进行排序，这将导致额外的时间损失。所以我想主要的问题是你的名单有多大。对于低于1000名学生/ 100名列表的值，性能问题不应引人注意。

另一个问题是GetHashCode实现 - 它是O（N），我们无处可以缓存计算值，因为List是一个框架结构。为了解决这个问题，我建议引入StudentList类，它将具有比较器（现在我们必须在外部指定它）并获得带缓存的哈希代码。

此外，还有更好的generic collection equivalence comparer可用实现。

Answer 2

您可以Student和Exam使用IEquatable<T>：

public class Student: IEquatable<Student>
{
    ...

    public bool Equals(Student other)
    {
        return name == other.name && age == other.age 
                    && lastExam.Equals(other.lastExam);
    }

    public override bool Equals(object obj)
    {
        Student student = obj as Student;
        return Equals(student);
    }

    public override int GetHashCode()
    {
        return name.GetHashCode() ^ 
             age.GetHashCode() ^ lastExam.GetHashCode();
    }
}

Exam：

public class Exam: IEquatable<Exam>
{
    ...

    public bool Equals(Exam exam)
    {
        return exam.correct == correct && exam.possible == possible;
    }

    public override bool Equals(object obj)
    {
        Exam exam = obj as Exam;
        return Equals(exam);
    }

    public override int GetHashCode()
    {
        return correct.GetHashCode() ^ possible.GetHashCode();
    }
}

然后为IQualityComparer<T>构建自定义List<Student>：

public class StudentListComparer : IEqualityComparer<List<Student>>
{
    public bool Equals(List<Student> x, List<Student> y)
    {
        return x.OrderBy(a => a.name)
                .SequenceEqual(y.OrderBy(b => b.name));
    }

    public int GetHashCode(List<Student> obj)
    {
        return obj.Aggregate(0, (current, t) => current ^ t.GetHashCode());
    }
}

然后你可以Distinct得到结果：

var result = lstStudents.Distinct(new StudentListComparer());

C＃从包含列表的列表中删除重复项

2 个答案: