Найшвидший спосіб порівняння двох загальних списків для відмінностей

Який найшвидший (і найменш трудомісткий) для порівняння двох масивних (> 50 000 позицій), і в результаті є два списки, як наведений нижче:

1. елементи, які відображаються у першому списку, а не у другому
2. елементи, які відображаються у другому списку, але не в першому

В даний час я працюю зі списком або IReadOnlyCollection і вирішую це питання у запиті на посилання:

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

Але це не так добре, як хотілося б. Будь-яка ідея зробити це більш швидким та менш ресурсоємним, оскільки мені потрібно обробити багато списків?

Використання Except:

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

Я підозрюю, що існують підходи, які насправді виявляться незначно швидшими за цей, але навіть це буде набагато швидше, ніж ваш підхід O (N * M).

Якщо ви хочете комбінувати їх, ви можете створити метод із зазначеним вище, а потім повернути:

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

Слід зазначити, що між початковим кодом у питанні та рішенням тут є різниця в результатах: про будь-які повторювані елементи, що знаходяться лише в одному списку, буде повідомлено лише один раз разом із моїм кодом, тоді як про них буде повідомлено стільки разів, коли вони трапляються в вихідному коді.

Наприклад, зі списками [1, 2, 2, 2, 3]та [1], "початковим кодом" буде результат "елементів у списку1, але не список2" [2, 2, 2, 3]. З моїм кодом це просто було б [2, 3]. У багатьох випадках це не буде проблемою, але варто пам’ятати про це.

Більш ефективним було б використання Enumerable.Except:

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

Цей метод реалізований за допомогою відкладеного виконання. Це означає, що ви можете написати наприклад:

var first10 = inListButNotInList2.Take(10);

Він також ефективний, оскільки використовує внутрішньо Set<T>для порівняння об'єктів. Вона працює, спочатку збираючи всі різні значення з другої послідовності, а потім передаючи результати першої, перевіряючи, чи не були вони раніше.

Спосіб числення

Визначає, чи однакові дві послідовності відповідно до порівняння рівності. MS.Docs

Enumerable.SequenceEqual(list1, list2);

Це працює для всіх примітивних типів даних. Якщо вам потрібно використовувати його на користувацьких об'єктах, вам потрібно реалізуватиIEqualityComparer

Визначає методи підтримки порівняння об'єктів для рівності.

Інтерфейс IEqualityComparer

Визначає методи підтримки порівняння об'єктів для рівності. MS.Docs для IEqualityComparer

Якщо ви хочете, щоб результати були нечутливими до регістру , буде діяти наступне:

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

firstNotSecondмістив би b1.dll

secondNotFirstмістив би b2.dll

Не для цієї проблеми, але ось якийсь код для порівняння списків для рівних, а не! однакові об'єкти:

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

спробуйте так:

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

Іноді потрібно лише знати, чи два списки різні, а не те, що ці відмінності. У такому випадку розгляньте можливість додавання цього методу розширення до свого проекту. Зауважте, що ваші перелічені об'єкти повинні реалізувати IEquatable!

Використання:

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
}

Незалежно від Componentкласу, показані тут методи Carповинні бути реалізовані майже однаково.

Дуже важливо відзначити, як ми написали GetHashCode. Для того, щоб належним чином реалізувати IEquatable, Equalsі GetHashCode треба працювати на властивості екземпляра в логічно сумісним способом.

Два списки з однаковим вмістом все ще є різними об'єктами, і вони створюватимуть різні хеш-коди. Оскільки ми хочемо, щоб ці два списки розглядалися як рівні, ми повинні дозволити GetHashCodeвиробляти однакове значення для кожного з них. Ми можемо досягти цього, делегувавши хеш-код кожному елементу у списку, і використовувати стандартний побітовий XOR для об'єднання їх усіх. XOR - порядок агностики, тому не має значення, чи списки сортуються по-різному. Важливо лише те, що вони не містять нічого, крім рівнозначних членів.

Зауважте: дивна назва означає те, що метод не враховує порядок елементів у списку. Якщо ви дбаєте про порядок елементів у списку, цей спосіб не для вас!

Я використав цей код для порівняння двох списків, що мають мільйон записів.

Цей метод не забере багато часу

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

Якщо потрібен лише комбінований результат, це також буде працювати:

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

де T - тип елемента списків.

Можливо, це смішно, але працює для мене

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

Я думаю, що це простий і простий спосіб порівняння двох списків за елементами

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)

Це найкраще рішення, яке ви знайдете

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