* heap binario:
* o (log n) . Questa è l'implementazione più comune ed efficiente. La rimozione della radice (elemento di priorità più alta) prende O (1). Tuttavia, è necessario sostituire la radice con l'ultimo elemento nel heap e "accumulare" per ripristinare la proprietà heap. Questa operazione di heaPify richiede tempo (log n), dove n è il numero di elementi nell'heap.
* Tree di ricerca binaria (BST):
* o (log n) Nel caso medio per un BST equilibrato (come un albero AVL o un albero rosso-nero). Trovare il massimo (o minimo, a seconda della priorità) è O (log n) e la rimozione è anche O (log n).
* o (n) Nel peggiore dei casi per un BST sbilanciato. Se l'albero è distorto (ad esempio, ricorda un elenco collegato), trovare e rimuovere il massimo/minimo può richiedere tempo lineare.
* array o elenco collegato (non ordinato):
* o (n) . È necessario iterare attraverso l'intero elenco per trovare l'elemento con la massima priorità e quindi rimuoverlo.
* array o elenco collegato (ordinato):
* Se ordinato per priorità (ad es. Array ordinato):far scoppiare l'elemento con la massima priorità (probabilmente alla fine o all'inizio, a seconda dell'ordinamento) può essere O (1). Tuttavia, se si utilizza un array ordinato e devi mantenere l'ordine ordinato dopo aver rimosso l'elemento, potrebbe essere necessario spostare gli elementi, risultando in O (N) nel peggiore dei casi. Gli elenchi collegati possono evitare lo spostamento, quindi lo scoppio è O (1) se sai dove si trova l'elemento prioritario più alto, ma trovarlo era ancora O (n) per cominciare.
* Fibonacci heap:
* o (log n) tempo ammortizzato. I cumuli di fibonacci sono più complessi da implementare, ma offrono prestazioni teoricamente migliori per determinate operazioni, in particolare quando si hanno molte operazioni `` zecca ke-key '. "Amorted" significa che mentre le singole operazioni potrebbero richiedere più tempo, la complessità temporale media su una sequenza di operazioni è O (log n).
Riepilogo:
| Implementazione | Complessità del tempo (scoppiettante) |
| ------------------------- | --------------------------- |
| Heap binario | O (log n) |
| BI equilibrato BST | O (log n) |
| BST sbilanciato | O (n) |
| Array/elenco non ordinato | O (n) |
| Array/elenco ordinato | O (1) o O (N) |
| Fibonacci heap | O (log n) (ammortizzato) |
In pratica:
L'implementazione più comune per le code prioritarie è il heap binario , a causa delle sue buone prestazioni (O (log n)) e implementazione relativamente semplice. Pertanto, puoi generalmente supporre che la complessità temporale di scoppietta da una coda prioritaria sia o (log n) A meno che la documentazione o il contesto non specifichi esplicitamente una diversa struttura di dati sottostante.
software © www.354353.com