Θ (n) ve O (n) arasındaki fark nedir?

Bazen garip Θ sembolü ile ortasında bir şey olan st (n) ve bazen sadece O (n) görürüm. Yazmak sadece tembellik mi, çünkü kimse bu sembolü nasıl yazacağını bilmiyor mu, yoksa farklı bir şey mi ifade ediyor?

Kısa açıklama:

Bir algoritma Θ (g (n)) ise, n (giriş boyutu) büyüdükçe algoritmanın çalışma süresinin g (n) ile orantılı olduğu anlamına gelir.

Bir algoritma O (g (n)) ise, n'nin büyüdükçe algoritmanın çalışma süresinin en fazla g (n) ile orantılı olduğu anlamına gelir .

Normalde, insanlar O (g (n)) hakkında konuştuğunda bile, aslında Θ (g (n)) anlamına gelirler, ancak teknik olarak, bir fark vardır.

Daha teknik olarak:

O (n) üst sınırı temsil eder. Θ (n) sıkı bağ anlamına gelir. Ω (n) alt sınırı temsil eder.

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

Biz bir algoritma O (n) ait olduğunu söylemek Temelde, bunun da var O (n ² ), O (n ^1000000 ), O (2 ⁿ ), ... ama bir Θ (n) algoritmasıdır değil Θ (n ² ) .

Aslında, f (n) = Θ (g (n)) yeterince büyük n değerleri anlamına geldiğinden, bazı c değerleri için c ₁ g (n) ve c ₂ g (n) içinde bağlanabilir ₁ c ₂ , f, yani büyüme hızı asimptotik g eşit: g bir alt bağlanmış olabilir ve ve bir üst f bağlandı. Bu doğrudan f'nin alt sınır ve g üst sınırı olabileceğini ima eder. Sonuç olarak,

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

Benzer şekilde, f (n) = Θ (g (n)) 'yi göstermek için, g'nin f'nin bir üst sınırı (yani f (n) = O (g (n))) ve f'nin bir alt sınırı olduğunu göstermek yeterlidir. g (yani f (n) = Ω (g (n)), g (n) = O (f (n)) ile aynı şeydir). Kısaca,

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

ωBir işlevin gevşek üst ve gevşek alt sınırlarını temsil eden küçük-oh ve küçük-omega ( ) gösterimleri de vardır.

Özetlemek:

f(x) = O(g(x))(büyük-ah) büyüme hızı bu araçlar f(x)asimptotik olan daha az veya eşit bir büyüme hızına g(x).

f(x) = Ω(g(x))(big-omega), büyüme hızının f(x)asemptotik olarak büyüme hızından büyük veya ona eşit olduğu anlamına gelir .g(x)

f(x) = o(g(x))(az-oh), büyüme hızının f(x)asemptotik olarak büyüme hızından düşük olduğu anlamına gelir g(x).

f(x) = ω(g(x))(küçük-omega), büyüme hızının f(x)asemptotik olarak büyüme hızından daha büyük olduğu anlamına gelir .g(x)

f(x) = Θ(g(x))(teta), büyüme hızının f(x)asemptotik olarak büyüme hızına eşit olduğu anlamına gelir .g(x)

Daha ayrıntılı bir tartışma için Wikipedia'daki tanımı okuyabilir veya Cormen ve ark. Tarafından Algoritmalara Giriş gibi klasik bir ders kitabına başvurabilirsiniz.

Hangi gösterimin ne anlama geldiğini hatırlamanın basit bir yolu (bir hile, sanırım) var.

Tüm Big-O gösterimlerinin bir çubuğu olduğu düşünülebilir.

Bir looking'ye bakarken, çubuk alttadır, bu nedenle (asimtotik) bir alt sınırdır.

Bir Θ bakıldığında, bar açıkça ortada. Yani (asimtotik) sıkı bir bağdır.

El yazısı O yazarken, genellikle en üstte bitirir ve bir dalgacık çizersiniz. Bu nedenle O (n), fonksiyonun üst sınırıdır. Adil olmak gerekirse, bu çoğu yazı tipiyle çalışmaz, ancak isimlerin orijinal gerekçesidir.

biri Büyük "O"

biri Big Theta

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

Büyük O, algoritmanızın belirtilen ifadeden daha fazla adımda yürütülmeyeceği anlamına gelir (n ^ 2)

Büyük Omega, algoritmanızın verilen ifadeden daha az adımda yürütüleceği anlamına gelir (n ^ 2)

Her iki koşul da aynı ifade için geçerli olduğunda, büyük teta gösterimini kullanabilirsiniz ....

Burada zaten güzel bir şekilde özetlenen teorik bir tanım sunmak yerine, basit bir örnek vereceğim:

Çalışma süresini varsayalım f(i)DİR O(1). Aşağıda asimptotik çalışma zamanı olan bir kod parçası bulunmaktadır Θ(n). Her zaman fonksiyon f(...) nsürelerini çağırır . Hem alt hem de üst sınır n'dir.

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

Aşağıdaki ikinci kod parçası asimptotik çalışma süresine sahiptir O(n). Fonksiyonu f(...) çoğu n zaman çağırır . Üst sınır n'dir, ancak alt sınır içeride ne olduğuna bağlı olarak Ω(1)veya olabilir .Ω(log(n))f2(i)

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

Teta, büyük O ve Omega'nın aynı olduğu özel bir duruma atıfta bulunmanın kısa bir yoludur.

Bu nedenle, eğer bir kişi iddia ederse The Theta is expression q, o zaman mutlaka bunu talep ederler Big O is expression qve Omega is expression q.

Kaba benzetme:

Eğer: Teta, "O hayvanın 5 bacağı var" diyor. o zaman şöyle olur: Big O doğrudur ("Bu hayvanın 5 bacağından daha az veya ona eşittir.") ve Omega doğrudur ("Bu hayvanın 5 bacağından daha fazla veya ona eşittir").

Bu sadece kaba bir benzetmedir, çünkü ifadeler mutlaka belirli sayılar değildir, bunun yerine log (n), n, n ^ 2, (vb.) Gibi değişen büyüklük derecelerindeki işlevler.

Bir grafik önceki cevapların anlaşılmasını kolaylaştırabilir:

Θ-Notasyonu - Aynı sipariş | O-Notasyonu - Üst sınır

İngilizcede,

Solda, aynı büyüklük sırasına (yani g (n) ) sahip bir üst sınır ve bir alt sınır olduğunu unutmayın . Sabitleri dikkate almayın ve eğer üst sınır ve alt sınır aynı büyüklük sırasına sahipse, geçerli olarak f (n) = Θ (g (n)) veya f (n) g (n) 'nin büyük tetasında olduğu söylenebilir .

Sağdan başlayarak, daha basit örnek, üst sınır g (n) ' nin sadece büyüklük sırası olduğunu ve c sabitini göz ardı ettiğini söyler (tıpkı tüm büyük O gösterimlerinin yaptığı gibi).

f(n)O(n)eğer varsa pozitif kolarak aittirf(n)<=k*n

f(n)ait Θ(n)pozitif varsa k1, k2olarakk1*n<=f(n)<=k2*n

Big O Notasyonu hakkındaki Wikipedia makalesi

Kullanım sınırları

Düşünelim f(n) > 0ve g(n) > 0herkes için n. Bunu göz önünde bulundurmak iyidir, çünkü en hızlı gerçek algoritmanın en az bir işlemi vardır ve başlatmadan sonra yürütülmesini tamamlar. Bu, hesaplamayı basitleştirecektir, çünkü f(n)mutlak değer ( |f(n)|) yerine value ( ) öğesini kullanabiliriz.

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

   Genel:

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

   Şunun için g(n) = n:

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

   Örnekler:

       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
   

   Karşı örnekler:

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

   Genel:

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

   Şunun için g(n) = n:

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

   Örnekler:

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

   Karşı örnekler:

       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
   

Sonuç: Büyük O, büyük big ve büyük Ω'yi aynı şey olarak görüyoruz.

Neden? Aşağıdaki nedeni anlatacağım:

İlk olarak, yanlış bir ifadeyi açıklığa kavuşturacağım, bazı insanlar sadece en kötü zaman karmaşıklığını önemsediğimizi düşünüyor, bu yüzden her zaman büyük instead yerine büyük O kullanıyoruz. Bu adamın saçma olduğunu söyleyeceğim. Üst ve alt sınır, zaman karmaşıklığını tanımlamak için kullanılmayan bir işlevi tanımlamak için kullanılır. En kötü zaman fonksiyonunun üst ve alt sınırı vardır; en iyi zaman fonksiyonunun da üst ve alt sınırı vardır.

Büyük O ve büyük θ arasındaki ilişkiyi net bir şekilde açıklamak için, önce büyük O ve küçük o arasındaki ilişkiyi açıklayacağım. Tanımdan, küçük o'nun büyük O'nun bir alt kümesi olduğunu kolayca bilebiliriz. Örneğin ：

T (n) = n ^ 2 + n, T (n) = O (n ^ 2), T (n) = O (n ^ 3), T (n) = O (n ^ 4) diyebiliriz. Ancak küçük o için T (n) = o (n ^ 2) küçük o tanımını karşılamıyor. Yani sadece T (n) = o (n ^ 3), T (n) = o (n ^ 4) küçük o için doğrudur. Gereksiz T (n) = O (n ^ 2) nedir? Büyük θ!

Genellikle, büyük O'nun O (n ^ 2) olduğunu söyleriz, T (n) = O (n ^ 3), T (n) = O (n ^ 4) demek zor. Neden? Çünkü biz büyük O'yu bilinçaltında büyük olarak görüyoruz.

Benzer şekilde, büyük Ω bilinçaltı olarak büyük regard olarak da kabul edilir.

Tek kelimeyle, büyük O, büyük big ve büyük Ω tanımlarla aynı şey değildir, ancak ağız ve beynimizde aynı şeydir.