Farklılıklar için iki genel listeyi karşılaştırmanın en hızlı yolu

İki büyük (> 50.000 öğe) karşılaştırmak için en hızlı (ve en az kaynak yoğun) ve sonuç olarak aşağıdaki gibi iki liste var:

1. ilk listede görünen ancak ikinci listede görünmeyen öğeler
2. ikinci listede görünen ancak ilk listede olmayan öğeler

Şu anda List veya IReadOnlyCollection ile çalışıyorum ve bir linq sorgusunda bu sorunu çözmek:

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

Ama bu istediğim kadar iyi bir performans sergilemiyor. Listeleri çok işlemek için bu daha hızlı ve daha az kaynak yoğun hale getirmek herhangi bir fikir?

Kullanım Except:

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

Aslında bundan biraz daha hızlı olan yaklaşımlar olduğundan şüpheleniyorum, ancak bu bile O (N * M) yaklaşımınızdan çok daha hızlı olacaktır .

Bunları birleştirmek istiyorsanız, yukarıdaki yöntemle bir yöntem ve ardından bir return ifadesi oluşturabilirsiniz:

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

Nota Bir nokta var ki olan söz konusu orijinal kod ve burada çözelti arasındaki sonuçlarında bir farkı: birçok olarak rapor olurdu oysa sadece tek bir listede hiçbir yinelenen elemanlar sadece benim koduyla bir kez rapor edilecektir orijinal kodda göründükleri zaman.

Örneğin, listeleri içeren [1, 2, 2, 2, 3]ve [1], "Liste1 elemanların ancak list2" orijinal kodunda sonucu olacaktır [2, 2, 2, 3]. Benim kod ile sadece olurdu [2, 3]. Çoğu durumda bu bir sorun olmayacak, ancak farkında olmaya değer.

Daha verimli kullanmak Enumerable.Except:

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

Bu yöntem ertelenmiş yürütme kullanılarak uygulanır. Bu, örneğin yazabileceğiniz anlamına gelir:

var first10 = inListButNotInList2.Take(10);

Set<T>Nesneleri karşılaştırmak için dahili olarak a kullandığından da etkilidir . İlk olarak ikinci sekanstan tüm farklı değerleri toplayıp, daha önce görülmediklerini kontrol ederek birincinin sonuçlarını aktararak çalışır.

Numaralandırılabilir.SequenceEqual Yöntemi

Eşitlik karşılaştırıcısına göre iki dizinin eşit olup olmadığını belirler. MS.Docs

Enumerable.SequenceEqual(list1, list2);

Bu, tüm ilkel veri türleri için geçerlidir. Özel nesnelerde kullanmanız gerekiyorsa, uygulamanız gerekirIEqualityComparer

Eşitlik için nesnelerin karşılaştırılmasını destekleyen yöntemleri tanımlar.

IEqualityComparer Arayüzü

Eşitlik için nesnelerin karşılaştırılmasını destekleyen yöntemleri tanımlar. IEqualityComparer için MS.Docs

Sonuçların büyük / küçük harfe duyarsız olmasını istiyorsanız , aşağıdakiler işe yarar :

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();

firstNotSecondb1.dll içerir

secondNotFirstb2.dll içerecektir

Bu Sorun için değil, ama eşit ve değil için listeleri karşılaştırmak için bazı kod İşte! özdeş nesneler:

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);
}

şu şekilde deneyin:

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;
        }
    }
}

Bazen sadece iki listenin farklı olup olmadığını bilmeniz gerekir , bu farklılıkların ne olduğunu değil. Bu durumda, projenize bu uzantı yöntemini eklemeyi düşünün. Listelenen nesnelerin IEquatable uygulaması gerektiğini unutmayın!

Kullanımı:

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
}

ComponentSınıf ne olursa olsun, burada gösterilen yöntemler Carneredeyse aynı şekilde uygulanmalıdır.

GetHashCode'u nasıl yazdığımızı not etmek çok önemlidir. Sipariş düzgün uygulamak ise IEquatable, Equalsve GetHashCode gereken bir mantıksal uyumlu şekilde örneğin özelliklerinin üzerinde işlem.

Aynı içeriklere sahip iki liste hala farklı nesnelerdir ve farklı karma kodlar oluşturur. Bu iki listenin eşit olarak ele alınmasını istediğimizden, GetHashCodeher biri için aynı değeri üretmemize izin vermeliyiz . Bunu, hashcode'u listedeki her öğeye devrederek ve hepsini birleştirmek için standart bitsel XOR'u kullanarak başarabiliriz. XOR sıraya göre değişmez, bu nedenle listelerin farklı sıralanması önemli değildir. Sadece eşdeğer üyelerden başka bir şey içermemeleri önemlidir.

Not: garip ad, yöntemin listedeki öğelerin sırasını dikkate almadığı anlamına gelir. Listedeki öğelerin sırasını önemsiyorsanız, bu yöntem sizin için değildir!

Milyonlarca kayıt bulunan iki listeyi karşılaştırmak için bu kodu kullandım.

Bu yöntem çok zaman almayacak

    //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;
    }

Yalnızca birleşik sonuç gerekiyorsa, bu da işe yarayacaktır:

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

burada T, liste elemanı türüdür.

Komik olabilir, ama benim için çalışıyor

string.Join ("", List1)! = string.Join ("", Liste2)

Bence bu iki listeyi tek tek karşılaştırmak için basit ve kolay bir yol

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)

Bulabileceğiniz en iyi çözüm

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