Cách nhanh nhất để so sánh hai danh sách chung cho sự khác biệt

Cách nhanh nhất (và ít tốn tài nguyên nhất) để so sánh hai khối lượng lớn (> 50.000 mặt hàng) và kết quả là có hai danh sách như các danh sách dưới đây:

1. các mục hiển thị trong danh sách đầu tiên nhưng không xuất hiện trong danh sách thứ hai
2. các mục hiển thị trong danh sách thứ hai nhưng không xuất hiện trong danh sách thứ nhất

Hiện tại tôi đang làm việc với Danh sách hoặc IReadOnlyCollection và giải quyết vấn đề này trong truy vấn linq:

var list1 = list.Where(i => !list2.Contains(i)).ToList();
var list2 = list2.Where(i => !list.Contains(i)).ToList();

Nhưng điều này không thực hiện tốt như tôi muốn. Bất kỳ ý tưởng làm cho điều này nhanh hơn và ít tốn tài nguyên hơn vì tôi cần xử lý rất nhiều danh sách?

Sử dụng Except:

var firstNotSecond = list1.Except(list2).ToList();
var secondNotFirst = list2.Except(list1).ToList();

Tôi nghi ngờ có những cách tiếp cận thực sự sẽ nhanh hơn một chút so với cách tiếp cận này, nhưng thậm chí điều này sẽ nhanh hơn rất nhiều so với cách tiếp cận O (N * M) của bạn.

Nếu bạn muốn kết hợp những thứ này, bạn có thể tạo một phương thức với ở trên và sau đó là một câu lệnh return:

return !firstNotSecond.Any() && !secondNotFirst.Any();

Một điểm cần lưu ý là có là một sự khác biệt trong kết quả giữa các mã gốc trong các câu hỏi và giải pháp ở đây: bất kỳ yếu tố trùng lặp mà chỉ trong một danh sách sẽ chỉ được thông báo một lần với mã của tôi, trong khi đó họ sẽ được báo cáo như nhiều lần khi chúng xảy ra trong mã gốc.

Ví dụ, với danh sách [1, 2, 2, 2, 3]và [1], "các phần tử trong list1 chứ không phải list2" trong mã gốc sẽ là [2, 2, 2, 3]. Với mã của tôi, nó sẽ chỉ là [2, 3]. Trong nhiều trường hợp sẽ không phải là một vấn đề, nhưng nó đáng để nhận thức.

Hiệu quả hơn sẽ được sử dụng Enumerable.Except:

var inListButNotInList2 = list.Except(list2);
var inList2ButNotInList = list2.Except(list);

Phương pháp này được thực hiện bằng cách sử dụng thực thi hoãn lại. Điều đó có nghĩa là bạn có thể viết ví dụ:

var first10 = inListButNotInList2.Take(10);

Nó cũng hiệu quả vì bên trong nó sử dụng a Set<T>để so sánh các đối tượng. Nó hoạt động bằng cách đầu tiên thu thập tất cả các giá trị riêng biệt từ chuỗi thứ hai, sau đó truyền kết quả của lần đầu tiên, kiểm tra xem chúng chưa từng thấy trước đó.

Phương pháp vô số.SequenceEqual

Xác định xem hai chuỗi có bằng nhau theo một so sánh bằng không. MS.Docs

Enumerable.SequenceEqual(list1, list2);

Điều này làm việc cho tất cả các loại dữ liệu nguyên thủy. Nếu bạn cần sử dụng nó trên các đối tượng tùy chỉnh, bạn cần thực hiệnIEqualityComparer

Xác định các phương thức để hỗ trợ so sánh các đối tượng cho sự bình đẳng.

Giao diện IEqualityComparer

Xác định các phương thức để hỗ trợ so sánh các đối tượng cho sự bình đẳng. MS.Docs cho IEqualityComparer

Nếu bạn muốn kết quả không phân biệt chữ hoa chữ thường , phần sau sẽ hoạt động:

List<string> list1 = new List<string> { "a.dll", "b1.dll" };
List<string> list2 = new List<string> { "A.dll", "b2.dll" };

var firstNotSecond = list1.Except(list2, StringComparer.OrdinalIgnoreCase).ToList();
var secondNotFirst = list2.Except(list1, StringComparer.OrdinalIgnoreCase).ToList();

firstNotSecondsẽ chứa b1.dll

secondNotFirstsẽ chứa b2.dll

Không phải cho vấn đề này, nhưng đây là một số mã để so sánh các danh sách cho bằng nhau và không! các đối tượng giống hệt nhau:

public class EquatableList<T> : List<T>, IEquatable<EquatableList<T>> where    T : IEquatable<T>

/// <summary>
/// True, if this contains element with equal property-values
/// </summary>
/// <param name="element">element of Type T</param>
/// <returns>True, if this contains element</returns>
public new Boolean Contains(T element)
{
    return this.Any(t => t.Equals(element));
}

/// <summary>
/// True, if list is equal to this
/// </summary>
/// <param name="list">list</param>
/// <returns>True, if instance equals list</returns>
public Boolean Equals(EquatableList<T> list)
{
    if (list == null) return false;
    return this.All(list.Contains) && list.All(this.Contains);
}

thử cách này:

var difList = list1.Where(a => !list2.Any(a1 => a1.id == a.id))
            .Union(list2.Where(a => !list1.Any(a1 => a1.id == a.id)));

using System.Collections.Generic;
using System.Linq;

namespace YourProject.Extensions
{
    public static class ListExtensions
    {
        public static bool SetwiseEquivalentTo<T>(this List<T> list, List<T> other)
            where T: IEquatable<T>
        {
            if (list.Except(other).Any())
                return false;
            if (other.Except(list).Any())
                return false;
            return true;
        }
    }
}

Đôi khi bạn chỉ cần biết nếu hai danh sách là khác nhau, và không phải những khác biệt đó là gì. Trong trường hợp đó, hãy xem xét thêm phương thức mở rộng này vào dự án của bạn. Lưu ý rằng các đối tượng được liệt kê của bạn nên triển khai IEquitable!

Sử dụng:

public sealed class Car : IEquatable<Car>
{
    public Price Price { get; }
    public List<Component> Components { get; }

    ...
    public override bool Equals(object obj)
        => obj is Car other && Equals(other);

    public bool Equals(Car other)
        => Price == other.Price
            && Components.SetwiseEquivalentTo(other.Components);

    public override int GetHashCode()
        => Components.Aggregate(
            Price.GetHashCode(),
            (code, next) => code ^ next.GetHashCode()); // Bitwise XOR
}

Dù Componentlớp học là gì, các phương thức hiển thị ở đây Carnên được thực hiện gần như giống hệt nhau.

Điều rất quan trọng cần lưu ý là chúng tôi đã viết GetHashCode như thế nào. Để thực hiện đúng IEquatable, Equalsvà GetHashCode phải hoạt động trên tài sản của ví dụ trong một cách tương thích một cách logic.

Hai danh sách có cùng nội dung vẫn là các đối tượng khác nhau và sẽ tạo ra các mã băm khác nhau. Vì chúng tôi muốn hai danh sách này được coi là bằng nhau, chúng tôi phải cho phép GetHashCodetạo ra cùng một giá trị cho mỗi danh sách. Chúng ta có thể thực hiện điều này bằng cách ủy thác mã băm cho mọi thành phần trong danh sách và sử dụng XOR bitwise tiêu chuẩn để kết hợp tất cả chúng. XOR không theo thứ tự, vì vậy sẽ không có vấn đề gì nếu các danh sách được sắp xếp khác nhau. Nó chỉ quan trọng rằng họ không chứa gì ngoài các thành viên tương đương.

Lưu ý: tên lạ là ngụ ý thực tế là phương thức không xem xét thứ tự của các phần tử trong danh sách. Nếu bạn quan tâm đến thứ tự của các yếu tố trong danh sách, phương pháp này không dành cho bạn!

Tôi đã sử dụng mã này để so sánh hai danh sách có hàng triệu hồ sơ.

Phương pháp này sẽ không mất nhiều thời gian

    //Method to compare two list of string
    private List<string> Contains(List<string> list1, List<string> list2)
    {
        List<string> result = new List<string>();

        result.AddRange(list1.Except(list2, StringComparer.OrdinalIgnoreCase));
        result.AddRange(list2.Except(list1, StringComparer.OrdinalIgnoreCase));

        return result;
    }

Nếu chỉ kết hợp cần thiết, điều này cũng sẽ hoạt động:

var set1 = new HashSet<T>(list1);
var set2 = new HashSet<T>(list2);
var areEqual = set1.SetEquals(set2);

Trong đó T là loại phần tử danh sách.

Có thể buồn cười, nhưng làm việc cho tôi

chuỗi.Join ("", List1)! = string.Join ("", List2)

Tôi nghĩ rằng đây là một cách đơn giản và dễ dàng để so sánh hai yếu tố danh sách theo yếu tố

x=[1,2,3,5,4,8,7,11,12,45,96,25]
y=[2,4,5,6,8,7,88,9,6,55,44,23]

tmp = []


for i in range(len(x)) and range(len(y)):
    if x[i]>y[i]:
        tmp.append(1)
    else:
        tmp.append(0)
print(tmp)

Đây là giải pháp tốt nhất bạn sẽ tìm thấy

var list3 = list1.Where(l => list2.ToList().Contains(l));