1. Usando el operador `&` o el método `intersection ()`:
* Caso promedio: O (min (len (set1), len (set2)))
* peor de los casos: O (n*m) donde n es la longitud de un conjunto y M es la longitud del otro, pero esto es muy poco probable.
Explicación:
* El `set` de Python se implementa utilizando una tabla hash. El algoritmo esencialmente itera a través del conjunto y verifica si cada elemento está presente en el conjunto más grande. El operador `in` en un conjunto (verificación de membresía) toma O (1) en promedio debido a la búsqueda de tabla hash.
* Por lo tanto, si `set1` es más pequeño, se itera a través de` set1` y realiza una búsqueda de tabla hash en `set2` para cada elemento, lo que resulta en la complejidad O (len (set1)). La misma lógica se aplica si `set2` es más pequeña.
* El peor caso de O (n* m) ocurriría si las colisiones hash son rampantes, degradando las búsquedas establecidas de o (1) a o (n). Esto es muy inusual con los buenos algoritmos de hash de Python.
2. Usando el método `intersection_update ()` (intersección en el lugar):
* Caso promedio: O (len (set)) donde el conjunto está el conjunto que se actualizará.
* peor de los casos: Igual que `intersección ()` - improbable o (n*m)
Explicación:
`intersection_update ()` modifica el conjunto en el que se llama, eliminando elementos que no están presentes en el otro conjunto (s). La complejidad del tiempo es similar a `intersección ()` porque aún necesita verificar la membresía en el otro (s) conjunto (s).
Ejemplo:
`` `Python
set1 ={1, 2, 3, 4, 5}
set2 ={3, 5, 6, 7, 8}
Intersección usando y operador:
intersection_set =set1 y set2
print (intersection_set) # output:{3, 5}
intersección usando el método intersection ():
intersection_set =set1.intersection (set2)
print (intersection_set) # output:{3, 5}
intersección usando el método intersection_update () (modifica set1):
set1.intersection_update (set2)
print (set1) # salida:{3, 5}
`` `` ``
Tabla de resumen:
| Método | Complejidad promedio de tiempo de caso | La peor complejidad del tiempo (poco probable) |
| -------------------------- | ------------------------------ | ------------------------------------- |
| `&` Operador | O (min (len (set1), len (set2))) | O (n*m) |
| `intersección ()` | O (min (len (set1), len (set2))) | O (n*m) |
| `intersection_update ()` | O (len (set)) | O (n*m) |
Key Takeaway: La operación de intersección establecida en Python es generalmente muy eficiente, gracias al uso de tablas hash. Por lo general, puede asumir que es O (min (len (SET1), len (set2))) para fines prácticos.