Вычислительная разница между двумя большими наборами

У меня есть два больших наборов целых чисел $A$ и . Каждый набор содержит около миллиона записей, и каждая запись представляет собой положительное целое число длиной не более 10 цифр. $B$

Каков наилучший алгоритм для вычисления и ? Другими словами, как я могу эффективно вычислить список записей , которых нет в и наоборот? Какова была бы лучшая структура данных для представления этих двух наборов, чтобы сделать эти операции эффективными?$A\setminus B$$B\setminus A$$A$$B$

Лучший подход, который я могу предложить, - это хранить эти два набора в виде отсортированных списков и сравнивать каждый элемент с каждым элементом линейным образом. Можем ли мы сделать лучше?$A$$B$

Если вы хотите хранить наборы в специализированной структуре данных, вы можете получить некоторые интересные сложности.

Пусть $I=\mathcal O\left(\min\left(|A|,|B|,|A\Delta B|\right)\right)$

Затем вы можете выполнять операции над множествами и A Δ B , каждая в O ( I ⋅ log | A | + | B $A\cup B, A\cap B,A\setminus B$$A\Delta B$ожидаемое время Таким образом, по существу, вы получаете минимальный размер двух наборов или размер симметричной разности, в зависимости от того, что меньше. Это лучше, чем линейное, если симметричная разница мала; то есть. если они имеют большое пересечение. Фактически, для двух требуемых операций разности множеств это практически чувствительно к выходу, поскольку вместе они составляют размер симметричной разности.$\mathcal O\left(I\cdot\log\frac{|A|+|B|}{I}\right)$

См. Confluently Persistent Sets и Maps by Olle Liljenzin (2013) для получения дополнительной информации.

Лучшее, что я знаю, это линейное сканирование, если наборы представлены в виде отсортированных связанных списков. Время работы .$O(|A| + |B|)$

$A$$B$$O(|A| \times |B|)$

$A \setminus B$$A$$B$

difference(A, B):
    if len(B)=0:
        return A # return the leftover list
    if len(A)=0:
        return B # return the leftover list
    if A[0] < B[0]:
        return [A[0]] + difference(A[1:], B)
    elsif A[0] = B[0]:
        return difference(A[1:], B[1:])  # omit the common element
    else:
        return [B[0]] + difference(A, B[1:])

Я представлял это в псевдо-Python. Если вы не читаете Python, он A[0]является главой связанного списка A, A[1:]является остальной частью списка и +представляет собой объединение списков. По соображениям эффективности, если вы работаете в Python, вы, вероятно, не захотите реализовать его точно так же, как описано выше - например, может быть лучше использовать генераторы, чтобы избежать создания многих временных списков - но я хотел показать вам идеи в простейшей форме. Цель этого псевдокода - просто проиллюстрировать алгоритм, а не предложить конкретную реализацию.

$A$$B$$A$$B$

Если A и B имеют одинаковый размер, непересекающиеся и чередующиеся (например, нечетные числа в A и четные числа в B), тогда парное сравнение элементов в линейном времени, вероятно, является оптимальным.

Если A и B содержат блоки элементов, которые находятся точно в одном из A или B или в обоих из них, можно вычислить разность множеств, объединение и пересечение за сублинейное время. Например, если A и B отличаются ровно одним элементом, то разницу можно вычислить в O (log n).

http://arxiv.org/abs/1301.3388

$n$$A-B$$a \wedge \overline b$$a,b$