Panoramica
Altri hanno fornito buoni esempi di diagrammi, come i diagrammi ad albero. Non ho visto alcun semplice esempio di codice. Quindi, oltre alla mia spiegazione, fornirò alcuni algoritmi con semplici istruzioni di stampa per illustrare la complessità delle diverse categorie di algoritmi.
Innanzitutto, vorrai avere un'idea generale del logaritmo, che puoi ottenere da https://en.wikipedia.org/wiki/Logarithm . Uso delle scienze naturali ee registro naturale. I discepoli di ingegneria useranno log_10 (log base 10) e gli informatici useranno molto log_2 (log base 2), poiché i computer sono basati su binari. A volte vedrai abbreviazioni di log naturale come ln(), gli ingegneri normalmente lasciano spento _10 e usano solo log()e log_2 è abbreviato come lg(). Tutti i tipi di logaritmi crescono in modo simile, per questo condividono la stessa categoria di log(n).
Quando guardi gli esempi di codice qui sotto, ti consiglio di guardare O (1), quindi O (n), quindi O (n ^ 2). Dopo che sei bravo con quelli, allora guarda gli altri. Ho incluso esempi chiari e varianti per dimostrare come i cambiamenti sottili possano comunque portare alla stessa categorizzazione.
Puoi pensare a O (1), O (n), O (logn), ecc. Come classi o categorie di crescita. Alcune categorie richiedono più tempo rispetto ad altre. Queste categorie ci aiutano a ordinare le prestazioni dell'algoritmo. Alcuni sono cresciuti più velocemente man mano che l'input n cresce. La tabella seguente mostra numericamente tale crescita. Nella tabella seguente pensa a log (n) come al soffitto di log_2.
Esempi di codice semplice di varie grandi categorie O:
O (1) - Esempi di tempo costante:
L'algoritmo 1 stampa ciao una volta e non dipende da n, quindi verrà sempre eseguito a tempo costante, quindi lo è O(1).
print "hello";
Algorithm 2 stampa ciao 3 volte, tuttavia non dipende da una dimensione di input. Anche se n cresce, questo algoritmo stampa sempre ciao solo 3 volte. Detto questo, è una costante, quindi anche questo algoritmo O(1).
print "hello";
print "hello";
print "hello";
O (log (n)) - Esempi logaritmici:
- Algoritmo 3 - Funziona come "log_2"
L'algoritmo 3 mostra un algoritmo che viene eseguito in log_2 (n). Notare che l'operazione post del ciclo for moltiplica il valore corrente di i per 2, quindi iva da 1 a 2 a 4 a 8 a 16 a 32 ...
for(int i = 1; i <= n; i = i * 2)
print "hello";
- Algoritmo 4 - Funziona come "log_3"
L'algoritmo 4 mostra log_3. L'avviso iva da 1 a 3 a 9 a 27 ...
for(int i = 1; i <= n; i = i * 3)
print "hello";
- Algoritmo 5 - Funziona come "log_1.02"
L'algoritmo 5 è importante, poiché aiuta a dimostrare che fintanto che il numero è maggiore di 1 e il risultato viene ripetutamente moltiplicato contro se stesso, si sta osservando un algoritmo logaritmico.
for(double i = 1; i < n; i = i * 1.02)
print "hello";
O (n) - Esempi di tempo lineare:
Questo algoritmo è semplice, che stampa ciao n volte.
for(int i = 0; i < n; i++)
print "hello";
Questo algoritmo mostra una variazione, dove stampa ciao n / 2 volte. n / 2 = 1/2 * n. Ignoriamo la costante 1/2 e vediamo che questo algoritmo è O (n).
for(int i = 0; i < n; i = i + 2)
print "hello";
O (n * log (n)) - nlog (n) Esempi:
Pensa a questo come una combinazione di O(log(n))e O(n). La nidificazione dei cicli for ci aiuta a ottenere ilO(n*log(n))
for(int i = 0; i < n; i++)
for(int j = 1; j < n; j = j * 2)
print "hello";
L'algoritmo 9 è come l'algoritmo 8, ma ciascuno dei loop ha consentito variazioni, il che risulta comunque nel risultato finale O(n*log(n))
for(int i = 0; i < n; i = i + 2)
for(int j = 1; j < n; j = j * 3)
print "hello";
O (n ^ 2) - n quadrati Esempi:
O(n^2) si ottiene facilmente annidando lo standard per i loop.
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
print "hello";
Come l'algoritmo 10, ma con alcune variazioni.
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j = j + 2)
print "hello";
O (n ^ 3) - n cubi Esempi:
Questo è come l'algoritmo 10, ma con 3 loop anziché 2.
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
for(int k = 0; k < n; k++)
print "hello";
Come l'algoritmo 12, ma con alcune variazioni che ancora producono O(n^3).
for(int i = 0; i < n; i++)
for(int j = 0; j < n + 5; j = j + 2)
for(int k = 0; k < n; k = k + 3)
print "hello";
Sommario
Quanto sopra fornisce diversi esempi diretti e variazioni per aiutare a dimostrare quali sottili cambiamenti possono essere introdotti che non cambiano davvero l'analisi. Spero che ti dia abbastanza informazioni.
