Karmaşıklık Giriş.

Slides:



Advertisements
Benzer bir sunumlar
Ders İçeriği Ağaç Veri Modeli Tanım ve Gerçekleştirim İkili Ağaç
Advertisements

Unsupervised Learning (Kümeleme)
Karmaşıklık Giriş.
Yinelemeli Algoritma Analizi & Asimptotik Notasyon
Ayrık Yapılar Algoritma Analizi.
MIT503 Veri Yapıları ve algoritmalar
EKRAN ÇIKTISI.
Bilgisayar Mühendisliğine Giriş
4 Kontrol Yapıları: 1.Bölüm.
8. SAYISAL TÜREV ve İNTEGRAL
Algoritmalar DERS 2 Asimptotik Notasyon O-, Ω-, ve Θ-notasyonları
İçerik Ön Tanımlar En Kısa Yol Problemi Yol, Cevrim(çember)
Bölüm 8: EĞRİ UYDURMA Fizikte laboratuarda yapılan deneysel ölçümlerin ne kadar hata payı içerdiğini, veya belli teorik modellere ne kadar uyduğunu bilmek.
BPR152 ALGORİTMA VE PROGRAMLAMA - II
MATEMATİKSEL PROGRAMLAMA
BPR151 ALGORİTMA VE PROGRAMLAMA - I
Birinci Dereceden Denklemler
FONKSİYONLAR ve GRAFİKLER
doğal sayısındaki rakamların sayı değerleri toplamı kaçtır?
Karar ifadeleri ve Döngüler
Algoritmalar DERS 3 Böl ve Fethet(Divide and Conquer) İkili arama
Bölüm 3 – Yapısal Programlama
Çizge Algoritmaları.
BİRİNCİ DERECEDEN BİR BİLİNMEYENLİ DENKLEMLER
Yapısal Program Geliştirme – if, if-else
S OYUT M ODELLER (A BSTRACT M ODELS ) Murat Olcay ÖZCAN Trakya Üniversitesi Bilgisayar Mühendisliği Anabilim Dalı.
While Döngüsü Tekrarlama deyimidir. Bir küme ya da deyim while kullanılarak bir çok kez yinelenebilir. Yinelenmesi için koşul sınaması döngüye girilmeden.
Görsel C# ile Windows Programlama
MIT503 Veri Yapıları ve algoritmalar Veri ağaçları
Bilgisayar Programlama
BPR152 ALGORİTMA VE PROGRAMLAMA - II
TEST – 1.
Bölüm 4: Sayısal İntegral
Algoritmalar (Algoritms)
Celal Bayar Üniversitesi Hasan Ferdi Turgutlu Teknoloji Fakültesi
Bölüm 2 – Kontrol Yapıları
Akış Kontrol Mekanizmaları
Bölüm6:Diferansiyel Denklemler: Başlangıç Değer Problemleri
İKİNCİ DERECEDEN FONKSİYONLAR ve GRAFİKLER
DENKLEMLER. DENKLEMLER ÜNİTE BAŞLIĞI X kimdir neye denir,neden gereksinim duyulmuştur.Bilinmeyeni denklem kurmada kullanırız.Bilinmeyen problemlerde.
FONKSİYONLAR f : A B.
YMT219: Veri Yapıları Ders Saatleri: Pazartesi 9:15-12, 17:30-20:15
Diziler Adres Kavramı Nesnelerin Adresleri sizeof Operatörü
Veri Yapıları ve Algoritmaları ders_1
Yard. Doç. Dr. Mustafa Akkol
C#’TA DÖNGÜLER onbirc.com/133.
EŞANLI DENKLEMLİ MODELLER. Eşanlı denklem sisteminde, Y den X e ve X den Y ye karşılıklı iki yönlü etki vardır. Y ile X arasındaki karşılıklı ilişki nedeniyle.
İKİNCİ DERECEDEN DENKLEMLER
10-14 Şubat Fonksiyonların Grafiği
Lineer Denklem Sistemlerinin
Algoritma Analizi Algoritma Algoritma bir problemi çözmek için izlenen komutlar kümesidir. Verilen bir problemin birden fazla çözümü dolayısıyla.
ALGORİTMA KARMAŞIKLIĞI
BM-103 Programlamaya Giriş Güz 2016 (5. Sunu)
Algoritmalar II Ders 7 Açgözlü Algoritmalar.
Algoritmalar II Ders 4 Dinamik Programlama Yöntemi.
Veri Yapıları ve Algoritmalar
Geçen hafta ne yapmıştık
İleri Algoritma Analizi
Fonksiyonlar Fonksiyonlar, belirli işlemleri yürüten ve sonuçları döndüren bir işlem kümesidir. Genellikle bilgisayar dilinde oluşturulur. Fonksiyonlar,
Diziler.
Fonksiyonlar Fonksiyonlar, belirli işlemleri yürüten ve sonuçları döndüren bir işlem kümesidir. Genellikle bilgisayar dilinde oluşturulur. Fonksiyonlar,
Optimizasyon Teknikleri
Problem Çözme Yaklaşımları
NİŞANTAŞI ÜNİVERSİTESİ
Lineer Denklem Sistemlerinin
NİŞANTAŞI ÜNİVERSİTESİ
NİŞANTAŞI ÜNİVERSİTESİ
..Denklemler..
Bilgisayar Bilimi Problem Çözme Süreci-3.
Introduction to Algorithms (2nd edition)
Sunum transkripti:

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

Bir programın performansı genel olarak programın işletimi için gerekli olan bilgisayar zamanı ve belleğidir. Bir programın zaman karmaşıklığı (time complexity) programın işletim süresidir. Bir programın yer karmaşıklığı (space complexity) programın işletildiği sürece gerekli olan yer miktarıdır. Bir problemin çözümünde, kullanılabilecek olan algoritmalardan en etkin olanı seçilmelidir. En kısa sürede çözüme ulasan veya en az işlem yapan algoritma tercih edilmelidir. Burada bilgisayarın yaptığı iş önemlidir. Bazı durumlarda da en az bellek harcayan algoritmanın tercih edilmesi gerekebilir. Ayrıca, programcının yaptığı is açısından veya algoritmaların anlaşılırlıkları bakımından da algoritmalar karşılaştırılabilir. Daha kısa sürede biten bir algoritma yazmak için daha çok kod yazmak veya daha çok bellek kullanmak gerekebilir (trade-off).

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 gereken yer (bellek alanı) Girdi verisinin büyüklüğü Bilgisayarın hızı Derleyicinin kalitesi Karmaşıklık iç faktörlerle ve daha çok da zamanla ilgilidir.

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

Çalışma Zamanı Analizi Algoritma 2 Çalışma zamanı T(N) Algoritma 1 Giriş verisi N 1000

Çalışma Zamanları Özeti 10 10-2 sec 10-4 sec 100 10-1 sec 1000 1 sec 10000 10 sec 100 sec 100000 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.

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

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

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 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 O(n2) O(n log n) 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) For each function, find the simplest and g(n) such that f_i(n) = O(g(n))

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ü dereceden Ardarda gerçekleştirilen lineer denklemler O(2N) üssel Hanoi’nin Kuleleri problemi

Büyüme Hızları O(N2) O(Nlog N) Zaman N 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? 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ığı)

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

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; } n defa çalışır Sabit zaman Toplam zaman = sabit c * n = cn = O(N)

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++) { for (j=1; j<=n; j++) { k = k+1; } Dış döngü n defa çalışır iç döngü n defa çalışır Sabit zaman Toplam zaman = c * n * n * = cn2 = O(N2)

Kural 3: Ardışık deyimler Her deyimin zamanı birbirine eklenir. Sabit zaman 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; n defa çalışır Sabit zaman iç döngü n defa çalışır Dış döngü Sabit zaman toplam zaman = c0 + c1n + c2n2 = O(N2)

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: sabit if (depth( ) != otherStack.depth( ) ) { return false; } else { for (int n = 0; n < depth( ); n++) { if (!list[n].equals(otherStack.list[n])) then: sabit else: (sabit +sabit) * n Diğer if : sabit+sabit (else yok) Toplam zaman = c0 + c1 + (c2 + c3) * n = O(N)

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

Örnek // Input: int A[N], array of N integers // Output: Sum of all numbers in array A int Sum(int A[], int N) { int s=0; for (int i=0; i< N; i++) s = s + A[i]; return s; } Nasıl analiz edilebilir?

Toplama İşlemi 1 2 3 4 5 6 7 8 1,2,8: Bir defa // Input: int A[N], array of N integers // Output: Sum of all numbers in array A int Sum(int A[], int N { int s=0; for (int i=0; i< N; i++) s = s + A[i]; return s; } 1 2 3 4 1,2,8: Bir defa 3,4,5,6,7: Her iterasyonda 1 defa N iterasyonlu işlemde Toplam: 5N + 3 Karmaşıklık: f(N) = 5N +3 5 6 7 8

5N+3 Nasıl Etkiler? Farklı N değerlerine göre işlem adımlarına bakalım: N = 10 => 53 steps N = 100 => 503 steps N = 1,000 => 5003 steps N = 1,000,000 => 5,000,003 steps N büyüdükçe lineer bir yükselme göstermektedir.

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

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 Peki while-döngüsü? bool done = false; int result = 1, n; cin>>n; while (!done){ result = result *n; n--; if (n <= 1) done = true; } Döngüden çıkıldığında done == true, N iterasyon Gerçekleşmiş olmaktadır.. Toplam zaman: O(N)

Birden fazla ifade Birden fazla birbirinden bağımsız ifade öbekleri varsa Karmaşıklık ifadelerin zamanlarının toplamıdır. for (j=0; j < N; j++) for (k =0; k < j; k++) sum = sum + j*k; for (l=0; l < N; l++) sum = sum -l; cout<<“Sum is now”<<sum; O(N2) O(N) O(1) Toplam zaman O(N2) + O(N) +O(1) = O(N2)

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

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) 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), T(N)’in asimtotik alt limiti olarak adlandırılır. f(n) c g(n) We use O-notation to give an upper bound of a function, to within a constant factor. n0

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

Resursive-Yinelemeli fonk. Aşağıdaki ifade: yinelemeli bir fonksiyondur.

Yineleme çözme metodları Iterasyon Metodu Recursion Ağacı metodu Master Teorem

İterasyon Yöntemi Yineleme işlemini açık hale getir Matematiksel işlemlerle göster Toplamı hesapla.

s(n) = n + s(n-1) = n + n-1 + s(n-2) = n + n-1 + n-2 + s(n-3) = n + n-1 + n-2 + n-3 + s(n-4) = … =n + n-1 + n-2 + n-3 + … + n-(k-1) + s(n-k)

So far for n >= k we have What if k = n? Thus in general

Iteration Method – Örnek 2 T(n) = n + 2T(n/2) = n + 2(n/2 + 2T(n/4)) = n + n + 4T(n/4) = n + n + 4(n/4 + 2T(n/8)) = n + n + n + 8T(n/8) … = in + 2iT(n/2i) = kn + 2kT(1) = nlgn + nT(1) = Θ(nlgn) T(n/2) = n/2 + 2T(n/4) Kabul: n = 2k

Master Teorem f (n) = O(nlogba – e) şartı e > 0 için sağlanıyorsa. f (n) ile nlogba karşılaştırma: f (n) = O(nlogba – e) şartı e > 0 için sağlanıyorsa. f (n) polinomik olarak büyüyordur. Çözüm: T(n) = Q(nlogba) .

Master teorem f (n) ile nlogba karşılaştırma: f (n) = Q(nlogba lgkn) bir k ³ 0 sabitini sağlıyorsa. f (n) ve nlogba eşit oranda büyüyordur. Çözüm: T(n) = Q(nlogba lgk+1n) .

Master teorem f (n) = W(nlogba + e) ifadesi e > 0 sabiti sağlıyorsa f (n) ile nlogba karşılaştırma: f (n) = W(nlogba + e) ifadesi e > 0 sabiti sağlıyorsa f (n) çok hızlı büyüyordur. Nlogba e göre. ve f (n) düzenlilik şartını a f (n/b) £ c f (n) c < 1gibi bir c değeri için sağlarsa. Çözüm: T(n) = Q( f (n) ) .

Örnekler Ex. T(n) = 4T(n/2) + n a = 4, b = 2  nlogba = n2; f (n) = n. CASE 1: f (n) = O(n2 – e) için e = 1.  T(n) = Q(n2). Ex. T(n) = 4T(n/2) + n2 a = 4, b = 2  nlogba = n2; f (n) = n2. CASE 2: f (n) = Q(n2lg0n), ise, k = 0.  T(n) = Q(n2lg n).

Örnekler Ex. T(n) = 4T(n/2) + n3 a = 4, b = 2  nlogba = n2; f (n) = n3. CASE 3: f (n) = W(n2 + e) için e = 1 ve 4(cn/2)3 £ cn3 (reg. cond.) için c = 1/2.  T(n) = Q(n3). a f (n/b) £ c f (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ı 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.