Bir algoritmanın zaman karmaşıklığı nasıl bulunur?

Soru

Bir algoritmanın zaman karmaşıklığı nasıl bulunur?

SO'ya soru göndermeden önce ne yaptım?

Bu , bu ve diğer birçok bağlantıdan geçtim

Ama zaman karmaşıklığının nasıl hesaplanacağıyla ilgili açık ve net bir açıklama bulamadım.

Neyi biliyorum ?

Aşağıdaki kod kadar basit bir kod isteyin:

char h = 'y'; // This will be executed 1 time
int abc = 0; // This will be executed 1 time

Aşağıdaki gibi bir döngü deyin:

for (int i = 0; i < N; i++) {        
    Console.Write('Hello World !');
}

int i = 0; Bu yalnızca bir kez yürütülür . Zaman aslında i=0bildirime değil hesaplanır .

i <N; Bu N + 1 kez yürütülecek

i ++; Bu işlem N kez yürütülecek

Bu döngü için gereken işlem sayısı

{1+ (N + 1) + N} = 2N + 2

Not: Zaman karmaşıklığını hesaplama konusundaki anlayışımdan emin olmadığım için bu hala yanlış olabilir

Ne bilmek istiyorum?

Tamam, bu küçük temel hesaplamaları bildiğimi düşünüyorum, ama çoğu durumda zaman karmaşıklığını şu şekilde gördüm:

O (N), O (n2), O (log n), O (n!) .... ve diğerleri ,

Biri bir algoritmanın zaman karmaşıklığını nasıl hesapladığını anlamama yardımcı olabilir mi? Eminim bunu bilmek isteyen benim gibi pek çok yeni kişi var.

Bir algoritmanın zaman karmaşıklığı nasıl bulunur?

Girdisinin boyutunun bir işlevi olarak kaç makine talimatı uygulayacağını ekler ve ardından ifadeyi en büyük (N çok büyük olduğunda) terime sadeleştirirsiniz ve herhangi bir basitleştirici sabit faktörü içerebilir.

Örneğin, bunu basit 2N + 2olarak tanımlamak için makine talimatlarını nasıl basitleştirdiğimizi görelimO(N) .

Neden ikisini kaldırıyoruz 2 s'yi ?

N büyüdükçe algoritmanın performansıyla ilgileniyoruz.

İki terimi 2N ve 2 düşünün.

N büyüdükçe bu iki terimin göreceli etkisi nedir? Diyelim ki N bir milyon.

O zaman ilk dönem 2 milyon ve ikinci dönem sadece 2.

Bu nedenle, büyük N için en büyük terimler hariç hepsini bırakıyoruz.

Yani, şimdi biz gitmiş 2N + 2etmek2N .

Geleneksel olarak, yalnızca sabit faktörlere kadar performansla ilgileniyoruz .

Bu, N büyük olduğunda performansta sürekli bir fark farkı olup olmadığını gerçekten umursamadığımız anlamına gelir. 2N birimi ilk etapta iyi tanımlanmamıştır. Böylece en basit ifadeye ulaşmak için sabit bir faktörle çarpabilir veya bölebiliriz.

Böylece 2Nadil olur N.

Bu mükemmel bir makale: http://www.daniweb.com/software-development/computer-science/threads/13488/time-complexity-of-algorithm

Aşağıdaki cevap yukarıdan kopyalanır (mükemmel bağlantının büst olması durumunda)

Zaman karmaşıklığını hesaplamak için en yaygın metrik Büyük O gösterimidir. Bu tüm sabit faktörleri ortadan kaldırır, böylece N sonsuza yaklaştıkça çalışma süresi N'ye göre tahmin edilebilir. Genel olarak şöyle düşünebilirsiniz:

statement;

Sabittir. İfadenin çalışma süresi N'ye göre değişmez.

for ( i = 0; i < N; i++ )
     statement;

Doğrusaldır. Döngünün çalışma süresi N ile doğru orantılıdır. N iki katına çıktığında çalışma süresi de aynıdır.

for ( i = 0; i < N; i++ ) {
  for ( j = 0; j < N; j++ )
    statement;
}

İkinci dereceden. İki döngünün çalışma süresi N karesiyle orantılıdır. N iki katına çıktığında çalışma süresi N * N artar.

while ( low <= high ) {
  mid = ( low + high ) / 2;
  if ( target < list[mid] )
    high = mid - 1;
  else if ( target > list[mid] )
    low = mid + 1;
  else break;
}

Logaritmiktir. Algoritmanın çalışma süresi, N'nin 2'ye bölünme sayısı ile orantılıdır. Bunun nedeni, algoritmanın çalışma alanını her bir yinelemeyle ikiye bölmesidir.

void quicksort ( int list[], int left, int right )
{
  int pivot = partition ( list, left, right );
  quicksort ( list, left, pivot - 1 );
  quicksort ( list, pivot + 1, right );
}

N * günlüğü (N). Çalışma süresi logaritmik olan N döngülerinden (yinelemeli veya özyinelemeli) oluşur, bu nedenle algoritma doğrusal ve logaritmik bir kombinasyonudur.

Genel olarak, bir boyuttaki her öğeyle bir şey yapmak doğrusaldır, iki boyutta her öğeyle bir şey yapmak ikinci derecelidir ve çalışma alanını ikiye bölmek logaritmiktir. Kübik, üstel ve karekök gibi başka Big O önlemleri de vardır, ancak bunlar neredeyse yaygın değildir. Büyük O gösterimi, önlemin O ( <type> )nerede <type>olduğu olarak tanımlanır . Hızlı sıralama algoritması şu şekilde tanımlanır:O ( N * log ( N ) ) .

Bunların hiçbirinin en iyi, ortalama ve en kötü durum önlemlerini dikkate almadığını unutmayın. Her birinin kendi Büyük O gösterimi olurdu. Ayrıca bunun ÇOK basit bir açıklama olduğunu unutmayın. Big O en yaygın olanıdır, ancak aynı zamanda gösterdiğimden daha karmaşık. Büyük omega, küçük o ve büyük teta gibi başka notasyonlar da vardır. Muhtemelen onlarla bir algoritma analizi kursu dışında karşılaşmayacaksınız. ;)

Buradan alındı ​​- Bir Algoritmanın Zaman Karmaşıklığına Giriş

1. Giriş

Bilgisayar biliminde, bir algoritmanın zaman karmaşıklığı, bir algoritmanın girdiyi temsil eden dizenin uzunluğunun bir fonksiyonu olarak çalışması için geçen süreyi belirler.

2. Büyük O gösterimi

Bir algoritmanın zaman karmaşıklığı, genellikle katsayıları ve düşük sıra terimlerini hariç tutan büyük O gösterimi kullanılarak ifade edilir. Bu şekilde ifade edildiğinde, zaman karmaşıklığının asimptotik olarak, yani girdi boyutu sonsuza giderken tarif edildiği söylenir.

Örneğin, n boyutunun tüm girişlerinde bir algoritmanın gerektirdiği süre en fazla 5n ise ³ + 3n ise, asimptotik zaman karmaşıklığı O (n ³ ) 'tür. Daha sonra.

Birkaç örnek daha:

• 1 = O (n)
• n = O (n ² )
• log (n) = O (n)
• 2 n + 1 = O (n)

3. O (1) Sabit Zaman:

Bir algoritmanın, giriş boyutundan bağımsız olarak aynı miktarda zaman gerektirmesi durumunda sabit sürede çalıştığı söylenir.

Örnekler:

• dizi: herhangi bir öğeye erişme
• sabit boyutlu yığın: push ve pop yöntemleri
• sabit boyutlu kuyruk: enqueue ve dequeue yöntemleri

4. O (n) Doğrusal Zaman

Bir algoritmanın, zaman yürütme giriş boyutuyla doğru orantılıysa, doğrusal zamanda çalıştığı söylenir, yani, giriş boyutu arttıkça zaman doğrusal olarak büyür.

Aşağıdaki örnekleri düşünün, aşağıda doğrusal olarak bir eleman arıyorum, bu O (n) 'in zaman karmaşıklığına sahiptir.

int find = 66;
var numbers = new int[] { 33, 435, 36, 37, 43, 45, 66, 656, 2232 };
for (int i = 0; i < numbers.Length - 1; i++)
{
    if(find == numbers[i])
    {
        return;
    }
}

Daha fazla örnek:

• Dizi: Doğrusal Arama, Geçiş, Minimum bul vb.
• ArrayList: yöntem içerir
• Kuyruk: yöntem içerir

5. O (log n) Logaritmik Zaman:

Bir algoritmanın, zaman yürütmesi girdi boyutunun logaritması ile orantılıysa, logaritmik zamanda çalıştığı söylenir.

Örnek: İkili Arama

"Yirmi soru" oyunu hatırlayın - görev bir aralıkta gizli bir sayının değerini tahmin etmektir. Her tahmin yaptığınızda, tahmininizin çok yüksek veya çok düşük olduğu size söylenir. Yirmi soru oyunu, aralık boyutunu yarıya indirmek için tahmin numaranızı kullanan bir strateji gerektirir. Bu, ikili arama olarak bilinen genel problem çözme yöntemine bir örnektir

6. O (n ² ) İkinci Derece

Bir algoritmanın, zamanın yürütülmesi girdi boyutunun karesiyle orantılıysa, ikinci dereceden çalıştığı söylenir.

Örnekler:

• Kabarcık Sırala
• Seçim Sıralaması
• Ekleme Sıralaması

7. Bazı Yararlı linkler

• Big-O Yanılgıları
• Algoritmanın Karmaşıklığını Belirleme
• Big O Hile Sayfası

Bu soru için bazı iyi cevaplar olmasına rağmen. Burada birkaç örnekle başka bir cevap vermek istiyorum loop.

• O (n) : Döngü değişkenleri sabit bir miktarda artırılırsa / azaltılırsa , bir döngünün Zaman Karmaşıklığı O (n) olarak kabul edilir . Örneğin, aşağıdaki işlevler O (n) zaman karmaşıklığına sahiptir.

  // Here c is a positive integer constant   
  for (int i = 1; i <= n; i += c) {  
      // some O(1) expressions
  }
  
  for (int i = n; i > 0; i -= c) {
      // some O(1) expressions
  }
  

• O (n ^ c) : İç içe döngülerin zaman karmaşıklığı, en içteki ifadenin yürütülme sayısına eşittir. Örneğin, aşağıdaki örnek döngülerinin O (n ^ 2) zaman karmaşıklığı vardır

  for (int i = 1; i <=n; i += c) {
     for (int j = 1; j <=n; j += c) {
        // some O(1) expressions
     }
  }
  
  for (int i = n; i > 0; i += c) {
     for (int j = i+1; j <=n; j += c) {
        // some O(1) expressions
  }
  

  Örneğin, Seçim sıralaması ve Ekleme Sıralaması O (n ^ 2) zaman karmaşıklığına sahiptir.

• O (Logn) Süresi Loop değişkenleri sabit bir miktarda bölünürse / çarpılırsa, bir loop'un karmaşıklığı O (Logn) olarak kabul edilir .

  for (int i = 1; i <=n; i *= c) {
     // some O(1) expressions
  }
  for (int i = n; i > 0; i /= c) {
     // some O(1) expressions
  }
  

  Örneğin, İkili Arama O (Logn) zaman karmaşıklığına sahiptir.

• O (LogLogn) Zaman Döngü değişkenleri sabit bir miktarda katlanarak azaltılır / arttırılırsa , bir döngünün karmaşıklığı O (LogLogn) olarak kabul edilir .

  // Here c is a constant greater than 1   
  for (int i = 2; i <=n; i = pow(i, c)) { 
     // some O(1) expressions
  }
  //Here fun is sqrt or cuberoot or any other constant root
  for (int i = n; i > 0; i = fun(i)) { 
     // some O(1) expressions
  }
  

Zaman karmaşıklığı analizine bir örnek

int fun(int n)
{    
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j < n; j += i)
        {
            // Some O(1) task
        }
    }    
}

analiz :

For i = 1, the inner loop is executed n times. For i = 2, the inner loop is executed approximately n/2 times. For i = 3, the inner loop is executed approximately n/3 times. For i = 4, the inner loop is executed approximately n/4 times. ……………………………………………………. For i = n, the inner loop is executed approximately n/n times.

Yukarıdaki algoritmanın toplam zaman karmaşıklığı (n + n/2 + n/3 + … + n/n) , hangisi olurn * (1/1 + 1/2 + 1/3 + … + 1/n)

Serilerle ilgili önemli olan şey O (Logn) 'a(1/1 + 1/2 + 1/3 + … + 1/n) eşittir . Yukarıdaki kodun zaman karmaşıklığı O (nLogn) .

Referans: 1 2 3

Örneklerle zaman karmaşıklığı

1 - Temel İşlemler (aritmetik, karşılaştırmalar, dizi elemanlarına erişim, atama): Çalışma süresi daima sabit O (1)

Misal :

read(x)                               // O(1)
a = 10;                               // O(1)
a = 1.000.000.000.000.000.000         // O(1)

2 - If else else ifadesi: Yalnızca iki veya daha fazla olası ifadeden maksimum çalışma süresini almak.

Misal:

age = read(x)                               // (1+1) = 2
if age < 17 then begin                      // 1
      status = "Not allowed!";              // 1
end else begin
      status = "Welcome! Please come in";   // 1
      visitors = visitors + 1;              // 1+1 = 2
end;

Dolayısıyla, yukarıdaki sözde kodun karmaşıklığı T (n) = 2 + 1 + max (1, 1 + 2) = 6'dır. Böylece, büyük oh hala sabit T (n) = O (1) 'dir.

3 - Döngü (tekrar ederken için): Bu ifade için çalışma süresi, döngü sayısının, döngü içindeki işlem sayısıyla çarpımıdır.

Misal:

total = 0;                                  // 1
for i = 1 to n do begin                     // (1+1)*n = 2n
      total = total + i;                    // (1+1)*n = 2n
end;
writeln(total);                             // 1

Dolayısıyla, karmaşıklığı T (n) = 1 + 4n + 1 = 4n + 2'dir. Böylece, T (n) = O (n).

4 - İç İçe Döngü (döngü içinde döngü): Ana döngü içinde en az bir döngü olduğundan, bu ifadenin çalışma süresi O (n ^ 2) veya O (n ^ 3) kullanır.

Misal:

for i = 1 to n do begin                     // (1+1)*n  = 2n
   for j = 1 to n do begin                  // (1+1)n*n = 2n^2
       x = x + 1;                           // (1+1)n*n = 2n^2
       print(x);                            // (n*n)    = n^2
   end;
end;

Ortak Çalışma Süresi

Bir algoritmayı analiz ederken bazı yaygın çalışma süreleri vardır:

1. O (1) - Sabit Süre Sabit süre, çalışma süresinin sabit olduğu, giriş boyutundan etkilenmediği anlamına gelir .

2. O (n) - Doğrusal Zaman Bir algoritma n giriş boyutunu kabul ettiğinde, n işlemi de gerçekleştirir.

3. O (log n) - Çalışma süresi O (log n) olan logaritmik Zaman Algoritması O (n) 'den biraz daha hızlıdır. Genellikle algoritma, sorunu aynı boyuttaki alt sorunlara böler. Örnek: ikili arama algoritması, ikili dönüşüm algoritması.

4. O (n log n) - Linearitmik Zaman Bu çalışma süresi, genellikle sorunu özyinelemeli olarak alt problemlere bölen ve n zamanında birleştiren "böl ve fethet algoritmalarında" bulunur. Örnek: Sıralama Birleştirme algoritması.

5. O (n ² ) - İkinci dereceden Time Look Bubble Sort algoritması!

6. O (n ³ ) - Kübik Zaman O (n ² ) ile aynı prensibe sahiptir .

7. O (2 ⁿ ) - Üstel Zaman Girdi büyüdükçe çok yavaştır, n = 1000.000 ise T (n) 21000.000 olur. Brute Force algoritması bu çalışma süresine sahiptir.

8. O (n!) - Faktöriyel Zaman YAVAŞ !!! Örnek: Seyahat Satıcısı Sorunu (TSP)

Alındığı bu makalede . Çok iyi açıklanmış bir okuma vermelidir.

Kodu analiz ederken, satır satır analiz etmeniz, her işlemi saymanız / zaman karmaşıklığını tanımanız gerekir, sonunda, tüm resmi elde etmek için onu toplamalısınız.

Örneğin, doğrusal karmaşıklığa sahip bir basit döngüye sahip olabilirsiniz , ancak daha sonra aynı programda kübik karmaşıklığa sahip üçlü bir döngüye sahip olabilirsiniz , böylece programınız kübik karmaşıklığa sahip olur . Büyümenin fonksiyon sırası burada devreye giriyor.

Bir algoritmanın zaman karmaşıklığı için olasılıkların neler olduğuna bakalım, yukarıda bahsettiğim büyüme sırasını görebilirsiniz:

• Sabit zaman büyümenin bir emir vardır1, örneğin:a = b + c.

• Logaritmik zamanın bir büyüme sırası vardırLogN, genellikle bir şeyi ikiye böldüğünüzde (ikili arama, ağaçlar, hatta döngüler) veya bir şeyi aynı şekilde çarptığınızda oluşur.

• Doğrusal , büyüme sırası,Nörneğin

  int p = 0;
  for (int i = 1; i < N; i++)
    p = p + 2;
  

• Doğrusal , büyüme sırasın*logN, genellikle böl ve fethet algoritmalarında ortaya çıkar.

• Kübik , büyüme sırasıN^3, klasik örnek, tüm üçlüleri kontrol ettiğiniz üçlü bir döngüdür:

  int x = 0;
  for (int i = 0; i < N; i++)
     for (int j = 0; j < N; j++)
        for (int k = 0; k < N; k++)
            x = x + 2
  

• Üstel , büyüme sırası2^N, genellikle kapsamlı bir arama yaptığınızda ortaya çıkar, örneğin bazı kümelerin alt kümelerini kontrol edin.

Gevşek olarak, zaman karmaşıklığı, girdi boyutu arttıkça bir algoritmanın işlem sayısının veya çalışma süresinin nasıl büyüdüğünü özetlemenin bir yoludur.

Hayattaki çoğu şey gibi, bir kokteyl partisi de anlamamıza yardımcı olabilir.

O (N)

Partiye geldiğinizde, herkesin elini sıkmanız gerekir (her öğede bir işlem yapın). Katılımcı sayısı Narttıkça, herkesin elini sıkmak için gereken süre / iş de artar O(N).

Neden O(N)olmasın cN?

İnsanlarla el sıkışmak için geçen süre değişiyor. Bunu ortalayabilir ve sabit bir şekilde yakalayabilirsiniz c. Ama buradaki temel operasyon --- herkesle el sıkışmak --- O(N)ne olursa olsun, her zaman orantılı olacaktır c. Bir kokteyl partisine gitmemiz gerekip gerekmediğini tartışırken, genellikle bu toplantıların nasıl göründüğünün dakika detaylarından daha çok herkesle tanışmamız gerekeceğiyle ilgileniyoruz.

O (N ^ 2)

Kokteyl partisinin sahibi, herkesin herkesle buluştuğu aptal bir oyun oynamanızı istiyor. Bu nedenle, N-1diğer insanlarla tanışmalısınız ve bir sonraki kişi sizinle daha önce tanıştığı için N-2insanlarla tanışmaları gerekir , vb. Bu serinin toplamı x^2/2+x/2. Katılımcı sayısı arttıkça, x^2terim hızlı bir şekilde büyür, bu yüzden diğer her şeyi bırakıyoruz.

O (N ^ 3)

Diğer herkesle tanışmalısınız ve her toplantı sırasında odadaki diğer herkes hakkında konuşmalısınız.

O (1)

Ev sahibi bir şey duyurmak istiyor. Bir bardağı ding ve yüksek sesle konuşurlar. Herkes onları duyar. Kaç katılımcı olduğu önemli değil, bu işlem her zaman aynı süreyi alıyor.

O (log N)

Ev sahibi masada herkesin alfabetik sıraya göre dizildi. Dan nerede? Onun Adam ve Mandy arasında bir yerde olması gerektiğini düşünüyorsun (kesinlikle Mandy ve Zach arasında değil!). Buna göre, George ve Mandy arasında mı? Hayır. Adam ile Fred arasında, Cindy ile Fred arasında olmalı. Ve böylece ... setin yarısına, sonra da setin yarısına bakarak Dan'ı verimli bir şekilde bulabiliriz. Nihayetinde O'ya bakıyoruz (log_2 N) bireylere .

O (N log N)

Yukarıdaki algoritmayı kullanarak masada nerede oturacağınızı bulabilirsiniz. Çok sayıda insan masaya gelirse, birer birer ve hepsi bunu yaparsa, bu O (N log N) zaman . Bu, herhangi bir öğe koleksiyonunun karşılaştırılması gerektiğinde sıralanmasının ne kadar sürdüğü ortaya çıkıyor.

En İyi / En Kötü Durum

Partiye geliyor ve Inigo'yu bulmanız gerekiyor - ne kadar sürecek? Ne zaman geldiğine bağlıdır. Herkes etrafta frezeleme yapıyorsa, en kötü duruma çarptınız: zaman alacaktır O(N). Ancak, herkes masada oturuyorsa, sadece O(log N)zaman alacaktır . Ya da belki ev sahibinin bardağı bağıran gücünden faydalanabilirsiniz ve sadeceO(1) zaman .

Ana bilgisayarın kullanılamadığı varsayılarak, Inigo bulma algoritmasının, geldiğinizde partinin durumuna bağlı olarak bir alt sınırı O(log N)ve bir üst sınırı olduğunu söyleyebiliriz O(N).

Mekan ve İletişim

Aynı fikirler, algoritmaların alanı veya iletişimi nasıl kullandığını anlamak için de uygulanabilir.

Knuth, "Şarkıların Karmaşıklığı" başlıklı eski hakkında güzel bir makale yazdı .

Teorem 2: O (1) karmaşıklığının keyfi olarak uzun şarkıları vardır.

PROOF: (Casey ve Sunshine Bandı nedeniyle). (15) ile tanımlanan Sk şarkılarını düşünün, ancak

V_k = 'That's the way,' U 'I like it, ' U
U   = 'uh huh,' 'uh huh'

tüm k.

Bu sorunun bir geri dönüşü olduğunu biliyorum ve burada bazı mükemmel cevaplar var, yine de bu yazıda yanacak matematiksel fikirli insanlar için başka bir bit paylaşmak istedim. Usta teoremi karmaşıklığını okuyan zaman bilmek için başka yararlı bir şeydir. Diğer cevaplarda bahsedildiğini görmedim.

O (n), bir algoritmanın zaman karmaşıklığını yazmak için kullanılan büyük O gösterimidir. Bir algoritmada yürütme sayısını eklediğinizde, sonuç olarak 2N + 2 gibi bir ifade elde edersiniz, bu ifadede N hakim olan terimdir (değeri artar veya azalırsa ifade üzerinde en büyük etkiye sahip olan terim). Şimdi O (N), zaman terimidir ve N termin hakimiyetindedir. Misal

For i= 1 to n;
  j= 0;
while(j<=n);
  j=j+1;

burada iç döngü için toplam yürütme sayısı n + 1 ve dış döngü için toplam yürütme sayısı n (n + 1) / 2'dir, bu nedenle tüm algoritma için toplam yürütme sayısı n + 1 + n (n + 1 / 2'dir ) = (n ^ 2 + 3n) / 2. burada n ^ 2 hakim olan terimdir, bu nedenle bu algoritmanın zaman karmaşıklığı O (n ^ 2)