Qual è la complessità temporale dell'operazione di intersezione impostata in Python?

La complessità temporale dell'operazione di intersezione del set in Python dipende dal metodo utilizzato e dalle dimensioni dei set coinvolti. Ecco una rottura:

1. Utilizzando l'operatore `&` o il metodo `intersection ()`:

* Caso medio: O (min (len (set1), len (set2))

* Caso peggiore: O (n*m) dove n è la lunghezza di un set e m è la lunghezza dell'altro, ma questo è molto improbabile.

Spiegazione:

* Il set` di Python è implementato utilizzando una tabella hash. L'algoritmo ITERANGIAMENTE Itera attraverso il set più piccolo e controlla se ogni elemento è presente nel set più grande. L'operatore `In` su un set (controlla l'adesione) prende in media O (1) a causa della ricerca della tabella hash.

* Pertanto, se `set1` è più piccolo, itera attraverso` set1` ed esegue una ricerca della tabella hash in `set2` per ogni elemento, risultando in complessità O (len (set1)). La stessa logica si applica se `set2` è più piccolo.

* Il caso peggiore di O (n* m) si verificherebbe se le collisioni di hash sono dilaganti, degradando le ricerche impostate da O (1) a O (n). Questo è molto insolito con i buoni algoritmi di hashing di Python.

2. Utilizzando il metodo `intersection_update ()` (intersezione sul posto):

* Caso medio: O (len (set)) dove è il set che verrà aggiornato.

* Caso peggiore: Come `intersection ()` - improbabile O (n*m)

Spiegazione:

`intersection_update ()` Modifica l'insieme su cui viene chiamato, rimuovendo gli elementi che non sono presenti negli altri set. La complessità del tempo è simile a `intersection ()` perché deve ancora controllare l'appartenenza agli altri set.

Esempio:

`` `Python

set1 ={1, 2, 3, 4, 5}

set2 ={3, 5, 6, 7, 8}

intersezione usando e operatore:

intersection_set =set1 e set2

print (intersection_set) # output:{3, 5}

intersezione usando il metodo intersection ():

intersection_set =set1.intersection (set2)

print (intersection_set) # output:{3, 5}

intersezione usando il metodo intersection_update () (modifica set1):

Set1.Intersection_Update (set2)

print (set1) # output:{3, 5}

`` `

Tabella di riepilogo:

| Metodo | Complessità del tempo medio del caso | Complessità del tempo peggiore (improbabile) |

| -------------------------- | ---------------------------------- --------------------------------------------------

| `&` Operatore | O (min (len (set1), len (set2)) | O (n*m) |

| `intersection ()` | O (min (len (set1), len (set2)) | O (n*m) |

| `intersection_update ()` | O (len (set)) | O (n*m) |

takeaway chiave: L'operazione di intersezione set in Python è generalmente molto efficiente, grazie all'uso delle tabelle di hash. Di solito puoi supporre che sia O (min (len (set1), len (set2))) per scopi pratici.

• Qual è la complessità temporale dell'operazione di intersezione nei set di Python? 
• Come moltiplicare le galleggianti in Python?