web-dev-qa-db-fra.com

Calcul d'intersection d'ensemble en temps linéaire?

Existe-t-il un algorithme qui, compte tenu de deux ensembles, calcule leur intersection en temps linéaire?

Je peux exécuter deux boucles for pour vérifier toutes les paires d'éléments, en enregistrant les éléments que je trouve dans les deux ensembles. Cependant, le temps d'exécution sera O (n2). Comment faire cela en O(n) temps?

algorithmmathdata-structuresbig-oset-intersection
36
NEO

Cela dépend de votre implémentation.

Si vous avez un ensemble de hachage (recherche O (1)), l'approche indiquée par toutes les autres affiches est correcte. Itérer sur tous les éléments du premier ensemble. Si c'est dans le deuxième ensemble, ajoutez-le au résultat. Cela s'exécute en O(n) temps.

Si vous avez une arborescence (recherche O (lg n)), cette approche fonctionnera, mais elle s'exécutera en temps O (n lg n). Tu peux faire mieux; il y a une solution O(n). Je suppose que vous avez une sorte d'itérateur qui peut parcourir les éléments des deux ensembles dans l'ordre croissant. Si vous le faites, alors la question est "donnée deux listes dans l'ordre trié, trouver leur intersection. "Cela peut être fait en utilisant une version modifiée de l'algorithme que vous utilisez pour fusionner deux plages. L'idée est de garder une trace des deux itérateurs. À chaque étape, comparer les premiers éléments des plages . S'ils sont égaux, ajoutez l'élément à l'intersection et avancez les deux itérateurs. Si le premier est inférieur au second, avancez le premier itérateur. Si le premier élément est supérieur, avancez le deuxième itérateur. Cela s'exécute dans time O(n) car chaque itération consomme au moins un élément, et il n'y a que O(n) éléments au total).

41
templatetypedef

Je me demande si personne n'a mentionné la table de hachage.
Quelle que soit l'implémentation de votre ensemble (même si "ensemble" signifie ici un tableau simple), vous pouvez

  1. mettre le contenu du premier ensemble dans une table de hachage et
  2. itérer sur le deuxième ensemble, vérifier si la table de hachage contient l'élément actuel.

O(n)

9
Nikita Rybak
intersection(a, b):
  result = new empty set
  for x in b:
    if a contains x:
      add x to result

  return result

Si le test contains est à temps constant (comme dans un ensemble qui utilise une table de hachage comme implémentation), alors cet algorithme est O(n).

2
sjr

Combinez les deux tableaux et comptez le nombre d'occurrences de chaque élément dans ce tableau combiné et placez-les dans un nouveau tableau. Vérifiez ensuite ce tableau de comptage pour les entrées qui contiennent 2, ces éléments sont en intersection des deux ensembles.

2
user2603796

si l'une des deux listes est ordonnée, nous pouvons commencer par la liste non ordonnée

FUNCTION: INTERSECTION ( LIST A, LIST B )
{
   CREATE C AS EMPTY LIST

   FOR EVERY: NUMBER n IN A
   {
        IF BINARY-SEARCH(n) IN B
        {
            ADD n TO C
        }
   }

   RETURN C
}

Time Complexity = O(n O(BINARY-SEARCH)) = O(n log n)

si la liste B est hashed, alors nous avons BIG-THETA(C n + T(hash))

où BIG-THETA est la moyenne asymptotique et C est un constant et T(hash) est le temps nécessaire à la fonction de hachage

0
Khaled Khunaifer

Pour tous les éléments de l'ensemble 1: vérifiez si cet élément est dans l'ensemble 2. Vous pouvez implémenter un ensemble qui a amorti O(1) temps de recherche).

0
Anon.