Karmaşıklık Giriş

KarmaşıklıkGiriş

Algoritma Analizi • Neden algoritmayı analiz ederiz? • Algoritmanın performansını ölçmek için • Farklı algoritmalarla karşılaştırmak için • Daha iyisi mümkün mü? Olabileceklerin en iyisi mi? • Özelliklerinin analizi • Algoritmanın çalışma zamanı • Hafızada kapladığı alan

Karmaşıklık: Algoritma performansı ölçme yöntemi Bir algoritmanın performansı iç ve dış faktörlere bağlıdır. • İç • Algoritma verimliliği: • Çalıştırmak için gereken zaman • Çalıştırmak için gerekenyer (bellek alanı) • Dış • Girdi verisinin büyüklüğü • Bilgisayarın hızı • Derleyicinin kalitesi Karmaşıklık iç faktörlerle ve daha çok da zamanla ilgilidir.

N giriş verisi Çalışma zamanıT2(n) 10001010101000111110001100011101010101010101010010001010101000100000000000011110101000111010 Algoritma 2 Çalışma Zamanı Analizi Algoritma 1 T1(N)=1000N Algoritma 2 T2(N)=N2 Çalışma zamanı T1(n) Ngiriş verisi Algoritma 1

Çalışma Zamanı Analizi Algoritma2 Çalışma zamanıT(N) Algoritma1 Giriş verisi N 1000

Çalışma Zamanları Özeti N değerinin 1000’den küçük olduğu durumlarda iki algoritma arasındaki çalışma zamanı ihmal edilebilir büyüklüktedir.

Büyüme Hızı ve Büyük-O(big-O)notasyonu • Büyüme hız bir algoritmanın performansını yansıtan en iyi göstergedir. • Büyük-O notasyonu büyüme hızını gösterir. Bir algoritmanın performansını en iyi tanımlayan matematiksel bir formüldür ve algoritmanın iç detaylarına bakılarak elde edilir. • Büyük-Ogirdi verisinin büyüklüğünü gösteren bir N parametresine dayanan bir fonksiyondur. • Örneğin n değerine bağlı olarak performansı (sabit a, b, c değerleri için) an2 + bn + c olan bir algoritmanın performansı O(N2)’dir • N değeri arttıkça N2 terimi baskın olacağı için büyük-O notasyonunda sadece baskın olan terim kullanılır

O Notasyonu- Asimtotik Üst Limit • Bir algoritmanın çalışma süresi T(N)=O(f(n)) O bir fonksiyon değil, sadece gösterimdir. • T(N) c f(n) ve N n0koşullarını sağlayan c ve n0 değerleri varsa T(N) c f(n) ifadesi doğrudur. • f(n), T(N)’in asimtotik üst limiti olarak adlandırılır. • T(N)=O(f(n))

O notasyonu • O notasyonunda yazarken en basit şekilde yazarız. • Örneğin • 3n2+2n+5 = O(n2) • Aşağıdaki gösterimlerde doğrudur fakat kullanılmaz. • 3n2+2n+5 = O(3n2+2n+5) • 3n2+2n+5 = O(n2+n) • 3n2+2n+5 = O(3n2)

Sık Kullanılan Büyüme hızları

Büyüme Hızları O(N2) O(Nlog N) Zaman Kısa bir süre için N2 NlogN’den daha iyi N

Bir programın asıl çalışma zamanını hesaplama (örnek) • Bir işlem için harcanan zaman 10ms olsun(bir veri üzerinde yapılan tek bir işlem) • 1000 veriyi işlemek için programın ne kadar çalışması gerekir? Programın çalışma zamanı aşağıdaki gibi verilmişse bu değer nasıl hesaplanır? • log10N • N • N log10N • N2 • N3 • (1 veri için zaman) x (N veri için verilen büyük-O( ) zaman karmaşıklığı)

büyük-O nasıl hesaplanır? 1Döngüler 2İç içe Döngüler 3Ardışık deyimler 4 If-then-else deyimleri 5 Logaritmikkarmaşıklık Bir program kodunun zaman karmaşıklığını hesaplamak için 5 kural

ndefa çalışır Sabit zaman Kural 1: Döngüler Bir döngünün çalışma zamanı en çok döngü içindeki deyimlerin çalışma zamanının iterasyon sayısıyla çarpılması kadardır. for (i=1; i<=n; i++) { m = m + 2; } Toplam zaman = sabit c * n = cn = O(N)

Dış döngü ndefa çalışır iç döngü ndefa çalışır Sabit zaman Kural2:İç içeDöngüler İçteki analiz yapılır. Toplam zaman bütün döngülerin çalışma sayılarının çarpımına eşittir for (i=1; i<=n; i++) { for (j=1; j<=n; j++) { k = k+1; } } Toplam zaman= c * n * n * = cn2 = O(N2)

Sabit zaman ndefa çalışır Sabit zaman iç döngü ndefa çalışır Dış döngü ndefa çalışır Sabit zaman Kural 3: Ardışık deyimler Her deyimin zamanı birbirine eklenir. x = x +1; for (i=1; i<=n; i++) { m = m + 2; } for (i=1; i<=n; i++) { for (j=1; j<=n; j++) { k = k+1; } } toplam zaman= c0 + c1n + c2n2 = O(N2)

test: sabit then: sabit else: (sabit +sabit) * n Kural 4: If-then-else deyimleri En kötü çalışma zamanı:test zamanına then veya else kısmındaki çalışma zamanının hangisi büyükse o kısım eklenir. if (depth( ) != otherStack.depth( ) ) { return false; } else { for (int n = 0; n < depth( ); n++) { if (!list[n].equals(otherStack.list[n])) return false; } } Diğer if : sabit+sabit (else yok) Toplam zaman = c0 + c1 + (c2 + c3) * n = O(N)

Kural 5: Logaritmikkarmaşıklık Problemin büyüklüğünü belli oranda(genelde ½) azaltmak için sabit bir zaman harcanıyorsa bu algoritma O(log N)’dir. Örnek algoritma (binary search): N sayfalı bir sözlükten bir sözcük arama • Sözlüğün orta kısmına bakılır • Sözcük ortaya göre sağda mı solda mı kaldığı bulunur? • Bu işlem sağ veya solda sözcük bulunana kadar tekrarlanır

O notasyonu- Örnek 1 • 3n2+2n+5 = O(n2) ifadesinin doğru olup olmadığını ispatlayınız. 10 n2 = 3n2 + 2n2 + 5n2  3n2 + 2n + 5 for n  1 c = 10, n0 = 1 Çözüm kümesini sağlayan kaç tane n0 ve c cifti olduğu önemli değildir. Tek bir çift olması notasyonun doğruluğu için yeterlidir.

O notasyonu- Örnek 2 • T(N)=O(7n2+5n+4) olarak ifade edilebiliyorsa, T(N) fonksiyonu aşağıdakilerden herhangi biri olabilir. • T(N)=n2 • T(N)=1000n2+2n+300 • T(N)= O(7n2+5n+4) =O(n2)

O notasyonu- Örnek 3 • Fonksiyonların harcadıkları zamanları O notasyonuna göre yazınız. • f1(n) = 10 n + 25 n2 • f2(n) = 20 n log n + 5 n • f3(n) = 12 n log n + 0.05 n2 • f4(n) = n1/2 + 3 n log n • O(n2) • O(n log n) • O(n2) • O(n log n)

Analiz • Strateji:Alt ve üst limitlerin bulunması Üst limit Algoritmanın gerçek fonksiyonu Alt limit

Analiz • Çalışma zamanının kesin olarak belirlenmesi zordur • Giriş verilerine bağlı olan en iyi durum (best case) • Ortalama durum (Average case), hesaplanması zordur • En kötü durum analizi, hesaplanması diğerlerine göre kolaydır

En iyi, ortalama, en kötü durum karmaşıklığı • Bazı durumlarda en iyi, ortalama, en kötü durum karmaşıklığı gözönüne almak gerekir • Örnek: Liste sıralarken eğer liste zaten sıralıya yakınsa yapılacak iş azdır. • En kötü durum muhtemel bütün girdiler için bir sınır çizer ve genelde ortalamadan daha kolay bulunur • En kötü, O(N) veya o(N):  veya >asıl fonksiyon * • Genel, Θ(N): asıl fonksiyon * • En iyi, Ω(N): asıl fonksiyon *

 Notasyonu- Asimtotik Alt Limit • O notasyonun tam tersidir. • Her durumda T(N)  c f(n)veN n0 koşullarını sağlayan pozitif, sabit c ve n0 değerleri bulunabiliyorsa T(N)=(f(n)) ifadesi doğrudur. • f(n), T(N)’in asimtotik alt limiti olarak • adlandırılır. f(n) c g(n) n0

 notasyonu- Örnek 1 • 7n2+3n+5 = O(n4) • 7n2+3n+5 = O(n3) • 7n2+3n+5 = O(n2) • 7n2+3n+5 = (n2) • 7n2+3n+5 = (n) • 7n2+3n+5 = (1)

Algoritma 1 int Sum (int N) { int i, PartialSum; PartialSum=0; for(i=1 ;i<=N ; i++) PartialSum+=i*i*i; return PartialSum; } 1 1+(N+1)+N N+N+2N 1 Çalışma zamanı 6N+4=O(N)

Algoritma 2 for(i=0;i<N; i++) for(j=1;j<=N; i++) k++; Çalışma zamanı O(N2) for(i=0;i<N; i++) A[i]=0; for(i=0;i<N; i++) for(j=1; j<=N; i++) A[i]+=A[j]+i+j; Çalışma zamanı O(N2)

Algoritma 3 If( condition ) S1 Else S2 Çalışma zamanı max_calışma_zamanı(S1,S2)

Algoritma 4 • int binary search(A,key,N) • low=0, high=N-1 • while(lowhigh) • mid=(low+high)/2 • if(A[mid]<key) • low=mid+1 • if(A[mid]>key) • high=mid-1; • if(A[mid]=key) • return mid • Return not found Her bir iterasyondan sonra, arama yapılacak eleman sayısı logaritmik olarak azalmaktadır. Çalışma süresi O(logN)’dir.

Algoritma 5 • int binarysearch(A,key,low,high) • if (low>high) • Return not found • else • mid=(low+high)/2 • if(A[mid]<key) • Return binarysearch(A,key,mid+1,high) • if(A[mid]>key) • Return binary search(A,key,low,mid-1) • if (A[mid]=key) • Return mid T(N)=T(N/2)+O(1)

Algoritma 6 MaxSubsequenceSum(const int A[], int n) ThisSum=MaxSum=0; for(j=0;j<N;j++) ThisSum+=A[j]; if (ThisSum<MaxSum) MaxSum=ThisSum; else if(ThisSum<0) ThisSum=0; Return MaxSum; Çalışma zamanı O(N)

Performans her şey demek değildir! • Bazen aşağıdaki iki durum birbiriyle çelişebilir: • Anlama, yazma ve hata ayıklama kolaylığı • Zaman ve yerin verimli kullanılmasıEfficient use of time and space • Bu nedenle maksimum performans her zaman tercih edilmeyebilir • Ancak yine de en uygun algoritmayı kullanmak mümkün olmasa da farklı yöntemleri karşılaştırmak yararlıdır.

Karmaşıklık Giriş