Complessità temporale logaritmica vs doppia logaritmica

Nelle applicazioni del mondo reale c'è un vantaggio concreto quando si usano gli algoritmi $\mathcal{O}(\log(\log(n))$ invece di ?$\mathcal{O}(\log(n))$

Questo è il caso in cui si usano, ad esempio, alberi di Van Emde Boas invece di implementazioni di alberi di ricerca binarie più convenzionali. Ma per esempio, se prendiamo nel migliore dei casi l'algoritmo logaritmico doppio supera quello logaritmico di (approssimativamente) un fattore . E anche in generale l'implementazione è più complicata e complessa.$n < 10^6$$5$

Dato che preferisco personalmente il BST rispetto agli alberi VEB, cosa ne pensi?

Si potrebbe facilmente dimostrare che:

$\qquad \displaystyle \forall n < 10^6.\ \frac{\log n}{\log(\log(n))} < 5.26146$

Non dimenticare che il continua a crescere esponenzialmente (nel registro ( n ) ) più velocemente del registro ( registro n ) !$\log n$$\log(n)$$\log(\log n)$

Infatti, se guardi il quoziente di e log ( log ( n ) ) , non c'è molto da vedere:$\log(n)$$\log(\log(n))$

^{[ fonte ]}

Tuttavia, ottieni un fattore da cinque a sei per dimensioni fino a . Si noti che le taglie più grandi non sono inusuali nella pratica, e uno speedup di quel fattore è fantastico ! Potrebbe fare la differenza tra avere risultati dopo pranzo o solo domani. Essere consapevoli del fatto che parte dell'accelerazione può essere eliminata dalle costanti più alte dell'implementazione dell'albero; dovresti tracciare (o analizzare) c ⋅ log ( n ) e d ⋅ log ( log ( n ) ) con c , d le costanti di runtime effettive per ottenere un'immagine reale.$100000$$c\cdot \log(n)$$d\cdot \log(\log(n))$$c,d$

Inoltre, ciò che Dave menziona è importante: se l'operazione accelerata in questo modo viene eseguita in modo lineare, diciamo, spesso in modo lineare, gli speedup costanti diventano speedups lineari, cioè potresti ridurre la costante principale dell'intero algoritmo! Come ho detto sopra, è fantastico. Guarda cosa succede se esegui l'operazione volte:$n$

^{[ fonte ]}

Ora, se non vale la pena, non so cosa.

Si potrebbe immaginare che la differenza di complessità in realtà non sia così importante e che il tempo di esecuzione effettivo sia più importante. Ma se l'algoritmo è al centro di un altro algoritmo, questa differenza potrebbe essere importante.

Da uno scopo puramente teorico, la differenza ovviamente conta, specialmente se l'algoritmo fa parte di un altro. Potrebbe mettere l'algoritmo più grande in una diversa classe di complessità.

In realtà, ho analizzato personalmente l'albero di Van Emde-Boas una volta. L'ho confrontato con un albero AA, una hashmap e un bit array.

I test eseguono sizeinserimenti con numeri casuali nell'intervallo [0, bound], quindi sizeeffettuano ricerche, quindi sizeeliminano e quindi eseguono nuovamente sizericerche. Le eliminazioni vengono eseguite anche su numeri casuali, quindi devi prima capire se sono nella struttura.

Ecco i risultati ( size= 2000000, bound= 10000000) in secondi:

AATreeLookup - O(n log n)
Inserting... 3.3652452
Searching... 5.2280724
Deleting...  7.3457427
Searching... 9.1462039
HashLookup - O(n) expected
Inserting... 0.3369505
Searching... 0.6223035
Deleting...  0.9062163
Searching... 1.1718223
VanEmdeBoasTree - O(n log log n)
Inserting... 0.7007531
Searching... 1.1775800
Deleting...  1.7257065
Searching... 2.2147703
ArrayLookup - O(n)
Inserting... 0.0681897
Searching... 0.1720300
Deleting...  0.2387776
Searching... 0.3413800

Come puoi vedere, gli alberi di Van Emde-Boas sono circa due volte più lenti delle mappe hash, dieci volte più lenti degli array di bit e 5 volte più veloci degli alberi di ricerca binari.

Naturalmente quanto sopra ha bisogno di una dichiarazione di non responsabilità: i test sono artificiali, puoi eventualmente migliorare il codice o usare una lingua diversa con un compilatore il cui output è più veloce, e così via e così via.

Questa dichiarazione di non responsabilità è al centro del motivo per cui utilizziamo l'analisi asintotica nella progettazione di algoritmi: poiché non hai idea di cosa siano le costanti e poiché le costanti possono cambiare in base a fattori ambientali, il meglio che possiamo fare è un'analisi asintotica.

$\log n$$\log \log n$$2^{32}$$\log 2^{32} = 32$$\log 32 = 5$