Was ist der Unterschied zwischen Θ (n) und O (n)?

Manchmal sehe ich Θ (n) mit dem seltsamen Θ-Symbol mit etwas in der Mitte und manchmal nur O (n). Ist es nur Faulheit beim Tippen, weil niemand weiß, wie man dieses Symbol tippt, oder bedeutet es etwas anderes?

Kurze Erklärung:

Wenn ein Algorithmus Θ (g (n)) ist, bedeutet dies, dass die Laufzeit des Algorithmus, wenn n (Eingabegröße) größer wird, proportional zu g (n) ist.

Wenn ein Algorithmus von O (g (n)) ist, bedeutet dies, dass die Laufzeit des Algorithmus, wenn n größer wird, höchstens proportional zu g (n) ist.

Selbst wenn Leute über O (g (n)) sprechen, meinen sie normalerweise Θ (g (n)), aber technisch gesehen gibt es einen Unterschied.

Technischer:

O (n) repräsentiert die Obergrenze. Θ (n) bedeutet fest gebunden. Ω (n) steht für die Untergrenze.

f (x) = Θ (g (x)) wenn f (x) = O (g (x)) und f (x) = Ω (g (x))

Wenn wir sagen, ein Algorithmus ist von O (n), dann ist es auch O (n ² ), O (n ^1000000 ), O (2 ⁿ ), ... aber ein Θ (n) -Algorithmus ist nicht Θ (n ² ) .

Da f (n) = Θ (g (n)) für ausreichend große Werte von n bedeutet, kann f (n) für einige Werte von c innerhalb von c ₁ g (n) und c ₂ g (n) gebunden werden ₁ und c ₂ , das heißt die Wachstumsrate von f gleich asymptotisch g: g eine untere gebunden werden kann und und gebunden an F eine obere. Dies impliziert direkt, dass f auch eine Untergrenze und eine Obergrenze von g sein kann. Folglich,

f (x) = Θ (g (x)) wenn f g (x) = Θ (f (x))

In ähnlicher Weise reicht es aus, um zu zeigen, dass f eine Obergrenze von f ist (dh f (n) = O (g (n))) und f eine Untergrenze von f ist, um f (n) = Θ (g (n)) zu zeigen g (dh f (n) = Ω (g (n)), was genau dasselbe ist wie g (n) = O (f (n))). Kurz gesagt,

f (x) = Θ (g (x)) wenn f (x) = O (g (x)) und g (x) = O (f (x))

Es gibt auch Little-Oh- und Little-Omega ( ω) -Notationen, die lose obere und lose untere Grenzen einer Funktion darstellen.

Zusammenfassen:

f(x) = O(g(x))(big-oh) bedeutet, dass die Wachstumsrate von f(x)asymptotisch kleiner oder gleich der Wachstumsrate von ist g(x).

f(x) = Ω(g(x))(Big-Omega) bedeutet, dass die Wachstumsrate von f(x)asymptotisch größer oder gleich der Wachstumsrate von istg(x)

f(x) = o(g(x))(little-oh) bedeutet, dass die Wachstumsrate von f(x)asymptotisch geringer ist als die Wachstumsrate von g(x).

f(x) = ω(g(x))(wenig Omega) bedeutet, dass die Wachstumsrate von f(x)asymptotisch größer ist als die Wachstumsrate vong(x)

f(x) = Θ(g(x))(Theta) bedeutet, dass die Wachstumsrate von f(x)asymptotisch gleich der Wachstumsrate von istg(x)

Für eine detailliertere Diskussion können Sie die Definition auf Wikipedia lesen oder ein klassisches Lehrbuch wie Introduction to Algorithms von Cormen et al.

Es gibt eine einfache Möglichkeit (ein Trick, denke ich), sich daran zu erinnern, welche Notation was bedeutet.

Alle Big-O-Notationen haben einen Balken.

Bei einem Ω befindet sich der Balken unten, sodass es sich um eine (asymptotische) Untergrenze handelt.

Beim Betrachten eines Θ befindet sich der Balken offensichtlich in der Mitte. Es ist also eine (asymptotische) enge Bindung.

Wenn Sie O schreiben, beenden Sie normalerweise oben und zeichnen einen Kringel. Daher ist O (n) die Obergrenze der Funktion. Um fair zu sein, funktioniert dies nicht mit den meisten Schriftarten, aber es ist die ursprüngliche Rechtfertigung der Namen.

einer ist Big "O"

einer ist Big Theta

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

Big O bedeutet, dass Ihr Algorithmus in nicht mehr Schritten als im angegebenen Ausdruck ausgeführt wird (n ^ 2).

Big Omega bedeutet, dass Ihr Algorithmus in nicht weniger Schritten als im angegebenen Ausdruck ausgeführt wird (n ^ 2).

Wenn beide Bedingungen für denselben Ausdruck zutreffen, können Sie die große Theta-Notation verwenden.

Anstatt eine theoretische Definition zu liefern, die hier bereits schön zusammengefasst ist, gebe ich ein einfaches Beispiel:

Angenommen, die Laufzeit von f(i)ist O(1). Unten ist ein Codefragment, dessen asymptotische Laufzeit ist Θ(n). Es ruft immer die Funktionszeiten f(...) nauf. Sowohl die untere als auch die obere Grenze ist n.

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

Das zweite Codefragment unten hat die asymptotische Laufzeit von O(n). Es ruft die Funktion f(...) meistens n auf. Die Obergrenze ist n, aber die Untergrenze könnte Ω(1)oder sein Ω(log(n)), je nachdem, was im Inneren passiert f2(i).

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

Theta ist eine Abkürzung für eine spezielle Situation, in der das große O und Omega gleich sind.

Wenn man also behauptet The Theta is expression q, dann behaupten sie auch notwendigerweise, dass Big O is expression qund Omega is expression q.

Grobe Analogie:

Wenn: Theta behauptet: "Dieses Tier hat 5 Beine." dann folgt: Big O ist wahr ("Dieses Tier hat weniger als oder gleich 5 Beine.") und Omega ist wahr ("Dieses Tier hat mehr als oder gleich 5 Beine.")

Dies ist nur eine grobe Analogie, da die Ausdrücke nicht unbedingt bestimmte Zahlen sind, sondern Funktionen unterschiedlicher Größenordnungen wie log (n), n, n ^ 2 (usw.).

Ein Diagramm könnte das Verständnis der vorherigen Antworten erleichtern:

Θ-Notation - Gleiche Reihenfolge | O-Notation - Obergrenze

Auf Englisch,

Beachten Sie links, dass es eine Obergrenze und eine Untergrenze gibt, die beide in der gleichen Größenordnung liegen (dh g (n) ). Ignorieren Sie die Konstanten, und wenn die Obergrenze und die Untergrenze dieselbe Größenordnung haben, kann man gültig sagen, dass f (n) = Θ (g (n)) oder f (n) in großem Theta von g (n) ist .

Beginnend mit dem einfacheren Beispiel rechts heißt es, dass die Obergrenze g (n) einfach die Größenordnung ist und die Konstante c ignoriert (genau wie alle großen O- Notationen).

f(n)gehört zu O(n)wenn existiert positiv kalsf(n)<=k*n

f(n)gehört zu Θ(n)wenn existiert positiv k1, k2alsk1*n<=f(n)<=k2*n

Wikipedia-Artikel zur Big O-Notation

Grenzen verwenden

Betrachten wir f(n) > 0und g(n) > 0für alle n. Es ist in Ordnung, dies zu berücksichtigen, da der schnellste reale Algorithmus mindestens eine Operation hat und seine Ausführung nach dem Start abschließt. Dies vereinfacht die Berechnung, da wir den Wert ( f(n)) anstelle des Absolutwerts ( |f(n)|) verwenden können.

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

   Allgemeines:

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

   Für g(n) = n:

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

   Beispiele:

       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
   

   Gegenbeispiele:

       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))

   Allgemeines:

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

   Für g(n) = n:

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

   Beispiele:

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

   Gegenbeispiele:

       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
   

Schlussfolgerung: Wir betrachten großes O, großes θ und großes Ω als dasselbe.

Warum? Ich werde den Grund unten sagen:

Erstens werde ich eine falsche Aussage klarstellen. Einige Leute denken, dass uns nur die schlechteste Zeitkomplexität wichtig ist, also verwenden wir immer großes O anstelle von großem θ. Ich werde sagen, dieser Mann ist Bullshitting. Ober- und Untergrenze werden verwendet, um eine Funktion zu beschreiben, nicht, um die zeitliche Komplexität zu beschreiben. Die schlechteste Zeitfunktion hat ihre Ober- und Untergrenze; Die beste Zeitfunktion hat auch ihre Ober- und Untergrenze.

Um die Beziehung zwischen großem O und großem θ klar zu erklären, werde ich zuerst die Beziehung zwischen großem O und kleinem O erklären. Aus der Definition können wir leicht erkennen, dass kleines o eine Teilmenge von großem O ist. Zum Beispiel:

T (n) = n ^ 2 + n, wir können sagen, T (n) = O (n ^ 2), T (n) = O (n ^ 3), T (n) = O (n ^ 4). Für kleines o entspricht T (n) = o (n ^ 2) jedoch nicht der Definition von kleinem o. Also sind nur T (n) = o (n ^ 3), T (n) = o (n ^ 4) für kleines o korrekt. Das redundante T (n) = O (n ^ 2) ist was? Es ist groß θ!

Im Allgemeinen sagen wir, dass großes O O (n ^ 2) ist, kaum zu sagen, dass T (n) = O (n ^ 3), T (n) = O (n ^ 4). Warum? Weil wir großes O unbewusst als großes θ betrachten.

In ähnlicher Weise betrachten wir auch großes Ω unbewusst als großes θ.

Mit einem Wort, großes O, großes θ und großes Ω sind nicht dasselbe aus den Definitionen, aber sie sind dasselbe in unserem Mund und Gehirn.