Qual è la differenza tra Θ (n) e O (n)?

A volte vedo Θ (n) con lo strano simbolo Θ con qualcosa nel mezzo, e talvolta solo O (n). È solo pigrizia di battitura perché nessuno sa come digitare questo simbolo o significa qualcosa di diverso?

Breve spiegazione:

Se un algoritmo è di Θ (g (n)), significa che il tempo di esecuzione dell'algoritmo man mano che n (dimensione dell'input) diventa più grande è proporzionale a g (n).

Se un algoritmo è di O (g (n)), significa che il tempo di esecuzione dell'algoritmo man mano che n diventa più grande è al massimo proporzionale a g (n).

Normalmente, anche quando le persone parlano di O (g (n)) in realtà significano Θ (g (n)) ma tecnicamente, c'è una differenza.

Più tecnicamente:

O (n) rappresenta il limite superiore. Θ (n) significa limite stretto. Ω (n) rappresenta il limite inferiore.

f (x) = Θ (g (x)) iff f (x) = O (g (x)) e f (x) = Ω (g (x))

Fondamentalmente quando diciamo che un algoritmo è di O (n), è anche O (n ² ), O (n ^1000000 ), O (2 ⁿ ), ... ma un algoritmo Θ (n) non è Θ (n ² ) .

Infatti, poiché f (n) = Θ (g (n)) significa che valori sufficientemente grandi di n, f (n) possono essere associati tra c ₁ g (n) e c ₂ g (n) per alcuni valori di c ₁ e C ₂ , cioè il tasso di crescita di f è uguale a asintoticamente g: g può essere un limite inferiore ed e un limite superiore di f. Ciò implica che f può essere anche un limite inferiore e un limite superiore di g. Di conseguenza,

f (x) = Θ (g (x)) iff g (x) = Θ (f (x))

Allo stesso modo, per mostrare f (n) = Θ (g (n)), è sufficiente mostrare g è un limite superiore di f (cioè f (n) = O (g (n))) e f è un limite inferiore di g (cioè f (n) = Ω (g (n)) che è esattamente la stessa cosa di g (n) = O (f (n))). In modo conciso,

f (x) = Θ (g (x)) iff f (x) = O (g (x)) eg (x) = O (f (x))

Esistono anche ωnotazioni little-oh e little-omega ( ) che rappresentano i limiti inferiori superiori e inferiori di una funzione.

Riassumere:

f(x) = O(g(x))(big-oh) significa che il tasso di crescita di f(x)è asintoticamente inferiore o uguale al tasso di crescita di g(x).

f(x) = Ω(g(x))(big-omega) significa che il tasso di crescita di f(x)è asintoticamente maggiore o uguale al tasso di crescita dig(x)

f(x) = o(g(x))(little-oh) significa che il tasso di crescita di f(x)è asintoticamente inferiore al tasso di crescita di g(x).

f(x) = ω(g(x))(omega) significa che il tasso di crescita di f(x)è asintoticamente maggiore del tasso di crescita dig(x)

f(x) = Θ(g(x))(theta) significa che il tasso di crescita di f(x)è asintoticamente uguale al tasso di crescita dig(x)

Per una discussione più dettagliata, puoi leggere la definizione su Wikipedia o consultare un classico libro di testo come Introduzione agli algoritmi di Cormen et al.

C'è un modo semplice (un trucco, immagino) per ricordare quale notazione significhi cosa.

Tutte le notazioni Big-O possono essere considerate con una barra.

Quando si osserva un Ω, la barra è in basso, quindi è un limite inferiore (asintotico).

Quando si guarda un Θ, il bar è ovviamente nel mezzo. Quindi è un limite (asintotico) stretto.

Quando scrivi a mano O, di solito finisci in alto e disegni uno scricchiolio. Pertanto O (n) è il limite superiore della funzione. Ad essere sinceri, questo non funziona con la maggior parte dei caratteri, ma è la giustificazione originale dei nomi.

uno è grande "O"

uno è Big Theta

http://en.wikipedia.org/wiki/Big_O_notation

Grande O significa che il tuo algoritmo verrà eseguito in non più passaggi rispetto all'espressione data (n ^ 2)

Big Omega significa che il tuo algoritmo verrà eseguito in non meno passaggi rispetto all'espressione data (n ^ 2)

Quando entrambe le condizioni sono vere per la stessa espressione, puoi usare la grande notazione theta ....

Piuttosto che fornire una definizione teorica, che sono già meravigliosamente riassunti qui, farò un semplice esempio:

Supponiamo che il tempo di esecuzione f(i)sia O(1). Di seguito è riportato un frammento di codice il cui runtime asintotico è Θ(n). E ' sempre chiama la funzione f(...) nvolte. Sia il limite inferiore che quello superiore sono n.

for(int i=0; i<n; i++){
    f(i);
}

Il secondo frammento di codice in basso ha il runtime asintotico di O(n). Chiama la funzione il f(...) più delle n volte. Il limite superiore è n, ma il limite inferiore potrebbe essere Ω(1)o Ω(log(n)), a seconda di ciò che accade all'interno f2(i).

for(int i=0; i<n; i++){
    if( f2(i) ) break;
    f(i);
}

Theta è un modo abbreviato di riferirsi a una situtazione speciale in cui la grande O e Omega sono uguali.

Pertanto, se uno afferma The Theta is expression q, anche loro lo stanno necessariamente sostenendo Big O is expression qe Omega is expression q.

Analogia approssimativa:

Se: Theta afferma: "Quell'animale ha 5 zampe". allora segue che: Big O è vero ("Quell'animale ha meno o uguale a 5 zampe.") e Omega è vero ("Quell'animale ha più o uguale a 5 zampe.")

È solo un'analogia approssimativa perché le espressioni non sono necessariamente numeri specifici, ma invece funzioni di diversi ordini di grandezza come log (n), n, n ^ 2, (ecc.).

Un grafico potrebbe facilitare la comprensione delle risposte precedenti:

Θ-Notazione - Stesso ordine | Notazione O - Limite superiore

In inglese,

A sinistra, notare che c'è un limite superiore e un limite inferiore che sono entrambi dello stesso ordine di grandezza (cioè g (n) ). Ignora le costanti e se il limite superiore e il limite inferiore hanno lo stesso ordine di grandezza, si può validamente dire f (n) = Θ (g (n)) o f (n) è in grande theta di g (n) .

A partire da destra, l'esempio più semplice, sta dicendo che il limite superiore g (n) è semplicemente l'ordine di grandezza e ignora la costante c (proprio come fa tutta la notazione O grande ).

f(n)appartiene a O(n)se esiste positivo kcomef(n)<=k*n

f(n)appartiene a Θ(n)se esiste positivo k1, k2comek1*n<=f(n)<=k2*n

Articolo di Wikipedia su Big O Notation

Usando i limiti

Consideriamo f(n) > 0e g(n) > 0per tutti n. Va bene considerare questo, perché l'algoritmo reale più veloce ha almeno un'operazione e ne completa l'esecuzione dopo l'avvio. Questo semplificherà il calcolo, perché possiamo usare il valore ( f(n)) invece del valore assoluto ( |f(n)|).

1. f(n) = O(g(n))

   Generale:

             f(n)     
   0 ≤ lim ──────── < ∞
       n➜∞   g(n)
   

   Per g(n) = n:

             f(n)     
   0 ≤ lim ──────── < ∞
       n➜∞    n
   

   Esempi:

       Expression               Value of the limit
   ------------------------------------------------
   n        = O(n)                      1
   1/2*n    = O(n)                     1/2
   2*n      = O(n)                      2
   n+log(n) = O(n)                      1
   n        = O(n*log(n))               0
   n        = O(n²)                     0
   n        = O(nⁿ)                     0
   

   controesempi:

       Expression                Value of the limit
   -------------------------------------------------
   n        ≠ O(log(n))                 ∞
   1/2*n    ≠ O(sqrt(n))                ∞
   2*n      ≠ O(1)                      ∞
   n+log(n) ≠ O(log(n))                 ∞
   

2. f(n) = Θ(g(n))

   Generale:

             f(n)     
   0 < lim ──────── < ∞
       n➜∞   g(n)
   

   Per g(n) = n:

             f(n)     
   0 < lim ──────── < ∞
       n➜∞    n
   

   Esempi:

       Expression               Value of the limit
   ------------------------------------------------
   n        = Θ(n)                      1
   1/2*n    = Θ(n)                     1/2
   2*n      = Θ(n)                      2
   n+log(n) = Θ(n)                      1
   

   controesempi:

       Expression                Value of the limit
   -------------------------------------------------
   n        ≠ Θ(log(n))                 ∞
   1/2*n    ≠ Θ(sqrt(n))                ∞
   2*n      ≠ Θ(1)                      ∞
   n+log(n) ≠ Θ(log(n))                 ∞
   n        ≠ Θ(n*log(n))               0
   n        ≠ Θ(n²)                     0
   n        ≠ Θ(nⁿ)                     0
   

Conclusione: consideriamo big O, big θ e big Ω come la stessa cosa.

Perché? Dirò il motivo di seguito:

In primo luogo, chiarirò un'affermazione sbagliata, alcune persone pensano che ci preoccupiamo solo della peggior complessità temporale, quindi usiamo sempre la grande O invece della grande θ. Dirò che quest'uomo è una cazzata. Il limite superiore e inferiore sono usati per descrivere una funzione, non per descrivere la complessità temporale. La funzione del tempo peggiore ha il limite superiore e inferiore; anche la funzione miglior tempo ha il suo limite superiore e inferiore.

Per spiegare chiaramente la relazione tra grande O e grande θ, spiegherò prima la relazione tra grande O e piccola o. Dalla definizione, possiamo facilmente sapere che piccola o è un sottoinsieme di grande O. Ad esempio ：

T (n) = n ^ 2 + n, possiamo dire T (n) = O (n ^ 2), T (n) = O (n ^ 3), T (n) = O (n ^ 4). Ma per la piccola o, T (n) = o (n ^ 2) non soddisfa la definizione di piccola o. Quindi solo T (n) = o (n ^ 3), T (n) = o (n ^ 4) sono corretti per la piccola o. Il ridondante T (n) = O (n ^ 2) è cosa? È grande θ!

Generalmente, diciamo che O grande è O (n ^ 2), a malapena a dire T (n) = O (n ^ 3), T (n) = O (n ^ 4). Perché? Perché consideriamo la grande O come grande θ inconsciamente.

Allo stesso modo, consideriamo anche il grande Ω come grande θ inconsciamente.

In una parola, grande O, grande θ e grande Ω non sono la stessa cosa dalle definizioni, ma sono la stessa cosa nella nostra bocca e nel nostro cervello.