Quali sono alcuni algoritmi che utilizziamo quotidianamente che hanno complessità O (1), O (n log n) e O (log n)?

Se desideri esempi di algoritmi / gruppi di dichiarazioni con complessità temporale come indicato nella domanda, ecco un piccolo elenco:

O(1) tempo

• Accesso all'indice di array (int a = ARR [5];)
• Inserimento di un nodo in un elenco collegato
• Spingendo e facendo scoppiare sullo stack
• Inserimento e rimozione dalla coda
• Individuazione del genitore o del figlio sinistro / destro di un nodo in un albero archiviato in Array
• Passaggio all'elemento successivo / precedente nell'elenco a doppio collegamento

O(n) tempo

In poche parole, tutti gli algoritmi di forza bruta, o noob che richiedono linearità, sono basati sulla complessità temporale O (n)

• Attraversare un array
• Attraversare un elenco collegato
• Ricerca lineare
• Eliminazione di un elemento specifico in un elenco collegato (non ordinato)
• Confronto di due stringhe
• Controllo per palindromo
• Counting / Bucket Sort e anche qui puoi trovare un milione di altri esempi simili ...

O(log n) tempo

• Ricerca binaria
• Trovare il numero più grande / più piccolo in un albero di ricerca binario
• Alcuni algoritmi di divisione e conquista basati sulla funzionalità lineare
• Calcolo dei numeri di Fibonacci - Metodo migliore La premessa di base qui NON è usare i dati completi e ridurre la dimensione del problema ad ogni iterazione

O(n log n) tempo

Il fattore "log n" viene introdotto prendendo in considerazione Divide and Conquer. Alcuni di questi algoritmi sono i migliori ottimizzati e utilizzati frequentemente.

• Unisci ordinamento
• Ordinamento mucchio
• Ordinamento rapido
• Alcuni algoritmi Divide and Conquer basati sull'ottimizzazione degli algoritmi O (n ^ 2)

O(n^2) tempo

Questi dovrebbero essere gli algoritmi meno efficienti se sono presenti le loro controparti O (nlogn). L'applicazione generale potrebbe essere Brute Force qui.

• Bubble Sort
• Ordinamento di inserzione
• Ordina selezione
• Attraversando un semplice array 2D

Un semplice esempio di O(1)potrebbe essere return 23;: qualunque sia l'input, questo tornerà in un tempo fisso e finito.

Un tipico esempio O(N log N)potrebbe essere l'ordinamento di un array di input con un buon algoritmo (ad es. Mergesort).

Un tipico esempio se O(log N)sarebbe cercare un valore in un array di input ordinato per bisezione.

O (1) - la maggior parte delle procedure di cottura sono O (1), ovvero ci vuole una quantità di tempo costante anche se ci sono più persone per cui cucinare (in una certa misura, perché potresti esaurire lo spazio nelle tue pentole / padelle e bisogno di dividere la cottura)

O (logn) - trovare qualcosa nella tua rubrica telefonica. Pensa alla ricerca binaria.

O (n) - leggere un libro, dove n è il numero di pagine. È il tempo minimo necessario per leggere un libro.

O (nlogn) - non riesco a pensare immediatamente a qualcosa che si potrebbe fare ogni giorno che è nlogn ... a meno che non si ordinino le carte eseguendo l'unione o l'ordinamento rapido!

Posso offrirti alcuni algoritmi generali ...

• O (1): Accesso a un elemento in un array (es. Int i = a [9])
• O (n log n): veloce o mergesort (in media)
• O (log n): ricerca binaria

Queste sarebbero le risposte istintive in quanto suona come un tipo di domanda per i compiti a casa / intervista. Se stai cercando qualcosa di più concreto è un po 'più difficile in quanto il pubblico in generale non avrebbe idea dell'implementazione sottostante (ovviamente con risparmio di open source) di un'applicazione popolare, né il concetto in generale si applica a una "applicazione"

O (1): trovare la migliore mossa successiva negli scacchi (o Go se è per questo). Poiché il numero di stati del gioco è finito, è solo O (1) :-)

La complessità dell'applicazione software non viene misurata e non è scritta in notazione O grande. È utile solo per misurare la complessità degli algoritmi e per confrontare gli algoritmi nello stesso dominio. Molto probabilmente, quando diciamo O (n), intendiamo che si tratta di "O (n) confronti " o "O (n) operazioni aritmetiche". Ciò significa che non puoi confrontare nessuna coppia di algoritmi o applicazioni.

O (1) - Eliminazione di un elemento da una lista doppiamente collegata. per esempio

typedef struct _node {
    struct _node *next;
    struct _node *prev;
    int data;
} node;


void delete(node **head, node *to_delete)
{
    .
    .
    .
}

Puoi aggiungere i seguenti algoritmi al tuo elenco:

O(1)- Determinare se un numero è pari o dispari; Lavorare con HashMap

O(logN) - calcolare x ^ N,

O(N Log N) - Sottosequenza crescente più lunga

O (n log n) è notoriamente il limite superiore della velocità con cui è possibile ordinare un insieme arbitrario (assumendo un modello di calcolo standard e non altamente parallelo).

0 (logn) -Ricerca binaria, elemento di picco in un array (può esserci più di un picco) 0 (1) -in Python che calcola la lunghezza di una lista o di una stringa. La funzione len () richiede 0 (1) tempo. L'accesso a un elemento in un array richiede 0 (1) tempo. L'operazione push in uno stack richiede 0 (1) tempo. 0 (nlogn) -Unisci ordinamento. l'ordinamento in python richiede tempo nlogn. quindi quando usi listname.sort () ci vuole tempo nlogn.

La ricerca di note in una tabella hash a volte richiede tempo più che costante a causa delle collisioni.

O (2 ^N )

O (2 ^N ) denota un algoritmo la cui crescita raddoppia con ogni aggiunta al set di dati di input. La curva di crescita di una funzione O (2 ^N ) è esponenziale: inizia molto superficiale, quindi aumenta in modo meteorico. Un esempio di una funzione O (2 ^N ) è il calcolo ricorsivo dei numeri di Fibonacci:

int Fibonacci (int number)
{
if (number <= 1) return number;
return Fibonacci(number - 2) + Fibonacci(number - 1);
}