Calcul de la différence entre deux grands ensembles

J'ai deux grands ensembles d'entiers et B . Chaque ensemble contient environ un million d'entrées et chaque entrée est un entier positif de 10 chiffres au maximum. $A$$B$

Quel est le meilleur algorithme pour calculer et B ∖ A ? En d'autres termes, comment puis-je calculer efficacement la liste des entrées de A qui ne sont pas dans B et vice versa? Quelle serait la meilleure structure de données pour représenter ces deux ensembles, pour rendre ces opérations efficaces?$A\setminus B$$B\setminus A$$A$$B$

La meilleure approche que je puisse trouver consiste à stocker ces deux ensembles sous forme de listes triées et à comparer chaque élément de avec chaque élément de B , de manière linéaire. Pouvons-nous faire mieux?$A$$B$

Si vous êtes prêt à stocker les ensembles dans une structure de données spécialisée, vous pouvez éventuellement obtenir des complexités intéressantes.

Soit $I=\mathcal O\left(\min\left(|A|,|B|,|A\Delta B|\right)\right)$

Ensuite, vous pouvez définir les opérations et A Δ B , chacune dans O ( I ⋅ log | A | + | B $A\cup B, A\cap B,A\setminus B$$A\Delta B$temps prévu. Donc, essentiellement, vous obtenez la taille minimale des deux ensembles, ou la taille de la différence symétrique, la plus petite des deux. C'est mieux que linéaire, si la différence symétrique est petite; c'est à dire. s'ils ont une grande intersection. En fait, pour les deux opérations de différence d'ensemble que vous souhaitez, cela est pratiquement sensible à la sortie, car ensemble, elles constituent la taille de la différence symétrique.$\mathcal O\left(I\cdot\log\frac{|A|+|B|}{I}\right)$

Voir Confluently Persistent Sets and Maps par Olle Liljenzin (2013) pour plus d'informations.

Un balayage linéaire est le meilleur que je sais faire, si les ensembles sont représentés sous forme de listes chaînées triées. Le temps d'exécution est .$O(|A| + |B|)$

Notez que vous n'avez pas besoin de comparer chaque élément de à chaque élément de B , par paire. Cela conduirait à un temps d'exécution de O ( | A | × | B | ) , ce qui est bien pire. Au lieu de cela, pour calculer la différence symétrique de ces deux ensembles, vous pouvez utiliser une technique similaire à l'opération de "fusion" dans mergesort, modifiée de manière appropriée pour omettre les valeurs communes aux deux ensembles.$A$$B$$O(|A| \times |B|)$

Plus en détail, vous pouvez créer un algorithme récursif comme le suivant pour calculer , en supposant que A et B sont représentés sous forme de listes liées avec leurs valeurs dans l'ordre trié:$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:])

J'ai représenté cela en pseudo-Python. Si vous ne lisez pas Python, A[0]est la tête de la liste liée A, A[1:]est le reste de la liste et +représente la concaténation des listes. Pour des raisons d'efficacité, si vous travaillez en Python, vous ne voudrez probablement pas l'implémenter exactement comme ci-dessus - par exemple, il serait préférable d'utiliser des générateurs, pour éviter de créer de nombreuses listes temporaires - mais je voulais vous montrer les idées sous la forme la plus simple possible. Le but de ce pseudo-code est juste d'illustrer l'algorithme, pas de proposer une implémentation concrète.

Je ne pense pas qu'il soit possible de faire mieux, si vos ensembles sont représentés sous forme de listes triées et que vous souhaitez que la sortie soit fournie sous forme de liste triée. Vous avez fondamentalement regarder tous les éléments de et B . Croquis informel de justification: s'il y a un élément que vous n'avez pas regardé, vous ne pouvez pas le produire, donc le seul cas où vous pouvez omettre de regarder un élément est si vous savez qu'il est présent à la fois dans A et B , mais comment pourriez-vous savoir qu'il est présent si vous n'avez pas regardé sa valeur?$A$$B$$A$$B$

Si A et B sont de taille égale, disjoints et entrelacés (par exemple, les nombres impairs dans A et les nombres pairs dans B), alors la comparaison par paire d'éléments en temps linéaire est probablement optimale.

Si A et B contiennent des blocs d'éléments qui se trouvent exactement dans l'un ou l'autre de A ou B, ou dans les deux, il est possible de calculer la différence, l'union et l'intersection définies en temps sous-linéaire. Par exemple, si A et B diffèrent dans exactement un élément, alors la différence peut être calculée dans O (log n).

http://arxiv.org/abs/1301.3388

une option consiste à utiliser des vecteurs de bits pour représenter les ensembles (où le$n$Cette position représente la présence ou l'absence d'un élément) et les opérations de type ensemble se réduisent ensuite à des opérations binaires qui peuvent être effectuées rapidement (et sur plusieurs bits en parallèle) sur des ordinateurs numériques. dans ce cas$A-B$ = $a \wedge \overline b$ où $a,b$sont les vecteurs de bits. l'efficacité relative de cette technique par rapport à d'autres techniques dépend également de la rareté. pour les ensembles plus denses, il peut être plus efficace que d'autres approches. bien sûr, toute l'opération est également embarrassante en parallèle, de sorte que les opérations définies peuvent être effectuées en parallèle.