ALGORİTMA KARMAŞIKLIĞI

Problemleri çözmek için geliştirilen algoritmaların bilgisayarda yürütülme süreleri incelenirse bazı çözümler için bulunan sürelerin hiçte kabul edilebilir olmadığı görülür.

Bu durumda algoritmaların kurulmasını ve etkinliğini ayrıca incelemek önemli hale gelir. Hatta çoğu zaman problemin çözümünde yapılacak olan hesaplama yükünün de ölçülmesi gerekebilir.

Bütün bunlar problemin giriş veri sayısına (n sayısına) bağlıdır Bütün bunlar problemin giriş veri sayısına (n sayısına) bağlıdır. Bir algoritmada n büyüdükçe bu yükün hızla artmaması istenilebilir. Bir algoritmik çözümün büyüklüğünü ölçmek için bir birime ihtiyacımız vardır.

Algoritmanın değerlendirilmesinde kullanılan alışılagelmiş yöntem toplama, çıkarma, çarpma, bölme ve karşılaştırma gibi temel işlemlerin toplam sayısının hesaplanmasıdır.

a1+ a2, (a1+ a2)+ a3 ...(a1+ ..+ak-1 )+ak Örneğin k adet a1, a2, a3...... ak sayısını toplamak istersek a1+ a2, (a1+ a2)+ a3 ...(a1+ ..+ak-1 )+ak olmak üzere k-1 adet toplama yaparız.

Elemanter işlemlerin toplam sayısını algoritmanın karmaşıklığı (complexity of algorithm) olarak isimlendiririz.

Bu yöntem esas olarak algoritmanın gerçeklenmesi için geçecek toplam süreyi hesaplamaya yöneliktir. Burada her temel işlemin aynı sürede yapıldığı varsayılmaktadır. Ancak, bilgisayarlar bellekleri ile sınırlıdırlar. Algoritmanın bellek gereksinimi bilgisayarda mevcut bellekten fazla olabilir. Ya da daha yavaş ek bellek kullanımı gerekebilir ve işlem yavaşlayabilir. Saklama olayı gözönüne alınması gereken bir değerdir.

Elementer işlemler aynı sürede uygulanmazlar. Örneğin bölme işlemi, toplamadan uzundur. Ayrıca temel işlemin süresi, üzerinde işlem yapılan elemanların büyüklüğüne de bağlıdır. Büyük sayılar çok daha uzun süre alırlar. Toplu bir değişkene değer atamanın da bir süre alması gibi işlemler de bizim hesaplamamıza katılmamaktadır.

Zaman Karmaşıklığı Bu eleştirilere rağmen, algoritmanın karmaşıklığının ölçülmesinde önerilen yöntem kullanılabilir. Özel bir bilgisayarın iç işlemleri ile uğraşmamak ve basitlik için bu yönteme zaman karmaşıklığı analizi denir.

Zaman Karmaşıklığı Zaman karmaşıklığı, girdi boyutu sonsuza yaklaşırken işletim süresinin artışını temsil eder. Algoritmanın yaptığı işi, giriş sayısı n’in fonksiyonu olarak hesaplar. Zaman karmaşıklığını göstermek için BigO notasyonu kullanılır. Bu gösterimde giriş veri sayısı oldukça büyük kabul edilerek en hızlı artış gösteren terim belirlenerek zaman karmaşıklığı bu terimle ifade edilir.

BigO Notasyonu Bir algoritmanın çalışma süresi T(N)=O(f(n)) 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))

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)

O(1): Sabit zaman: Girdinin miktarından bağımsız olarak bir ya da sabit bir sayıda komutun çalıştığı algoritmalardır. Örneğin, n elemanlı bir dizinin i. elemanına bir değer atanması O(1)'dir. Çünkü bir elemana indisinden doğrudan erişilmektedir. O(n) : Doğrusal zaman: Giriş sayısı ile işlem miktarı oranı bir katsayı ile belirlenebilen algoritmalardır.Örneğin verilen gelişigüzel bir sayı dizisindeki en büyük sayıyı bulan algoritmanın zaman karmaşıklığı O(n)'dir.

O(log2 n) : Logaritmik zaman, Büyük problemlerin bölünüp küçültüldüğü algoritmalardır.O(1)'den fazla O(n)'den azdır. Örneğin Sıralı bir listenin elemanları içinde ikili arama (binary search) uygulanarak belirli bir değerin aranması O(log2 n)'dir. O(n2) : Karesel zaman: Basit sıralama algoritmalarının birçoğu (seçerek sıralama (selection sort) gibi) O(n2)'dir.

O(n.log2 n) : , Genellikle problemin küçük parçalara bölünüp ayrı ayrı çözümlerinin birleştirildiği türde algoritmalardır. Bazı hızlı sıralama algoritmaları (birleşmeli sıralama (merge sort) gibi) O(n.log2 n)'dir. O(n3) : Kübik zaman:Üç boyutlu bir tamsayı tablosundaki her elemanın değerini artıran algoritma. O(2n) : Üstel zaman, Bu tür algoritmalar ekponansiyel (exponential) olarak adlandırılır. Genellikle sadece çok küçük N değerleri dışında pratik olarak kullanılamazlar, çünkü N'e baglı olarak zaman çok hızlı büyür. Bütün olasılıkların denendiği algoritmalar olarak düşünülebilir.

Aşağıdaki tabloda saniyede 10 6 işlem yapabilen bir bilgisayarda çeşitli n değerleri için toplam işlem süresi ve bir karşılaştırma için 1000 n2 'nin alacağı süre verilmiştir.

Çeşitli n değerleri ve farklı fonksiyonlarda saniyede 106 işlem yapan bilgisayarın toplam sürelerini vermektedir.

Zaman karmaşıklığı hesaplamada aşağıdaki kurallar uygulanır: 1. Dizinin boyutuyla ilişkisi olmayan komutlar O(1) zamanı alır. 2. Döngüler O(n) zamanı alır. (n = dizi boyutu)

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)

Çalışma zamanı =NXN=O(N2) 3. İçiçe döngüler zaman karmaşıklıklarının çarpılması şeklinde hesaplanır. Birinci döngü icra sayısı n, iki nci döngü m ise, O(nxm); ikisi de n ise O(n2) zamanı alır. for(i=0; i<N; i++) for(j=1; j<=N; j++) k++; Çalışma zamanı =NXN=O(N2)

Çalışma zamanı =1+[1+(N+1)+N]+(N+N+2N)+1=6N+4 Ardarda döngüler zaman karmaşıklıklarının toplanması şeklinde hesaplanır. int Sum (int N) { int i, Sum; Sum=0; →(1 adet atama işlemi) for(i=1 ;i<=N ; i++) →1 atama , (N+1) karşılaştırma, N toplama Sum+=i*i*i; → N atama+N toplama+2N çarpma return Sum; →1 } Çalışma zamanı =1+[1+(N+1)+N]+(N+N+2N)+1=6N+4

Çalışma zamanı =max_calışma_zamanı(S1,S2) If-then-else gibi şartlı yapılarda iki koşuldan zaman karmaşıklığı yüksek olan alınır If( condition ) S1 Else S2 Çalışma zamanı =max_calışma_zamanı(S1,S2)

Her bir icra, problemi dizi boyutunun yarısı şeklinde ikiye bölüyorsa, zaman karmaşıklığı O(log2n) değerini alır. 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

Sabit çarpanlar karmaşıklığı etkilemez. (O(3n) = O(n)) Katsayısı daha küçük olan zaman karmaşıklıkları ihmal edilebilir. (O(5n+n2) = O(n2) gibi) Sabit çarpanlar karmaşıklığı etkilemez. (O(3n) = O(n))

ÖZET Neden algoritmayı analiz ederiz? Özelliklerinin analizi 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

Özet (devam) Ç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

Analiz Üst limit Algoritmanın gerçek fonksiyonu Alt limit