Karmaşıklık

Giriş
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

2
 Karmaşıklık: Algoritma performansı
ölçme yöntemi

Bir algoritmanın performansı iç ve dış faktörlere bağlıdır.

İç Dış
Algoritma verimliliği: • Girdi verisinin
• Çalıştırmak için gereken büyüklüğü
zaman • Bilgisayarın hızı
• Çalıştırmak için gereken • Derleyicinin kalitesi
yer (bellek alanı)

Karmaşıklık iç faktörlerle ve daha çok da zamanla ilgilidir.

3
Çalışma Zamanı Analizi
Algoritma 1 T1(N)=1000N
Algoritma 2 T2(N)=N2

N giriş verisi Çalışma zamanı T1(n)

Algoritma 1

N giriş verisi
100010101010001111100011000111010
101010101010100100010101010001000
Çalışma zamanıT2(n)
00000000011110101000111010

Algoritma 2 4
Çalışma Zamanı Analizi
Çalışma zamanı T(N)

Algoritma 2

Algoritma 1

Giriş verisi N
1000
5
Çalışma Zamanları Özeti
N T1 T2

10 10-2 sec 10-4 sec

100 10-1 sec 10-2 sec

1000 1 sec 1 sec

10000 10 sec 100 sec

100000 100 sec 10000 sec

N değerinin 1000’den küçük olduğu durumlarda iki

algoritma arasındaki çalışma zamanı ihmal edilebilir
büyüklüktedir.
6
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-O girdi 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

7
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 ≥ n0 koş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))
8
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)

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

Zaman karmaşıklığı Örnek

O(1) sabit Bağlı listeye ilk eleman olarak ekleme yapma

O(log N) log Sıralı bir dizide bir eleman arama

O(N) lineer Sıralı olmayan bir dizide bir eleman arama
O(N log N) n-log-n N elemanı böl-parçala-yut yöntemiyle
sıralama
O(N2) ikinci dereceden Bir grafikte iki düğüm arasındaki en kısa yolu
bulma
O(N3) üçüncü Ardarda gerçekleştirilen lineer denklemler
dereceden
O(2N) üssel Hanoi’nin Kuleleri problemi
10
 Büyüme Hızları

O(N2)

O(Nlog N)
Zaman

Kısa bir süre için N2

NlogN’den daha iyi

11
 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?
– log10 N
– N
– N log10 N
– N2
– N3

• (1 veri için zaman) x (N veri için verilen büyük-O( ) zaman karmaşıklığı

12
büyük-O nasıl hesaplanır?

Bir program kodunun zaman

karmaşıklığını hesaplamak için 5
kural
1 Döngüler
2 İç içe Döngüler
3 Ardışık deyimler
4 If-then-else deyimleri
5 Logaritmik karmaşıklık

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

n defa {
çalışır m = m + 2; Sabit zaman
}

Toplam zaman = sabit c * n = cn = O(N)

14
Kural 2:İç içe Dö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++) {
Dış döngü for (j=1; j<=n; j++) { iç döngü
n defa k = k+1; n defa
çalışır } çalışır
} Sabit zaman

Toplam zaman = c * n * n * = cn2 = O(N2)

15
Kural 3: Ardışık deyimler

Her deyimin zamanı birbirine eklenir.

Sabit zaman x = x +1;

for (i=1; i<=n; i++) {
n defa
Sabit zaman m = m + 2;
} çalışır
for (i=1; i<=n; i++) {
Dış döngü for (j=1; j<=n; j++) { iç döngü
n defa k = k+1; n defa
} çalışır
çalışır Sabit zaman
}

toplam zaman = c0 + c1n + c2n2 = O(N2)

16
 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.

test: if (depth( ) != otherStack.depth( ) ) {

sabit return false; then:
} sabit
else {
for (int n = 0; n < depth( ); n++) { else:
Diğer if : if (!list[n].equals(otherStack.list[n]))
(sabit +sabit) * n
sabit+sabit return false;
(else yok) }
}

Toplam zaman = c0 + c1 + (c2 + c3) * n = O(N)

17
Kural 5: Logaritmik karmaşı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
18
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 Çözüm kümesini
sağlayan kaç tane n0 ve
c = 10, n0 = 1 c cifti olduğu önemli
değildir. Tek bir çift
olması notasyonun
doğruluğu için
yeterlidir.
19
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)

20
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 • O(n2)
• f3(n) = 12 n log n + 0.05 n2 • O(n log n)
• f4(n) = n1/2 + 3 n log n
• O(n2)
• O(n log n)

21
Analiz

• Strateji:Alt ve üst limitlerin bulunması

Üst limit

Algoritmanın gerçek fonksiyonu

Alt limit

22
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

23
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
– En kötü, O(N) veya o(N): ≥ veya > asıl fonksiyon *
– Genel, Θ(N): ≅ asıl fonksiyon *
– En iyi, Ω(N): ≤ asıl fonksiyon *

• Ö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

24
Ω Notasyonu- Asimtotik Alt Limit
 O notasyonun tam tersidir.
 Her durumda T(N) ≥ c f(n) ve N ≥ n0 koşullarını
sağlayan pozitif, sabit c ve n0 değerleri bulunabiliyorsa
T(N)=Ω (f(n)) ifadesi doğrudur. f(n)

 f(n), T(N)’in asimtotik alt limiti olarak

adlandırılır. c g(n)

n0
25
Ω 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)

26
Algoritma 1

int Sum (int N)

{
int i, PartialSum;
PartialSum=0;
for(i=1 ;i<=N ; i++) 1
PartialSum+=i*i*i;
return PartialSum;
1+(N+1)+N
} N+N+2N
1

Çalışma zamanı 6N+4=O(N)

27
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++) Çalışma zamanı O(N2)
for(j=1; j<=N; i++)
A[i]+=A[j]+i+j;

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

29
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; Her bir iterasyondan
• if(A[mid]=key)
• return mid sonra, arama
• Return not found yapılacak eleman
sayısı logaritmik
olarak azalmaktadır.
Çalışma süresi
O(logN)’dir.

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

32
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.

33