Algoritmalar: Tanım, Tipler ve Tasarım Paradigmalari

ALGORİTMALAR
Algoritmalar, problemleri çözmek için adım adım prosedürlerdir.
ALGORİTMA
NEDİR?
Algoritma, bir
mekanik kural veya
otomatik metot veya
bazı matematiksel işlemlerin
düzenlenmesi için programdır.
Algoritma, açık olarak tanımlanmış olan ve herhangi bir bilgisayarda
icra edilen bir prosedürdür.
ALGORİTMA TİPLERİ
• ALGORİTMALARI;
➢ KULLANIM AMAÇLARI,
➢ DİZAYN PARADİGMALARI,
➢ UYGULAMA ALANLARI VE
➢ KARMAŞIKLIKLARI GİBİ PEK ÇOK AÇIDAN SINIFLANDIRMAK MÜMKÜNDÜR.
ÖZYINELEMELI
(RECURSIVE)
VEYA DÖNGÜLÜ
(ITERATIVE)
ALGORITMALAR
• ÖZYİNELEMELİ VE DÖNGÜLÜ ALGORİTMALARIN HER İKİSİ
DE TEKRARLI BİR YAPIYA SAHİPTİR.
• ÖZYİNELEMELİ ALGORİTMALAR, BELİRLİ BİR KOŞUL
GERÇEKLEŞENE KADAR SÜREKLİ OLARAK KENDİSİNİ
ÇAĞIRMAKTADIRLAR.
• BAŞKA BİR İFADEYLE ALGORİTMANIN İÇERİSİNDE
KENDİNDEN BİR PARÇA YER ALIYORSA ÖZYİNELEMELİ
OLARAK NİTELENDİRİLİR.
ÖZYINELEMELI
(RECURSIVE)
VEYA DÖNGÜLÜ
(ITERATIVE)
ALGORITMALAR
Öte yandan algoritma kendisinden
bir parça içermeden tekrarlıyorsa
döngülü algoritma olarak
isimlendirilir.
Teorik olarak tüm özyinelemeli
algoritmaları döngülü olarak
yazmak mümkündür.
Bu durumun tersi de geçerlidir yani
tüm döngülü algoritmaları
özyinelemeli olarak yazmakta
mümkündür.
• PROSEDÜREL VEYA EMİRLİ ALGORİTMALAR OLARAK TA
BİLİNMEKTEDİR.
PROSEDÜREL
(PROCEDURAL)
VEYA
TANIMLAMALI
(DECLARATIVE)
ALGORITMALAR
• BU YAKLAŞIMDA PROGRAMI MEYDANA GETİREN
KOMUTLARIN ADIM ADIM EMİRLER ŞEKLİNDE
TANIMLANMASI GEREKİR.
• TANIMLAMALI ALGORİTMALAR İSE BUNUN AKSİNE
HESAPLAMANIN NASIL YAPILACAĞINDAN ZİYADE NEYİN
HESAPLANMASI GEREKTİĞİNE ODAKLANIR.
• HER İKİ YAKLAŞIM BİR KEK TARİFİ ÖRNEĞİ ŞU ŞEKİLDE
AÇIKLANABİLİR:
• EMİRLİ ALGORİTMALAR
• 1 BARDAK UN KOY
PROSEDÜREL
(PROCEDURAL)
VEYA
TANIMLAMALI
(DECLARATIVE)
ALGORITMALAR
• 1 BARDAK ŞEKER EKLE
• 1 ADET YUMURTA EKLE
• HEPSİNİ KARIŞTIR
• KARIŞIMI TEPSİYE DÖK
• FIRINI 15 DAKİKA 200 C’YE AYARLA
• TEPSİYİ FIRINA KOY
• TANIMLAMALI ALGORİTMALAR
PROSEDÜREL
(PROCEDURAL)
VEYA
TANIMLAMALI
(DECLARATIVE)
ALGORITMALAR
• 1 BARDAK UN, 1 BARDAK ŞEKER, 1 YUMURTA (BAŞLANGIÇ
DURUMU)
• KURALLAR
• HER ŞEY KARIŞMIŞSA TEPSİYE KOY
• HER ŞEY KARIŞMAMIŞSA KASEYE KOY
• HER ŞEY TEPSİDEYSE FIRINA KOY
PROSEDÜREL
(PROCEDURAL)
VEYA
TANIMLAMALI
(DECLARATIVE)
ALGORITMALAR
• YUKARIDAKİ ÖRNEKTE DE GÖRÜLDÜĞÜ GİBİ;
• EMİRLİ ALGORİTMALAR İŞLEMLERİN NASIL YAPILMASI
GEREKTİĞİNE ODAKLANIRKEN,
• TANIMLAMALI ALGORİTMALAR İSE NEYİN YAPILMASI
GEREKTİĞİNE ODAKLANIRLAR.
Algoritmalar tasarlanırken genellikle bilgisayarların ilgili
algoritmanın aynı anda tek bir komutu icra ettiği varsayımı ile
geliştirilirler.
SERI VEYA
PARALEL
ALGORITMALAR
Bu tip algoritmalar seri algoritmalar olarak tanımlanır.
Paralel algoritmalar ise bunun aksine gelişen bilgisayar
mimarisinin sağladığı çoklu çekirdek ve iplik (thread) avantajını
dikkate alarak aynı anda birden fazla komut icra ederler.
Bu yaklaşımda sorun alt problemlere bölünerek her birinin
ayrı ayrı çalışması sağlanır.
BELIRLI
(DETERMINISTIC)
VEYA BELIRSIZ
(NONDETERMINISTIC)
ALGORITMALAR
• BELİRLİ ALGORİTMALAR PROBLEMİ ÖNCEDEN
TANIMLANMIŞ BİR SÜREÇLE ÇÖZER,
• BELİRSİZ ALGORİTMALAR İSE SEZGİSEL YAKLAŞIMLAR
KULLANILMASI NEDENİYLE HER ADIMDA EN İYİ ÇÖZÜM
TAHMİNLERİNİ YAPMAYA ODAKLANIR.
BELIRLI
(DETERMINISTIC)
VEYA BELIRSIZ
(NONDETERMINISTIC)
ALGORITMALAR
Belirli algoritmalarda, belirli
bir girdi için, bilgisayar her
zaman aynı durumlardan
geçerek aynı çıkışı
üretecektir.
Ancak belirsiz
algoritmalarda, aynı girdi
için, derleyici farklı
işlemlerde farklı çıktılar
üretebilir.
Belirsiz algoritmalar, aynı
uygulama için her bir
çalıştırmada farklı
davranışlar gösterebilir ve
bunun için bir dereceye
kadar rastlantısallık vardır.
Dolayısıyla belirsiz
algoritmalar problemi
polinom zaman içerisinde
çözemediği gibi bir sonraki
adımın ne olduğunu da
belirleyemez.
• DOĞRUSAL PROGRAMLAMA
• BÖL VE FETHET (DIVIDE AND CONQUER) ALGORITMASI
• AÇGÖZLÜ (GREEDY) ALGORITMA
DİZAYN
PARADİGMALARI
AÇISINDAN
ALGORİTMALARIN
SINIFLANDIRILMASI
• DINAMIK PROGRAMLAMA
• GERI İZLEME (BACKTRACKING) ALGORITMASI
• DALLANMA VE SINIRLANDIRMA (BRANCH AND
BOUNDING) YAKLAŞIMI
• GRAPH ALGORITMALARI
• OLASILIKSAL (PROBABILISTIC) VE SEZGİSEL (HEURİSTİC)
ALGORİTMALAR
DOĞRUSAL PROGRAMLAMA
• DOĞRUSAL OPTİMİZASYON OLARAK DA BİLİNEN DOĞRUSAL PROGRAMLAMA, KARMAŞIK
İLİŞKİLERİN DOĞRUSAL FONKSİYONLAR İLE İFADE EDİLEREK GİRDİLERİN MAKSİMİZE VEYA
MİNİMİZE EDİLMEYE ÇALIŞILDIĞI BİR YAKLAŞIMDIR.
• BİLGİSAYAR MODELLEME VEYA SİMÜLASYONUNDA MAKİNE KAYNAKLARI, PARA, ENERJİ, İNSAN
GÜCÜ, MEKAN VE ZAMAN GİBİ SONLU KAYNAĞA SAHİP BİRÇOK DEĞİŞKENİ TAHSİS ETMEDE
EN İYİ ÇÖZÜMÜ BULMAK İÇİN EN SIK KULLANILAN YÖNTEMLERDEN BİR TANESİDİR.
• BİRÇOK DURUMDA, DOĞRUSAL PROGRAMLAMANIN SAĞLAMAYA ÇALIŞTIĞI EN İYİ SONUÇ
MAKSİMUM KAR VEYA EN DÜŞÜK MALİYETTİR.
BÖL VE FETHET (DIVIDE AND CONQUER)
ALGORITMASI
• BÖL VE FETHET ALGORİTMALARI BİR PROBLEMİ;
➢ AYNI TİPTE DAHA KOLAY ÇÖZÜLEBİLECEK KÜÇÜK ALT PROBLEMLERE BÖLEREK
➢ HER BİR PARÇAYI AYRI AYRI ÇÖZMEYİ VE
➢ SONRASINDA DA ELDE EDİLEN ÇÖZÜMLERİ BİRLEŞTİREREK NİHAİ SONUCU BULMAYI HEDEFLER.
BÖL VE FETHET (DIVIDE AND CONQUER)
ALGORITMASI
• BU ALGORİTMAYI ÜÇ TEMEL ADIMDAN OLUŞACAK BİÇİMDE ŞU ŞEKİLDE ÖZETLEMEK
MÜMKÜNDÜR:
1.
BÖL: PROBLEMİ AYNI TİPTE DAHA KÜÇÜK ALT PARÇALARA AYIR
2.
FETHET: HER BİR ALT PROBLEMİ YİNELEMELİ ŞEKİLDE ÇÖZ
3.
BİRLEŞTİR: ELDE EDİLEN SONUÇLARI UYGUN ŞEKİLDE BİRLEŞTİR.
AÇGÖZLÜ (GREEDY) ALGORITMA
• AÇGÖZLÜ ALGORİTMALAR PARÇA PARÇA ÇÖZÜM OLUŞTURAN BİR YÖNTEMDİR.
• SEÇİLECEK BİR SONRAKİ PARÇA İÇİN HER ZAMAN EN AÇIK VE EN YAKIN KATKIYI SAĞLAYAN
PARÇAYI KULLANIR.
• YEREL OPTİMUMLARI KULLANMANIN GLOBAL SONUCA KATKI SAĞLADIĞI PROBLEMLER İÇİN
İDEALDİR.
• FAKAT YEREL OPTİMUMLARI KULLANMAK HER ZAMAN EN DOĞRU SONUCU BULMAYI GARANTİ
ETMEZ.
DINAMIK PROGRAMLAMA
• DİNAMİK PROGRAMLAMA BÖL VE FETHET YÖNTEMİNE OLDUKÇA BENZEMEKTEDİR.
• BU YAKLAŞIMDA DA PROBLEMLER KÜÇÜK ALT PARÇALARA BÖLÜNÜR VE HER BİR PARÇANIN
ÇÖZÜMÜ ELDE EDİLİR.
• FAKAT BÖL VE FETHET ALGORİTMASINDAN FARKLI OLARAK HAFIZA TABANLI BİR VERİ YAPISI
KULLANILARAK HER BİR ÇÖZÜMÜN SONUCU SAKLANIR.
• İLERLEYEN SEFERLERE AYNI ALT PROBLEMİN ORTAYA ÇIKMASI DURUMUNDA PROBLEMİ TEKRAR
ÇÖZMEDEN HAFIZADAKİ SONUCU KULLANIR.
• BÖYLELİKLE PROBLEMİN ÇÖZÜM SÜRESİNİN KISALTILMASI HEDEFLENİR.
GERI İZLEME (BACKTRACKING) ALGORITMASI
• GERİ İZLEME ALGORİTMA YAKLAŞIMINDA OLASI BİR NOKTADAN BAŞLANARAK ÇÖZÜM İÇİN
YOLLAR ARANIR.
• EĞER BİR NOKTADA PROBLEM İÇİN VERİLEN KISITLAR SAĞLANMIYORSA BU NOKTADAN GERİ
DÖNÜLEREK ÇÖZÜM İÇİN BAŞKA YOLLAR ARANMAKTADIR.
• BAŞKA BİR DEYİŞLE,
➢ ART ARDA, HER SEFERİNDE BİR PARÇA OLUŞTURARAK,
➢ SORUNUN SINIRLAMALARINI HERHANGİ BİR ZAMANDA YERİNE GETİREMEYEN ÇÖZÜMLERİ BULUR VE
➢ BUNLARI KALDIRARAK NİHAİ ÇÖZÜME OLUŞMAYI AMAÇLAR.
GERI İZLEME (BACKTRACKING) ALGORITMASI
• BU ALGORİTMA TİPİ İÇİN SUDOKU PROBLEMİNİN ÇÖZÜMÜ ÖRNEK OLARAK VERİLEBİLİR.
• SUDOKU PROBLEMİNDE TEK TEK SAYILAR DENENEREK ÇÖZÜMÜ SAĞLAYIP SAĞLAMADIĞI
KONTROL EDİLİR.
• EĞER KULLANILAN SAYI BİR NOKTADA ÇÖZÜMÜ SAĞLAYAMAZSA BURADAN GERİ DÖNÜLEREK
DİĞER SAYILAR KULLANILARAK ÇÖZÜME ULAŞILIR.
DALLANMA VE SINIRLANDIRMA (BRANCH AND
BOUNDING) YAKLAŞIMI
• DALLANMA VE SINIRLANDIRMA YAKLAŞIMI GENELLİKLE KOMBİNASYONAL OPTİMİZASYON
PROBLEMLERİNİ ÇÖZMEK İÇİN KULLANILAN BİR ALGORİTMA TASARIM PARADİGMASIDIR.
• KOMBİNASYONAL OPTİMİZASYON PROBLEMLERİ, ZAMAN KARMAŞIKLIĞI AÇISINDAN TİPİK
OLARAK ÜSTELDİR VE EN KÖTÜ DURUMDA TÜM OLASI ÇÖZÜMLERİN DENENMESİNİ
GEREKTİREBİLİR.
• DAL VE SINIR ALGORİTMASI TEKNİĞİ BU PROBLEMLERİ NİSPETEN HIZLI BİR ŞEKİLDE
ÇÖZÜLMESİNE OLANAK SAĞLAR.
DALLANMA VE SINIRLANDIRMA (BRANCH AND
BOUNDING) YAKLAŞIMI
• DALLANMA VE SINIRLANDIRMA YAKLAŞIMINDA, TÜM ADAY ÇÖZÜMLER SİSTEMATİK OLARAK
SIRALANIR.
• SONRASINDA BU ADAY ÇÖZÜMLERDEN AÇIKÇA İMKANSIZ OLAN ÇÖZÜMLER ELDEN
ÇIKARTILARAK ARAMA İŞLEMİNİN DAHA HIZLI BİR ŞEKİLDE GERÇEKLEŞTİRİLMESİ SAĞLANIR.
• BU ALGORİTMİK YAKLAŞIM GENELLİKLE TÜM OLASI ÇÖZÜMLERİN BİR SEÇENEK DİZİSİ ŞEKLİNDE
GÖSTERİLEBİLECEĞİ SONLU PROBLEMLER İÇİN UYGULANIR.
Graph Algoritmaları
• GRAPHLAR SONLU SAYIDA DÜĞÜM VE BU DÜĞÜMLERİ BİRBİRİNE BAĞLAYAN KENARLARDAN
OLUŞUR
• PEK ÇOK GERÇEK DÜNYA PROBLEMİNİN ÇÖZÜMÜ İÇİN OLDUKÇA UYGUN BİR YAPIYA
SAHİPTİR.
• ÖZELLİKLE AĞ BENZERİ YAPILARI TEMSİL ETMEK İÇİN OLDUKÇA İDEALDİR.
GRAPH ALGORITMALARI
• BURADAKİ AĞ KAVRAMI İNTERNET ŞEBEKESİNDEKİ ROUTERLAR VE BUNLAR ARASINDAKİ
BAĞLANTILAR OLABİLECEĞİ GİBİ
• ŞEHİRLER ARASINDAKİ YOLLAR,
• TELEFON ŞEBEKESİ VE ELEKTRİK ŞEBEKESİ GİBİ BİRÇOK BENZER YAPI OLABİLİR.
• BUNLARIN YANI SIRA FACEBOOK VE TWİTTER GİBİ SOSYAL MEDYA PLATFORMLARI DA AĞ
YAPILARINA İYİ BİRER ÖRNEKTİR.
• GRAPHLAR DİĞER DERSLERDE DAHA DETAYLI BİR ŞEKİLDE ELE ALINACAKTIR
OLASILIKSAL (PROBABILISTIC) VE SEZGİSEL
(HEURİSTİC) ALGORİTMALAR
• BU BÖLÜMDE ALGORİTMALARI FARKLI ALT BAŞLIKLARA AYIRMAK MÜMKÜNDÜR. BURADA 3
TEMEL ALT BAŞLIK ALTINDA DEĞERLENDİRME YAPILACAK.
OLASILIKSAL (PROBABILISTIC) VE SEZGİSEL
(HEURİSTİC) ALGORİTMALAR
1.
OLASILIKSAL ALGORİTMALAR BELİRSİZ (NON-DETERMİNİSTİC) ALGORİTMALARDIR.
• HERHANGİ BİR NOKTADA NE YAPILACAĞINA KARAR VERMEK İÇİN RASGELE SEÇİMLER YAPARAK
HAREKET EDERLER.
• BU ALGORİTMALAR TEMELDE STANDART ALGORİTMALARA KIYASLA UZAY VE ZAMAN
KARMAŞIKLIĞINI AZALTMAYI HEDEFLERLER
OLASILIKSAL (PROBABILISTIC) VE SEZGİSEL
(HEURİSTİC) ALGORİTMALAR
2. GENETİK ALGORİTMALAR DOĞAL SELEKSİYON FİKRİNDEN HAREKETLE TÜRETİLMİŞ UYARLAMALI SEZGİSEL
ALGORİTMALARDIR.
• BU ALGORİTMALAR DOĞAL SELEKSİYON SÜRECİNİ SİMÜLE EDERLER.
• DOLAYISIYLA ORTAMLARINDAKİ DEĞİŞİKLİKLERE UYUM SAĞLAYABİLEN TÜRLERİN HAYATTA KALABİLECEKLERİ,
ÇOĞALABİLECEKLERİ VE GELECEK NESİLLERE AKTARILABİLECEKLERİ ANLAMINA GELİR.
• BASİT BİR DEYİŞLE, BİR PROBLEMİ ÇÖZMEK İÇİN ARDIŞIK NESİLLER ARASINDA EN GÜÇLÜLERİN HAYATTA KALMASI
FİKRİNİ TEMSİL EDERLER.
• HER NESİL, BİR BİREY POPÜLASYONUNDAN MEYDANA GELİR. HER BİREYDE ARAMA ALANINDA VE OLASI
ÇÖZÜMDE BİR NOKTAYI TEMSİL EDER.
OLASILIKSAL (PROBABILISTIC) VE SEZGİSEL
(HEURİSTİC) ALGORİTMALAR
3. SEZGİSEL ALGORİTMALAR KAYNAKLAR VE ZAMAN DİKKATE ALINDIĞINDA OPTİMAL ÇÖZÜMÜ
BULMANIN PRATİK OLMADIĞI DURUMLAR İÇİN TERCİH EDİLEN ALGORİTMALARDIR.
• BURADA AMAÇ KESİN SONUCU BULMAK DEĞİL YAKLAŞIK OLARAK EN İYİ DEĞERİ ELDE
ETMEKTİR.
ALGORİTMALARIN KARMAŞIKLIĞI
• BİR ALGORİTMANIN KARMAŞIKLIĞI, BU ALGORİTMANIN ÇALIŞMA ZAMANI İLE İLGİLİ BİR
KAVRAMDIR.
• BİR ALGORİTMANIN ÇALIŞMA ZAMANI OLARAK DA İSİMLENDİRİLEN ALGORİTMANIN
GEREKSİNİMİ OLAN ZAMAN, VERİNİN HEM YAPISINA HEM DE BOYUTUNA BAĞLIDIR.
ALGORİTMALARIN KARMAŞIKLIĞI
• BÜYÜK PROBLEMLER ÇOK DAHA FAZLA ÇÖZÜM ZAMANI GEREKTİRİRKEN;
➢ VERİDEKİ FARKLILIKLARA BAĞLI OLARAK AYNI BOYUTTAKİ DEĞİŞİK PROBLEMLER BELİRGİN OLARAK
FARKLI ÇÖZÜM ZAMANLARI GEREKTİRİRLER.
• BİR ALGORİTMANIN KARMAŞIKLIK FONKSİYONU;
➢ PROBLEM UZAYI BOYUTUNUN BİR FONKSİYONUDUR VE
➢ VERİLEN BOYUTUN ZAMANININ HERHANGİ BİR PROBLEM ÖRNEĞİNİ ÇÖZMEK İÇİN ALGORİTMA
TARAFINDAN İHTİYAÇ DUYULAN EN GENİŞ ZAMANI BELİRTİR.
• BİR BAŞKA DEYİŞLE, ZAMAN KARMAŞIKLIĞI FONKSİYONU, PROBLEMİN BOYUTU ARTTIKÇA
ÇÖZÜM ZAMANININ GELİŞME HIZINI ÖLÇER.
ALGORİTMALARIN KARMAŞIKLIĞI
• BURADA DİKKAT EDİLMESİ GEREKEN KONU, ZAMAN KARMAŞIKLIĞI FONKSİYONUNUN, VERİLEN
BİR PROBLEM UZAYI BOYUTUNDA HERHANGİ BİR PROBLEM ÖRNEĞİNİ ÇÖZMEK İÇİN GEREKEN
ÇALIŞMA ZAMANINI, ÇÖZÜM İÇİN GEREKLİ EN BÜYÜK ÇALIŞMA ZAMANINI ÖLÇEREK
HESAPLADIĞIDIR.
• KARMAŞIKLIK FONKSİYONU, ALGORİTMANIN PERFORMANSININ ÖLÇÜMÜNDE, PROBLEMİN
GİRİŞ VERİSİNİN UYGUN ÖLÇÜLMESİNE BAĞLI OLARAK BİR PERFORMANS GARANTİSİ SAĞLAR.
ALGORİTMALARIN KARMAŞIKLIĞI
• BİR ALGORİTMANIN ETKİNLİĞİ;
➢ EN KÖTÜ DURUMDA ALGORİTMA İÇİN GEREKEN ADIMLARIN SAYISINI SAYARAK VE
➢ BUNU PROBLEM UZAYI BOYUTU OLAN N’NİN BİR FONKSİYONU OLARAK,
➢ N BÜYÜDÜKÇE ÇALIŞMA ZAMANININ DAVRANIŞINI SAPTAMAKTIR.
1.
ALGORİTMALARIN
KARMAŞIKLIĞI İÇİN
KULLANILAN
TERMİNOLOJİ VE
İŞLEM ZAMANI
Karmaşıklık
1.
Terminoloji
O(1)
Sabit Karmaşıklık
O(log n)
Logaritmik Karmaşıklık
O(n)
Lineer Karmaşıklık
O(n logn)
nlogn
O(nb)
Polinom Karmaşıklık
O(bn), b>1
Üstel Karmaşıklık
O(n!)
Faktöriyel Karmaşıklık
Algoritmaların zaman karmaşıklığının tanımında kullanılan terminoloji.
ALGORİTMALARIN KARMAŞIKLIĞI İÇİN
KULLANILAN TERMİNOLOJİ VE İŞLEM ZAMANI
Problem
Uzunluğu
Kullanılan bit işlem
n
logn
n
nlogn
n2
2n
n!
10
3x10-9
10-8
3x10-8
10-7 s
10-6
3x10-3s
102
7x10-9
10-7
7x10-7
10-5 s
4x1013yıl
*
103
1x10-8
10-6
1x10-5
10-3 s
*
*
104
1.3x10-8
10-5
1x10-4
10-1 s
*
*
105
1.7x10-8
10-4
2x10-3
10 s
*
*
106
2x10-8
10-3
2x10-2
17 dakika
*
*
Tablo bit işlem sayısını göstermektedir. 10100 yıldan büyük zamanlar asterisk (*) ile
gösterilmiştir. Bu tablo yapılırken her bit işlemi 10-9 saniye alınmıştır.
ALGORİTMALARIN KARMAŞIKLIĞI İÇİN
KULLANILAN TERMİNOLOJİ VE İŞLEM ZAMANI
Problem uzayının boyutu n’ye göre bir
algoritmayı gerçekleştirmede f(n) hesaplama
adımlarının sayısı.
“O”, “”, “” Sembolleri
ALGORİTMALARIN
KARMAŞIKLIĞI İÇİN
KULLANILAN
TERMİNOLOJİ VE
İŞLEM ZAMANI
“O”: sembolü algoritmanın performansı üzerinde bir üst sınırı belirtir.
Problem uzayı boyutu olan n’nin yeterince büyük değerleri için algoritmanın
çalışma zamanında bir üst sınır belirlendiğinde O(f(n)) karmaşıklık ölçümü
çalışma zamanının asimptotik bir büyüme oranına sahip olmasına yol açar.
“” : sembolü, algoritmanın çalışma zamanı üzerinde bir alt sınırı belirtir
“” : sembolü bir algoritmanın performansı üzerinde hem alt hem de üst
sınırı belirtir
DİZİ = [41, 9, 8, 17, 5, 1, 23, 44, 7, 12, 27]
SONLU BİR
DİZİDEKİ
MAKSİMUM
ELEMANI
BULAN
ALGORİTMA
(MATLAB)
MAKSİMUM = DİZİ[0]
FOR İ İN RANGE(1,LEN(DİZİ)):
İF MAKSİMUM < DİZİ[İ] :
MAKSİMUM = DİZİ[İ]
PRİNT(MAKSİMUM)
DIZI = [41, 9, 8, 17, 5, 1, 23, 44, 7, 12, 27];
SONLU BİR
DİZİDEKİ
MAKSİMUM
ELEMANI
BULAN
ALGORİTMA
(MATLAB)
MAKSİMUM = DİZİ(1);
FOR İ=2 : LENGTH(DİZİ)
İF MAKSİMUM < DİZİ(İ)
MAKSİMUM = DİZİ(İ);
END
END
MAKSİMUM
ARAMA ALGORİTMALARI VE PERFORMANS
ANALİZİ
• BİLGİSAYAR TEKNOLOJİSİ VE İNTERNET AĞLARININ GEÇTİĞİMİZ ON YILLIK SÜRE ZARFINDA
MUAZZAM BİR BÜYÜME KAYDETMESİ, ÜRETİLEN BİLGİ MİKTARININ DA HATIRI SAYILIR BİR
BİÇİMDE ARTMASINA NEDEN OLDU.
• BUNUN YANISIRA MOBİL AYGITLAR VE NESNELERİN İNTERNETİ GİBİ KAVRAMLARINDA HER
GEÇEN GÜN HAYATIMIZDA DAHA FAZLA YER ALMAYA BAŞLAMASIYLA BİRLİKTE ÜRETİLEN VERİ
MİKTARI ÇOK YÜKSEK DEĞERLERE ULAŞTI.
ARAMA ALGORİTMALARI VE PERFORMANS
ANALİZİ
• FORBES DERGİSİNİN MAYIS, 2018 TARİHLİ BİR HABERİNE GÖRE DÜNYADA HER GÜN YAKLAŞIK
OLARAK 2.5 KENTİLYON BYTE (1 KENTİLYON = 1018 ) VERİ ÜRETİLMEKTE.
• BU DEĞERİN 2.500.000 TERABYTE KARŞILIK GELDİĞİ DÜŞÜNÜLDÜĞÜNDE ÜRETİLEN VERİNİN NE
KADAR BÜYÜK OLDUĞU DAHA İYİ ANLAŞILMAKTADIR.
ARAMA ALGORİTMALARI VE PERFORMANS
ANALİZİ
• BİLGİYİ İŞLEYEBİLMENİN EN TEMEL ADIMLARINDAN BİR TANESİDE BU BİLGİYİ ARAMA
YETENEĞİDİR.
• ÜRETİLEN MUAZZAM BÜYÜKLÜKTEKİ VERİNİN ARASINDAN İSTEDİĞİMİZ BİLGİYİ KISA SÜREDE
BULABİLMEK OLDUKÇA ÖNEMLİ BİR KABİLİYETTİR.
• BİR ARAMA MOTURUNDA ARAMA YAPMAK VEYA CEP TELEFONUNUMUZUN REHBERİNDEN BİR
KİŞİNİN İSMİNİ BULMAK HEPİMİZİN GÜNLÜK HAYATTA GERÇEKLEŞTİRDİĞİ ARAMA
FAALİYETLERİNDEN BİR KAÇIDIR.
ARAMA ALGORİTMALARI VE PERFORMANS
ANALİZİ
• BU BÖLÜMDE UZUN YILLARDIR KULLANILMAKTA OLAN ÇEŞİTLİ KLASİK ARAMA ALGORİTMALARI
TANITILACAKTIR.
• AYRICA ÇOK BÜYÜK BİR VERİ UZAYINDA ARAMA YAPARKEN ALGORİTMANIN HIZLI ÇALIŞMASI
KRİTİK KONULARDAN BİR TANESİDİR.
• BU DOĞRULTUDA ALGORİTMALARIN PERFORMANS ANALİZLERİ YANİ ZAMAN KARMAŞIKLIĞI
HESAPLARININ DA BİR KIYASLAMASI VERİLECEKTİR.
LİNEER ARAMA ALGORİTMASI
• LİNEER ARAMA ALGORİTMASI HERKESİN GÜNLÜK HAYATTA DA KULLANDIĞI EN BASİT ARAMA
ALGORİTMALARINDAN BİR TANESİDİR.
• VERİLEN BİR DİZİNİN İLK ELEMANINDAN BAŞLAYARAK DİZİNİN SON ELEMANINA KADAR TÜM
DEĞERLERİN KARŞILAŞTIRILMASI ESASINA DAYANIR.
• EĞER ARANAN DEĞER DİZİDE BULUNMUŞSA BULUNDUĞU KONUMUN İNDİSİ DEĞER OLARAK
DÖNDÜRÜLÜR.
• AKSİ DURUMDA “ELEMAN BULUNAMADI MESAJI DÖNDÜRÜLECEKTİR.
LİNEER ARAMA ALGORİTMASI
__NAME__ = "LİNEER_ARAMA"
DEF LİNEER_ARAMA(ARANANDEGER, DİZİ):
İ=0
WHİLE(İ<LEN(DİZİ) AND ARANANDEGER != DİZİ[İ] ):
LİNEER
ARAMA
ALGORİTMASI
(PYTHON)
İ +=1
İF İ<LEN(DİZİ):
PRİNT('ELEMANIN KONUMU :', İ )
ELSE:
PRİNT('ARANAN ELEMAN BULUNAMADI')
DEF MAİN():
DİZİ = [41, 9, 8, 17, 5, 1, 23, 44, 7, 12, 27]
ARANANDEGER = 27
LİNEER_ARAMA(ARANANDEGER,DİZİ)
İF __NAME__ == "LİNEER_ARAMA":
MAİN()
LİNEER ARAMA ALGORİTMASI (MATLAB)
FUNCTİON LİNEER_ARAMA(ARANANDEGER, DİZİ)
İ=1;
WHİLE(İ<=LENGTH(DİZİ) && ARANANDEGER ~= DİZİ(İ))
İ =İ+1;
END
İF İ <= LENGTH(DİZİ)
FPRİNTF('ELEMANÝN KONUMU :%İ\N', İ)
ELSE
FPRİNTF('ARANAN ELEMAN BULUNAMADÝ\N')
END
END
>> dizi = [41, 9, 8, 17, 5, 1, 23, 44, 7, 12, 27];
>> lineer_arama(27,dizi)
LİNEER ARAMA ALGORİTMASI
• ZAMAN KARMAŞIKLIĞININ ÖLÇÜMÜ KARŞILAŞTIRMA SAYISI KULLANILARAK YAPILACAKTIR.
• ALGORİTMADA ÇEVRİMİN HER ADIMINDA, İKİ KARŞILAŞTIRMA YAPILACAKTIR.
• BİRİNCİDE LİSTENİN SONUNA GELİNDİĞİNDE VE LİSTENİN BİRİNCİ TERİMİYLE X ELEMANI
KARŞILAŞTIRILACAKTIR.
• SONUÇTA BİR DAHAKİ KARŞILAŞTIRMADA ÇEVRİMDEN ÇIKILIR.
LİNEER ARAMA ALGORİTMASI
• DOLAYISIYLA, EĞER X= Aİ, 2İ+1 KARŞILAŞTIRMASI KULLANILDI.
• EN ÇOK KARŞILAŞTIRMA 2N, LİSTEDEKİ OLMAYAN ELEMAN OLDUĞU ZAMANDIR.
• BU BÖLÜMDE 2N KARŞILAŞTIRMASI X HESABINDA KULLANILDIYSA Aİ DEĞİLDİR VE SONRAKİ
KARŞILAŞTIRMALARDA ÇEVRİMDEN ÇIKILIR.
• X LİSTEDE DEĞİLSE 2N+2 KARŞILAŞTIRMALARI TOPLAMI KULLANILIR.
• BÖYLECE O(N) KARŞILAŞTIRMALARI.
• BİR LİNEER SEÇİM OLMUŞTUR.
• BU KARMAŞIKLIK ANALİZİ EN KÖTÜ DURUM ANALİZİDİR.
• BU ANALİZ BİZE BİR ALGORİTMADA KAÇ TANE İŞLEM YAPILIRSA ÇÖZÜME ULAŞILACAĞININ GARANTİSİNİ VERİR.
LİNEER ARAMA ALGORİTMASI
• LİSTEDE X BİLİNDİĞİ ZAMAN MÜMKÜN OLAN N TİP GİRİŞ VARDIR.
• LİSTEDE X İLK TERİMSE, 3 KARŞILAŞTIRMAYA İHTİYAÇ DUYULUR.
• BİRİNCİ HESAP LİSTE SONUNA GELİNİP GELİNMEDİĞİNİ, BİRİNCİ KARŞILAŞTIRMA X VE İLK TERİM
VE İLK ÇEVRİM DIŞINA ÇIKILIR.
• EĞER LİSTEDE X İKİNCİ TERİMSE, 2’ DEN FAZLA KARŞILAŞTIRMAYA İHTİYAÇ DUYULUR.
• BU YÜZDEN TOPLAM 5 KARŞILAŞTIRMA YAPILIR.
LİNEER ARAMA ALGORİTMASI
• GENELDE EĞER X İ’ NİNCİ TERİMSE ÇEVRİMDEN İ ADIMIN HERBİRİNDE İKİ KARŞILAŞTIRMA
KULLANILIR VE BİR ÇEVRİM DIŞINA ÇIKILIR.
• BU YÜZDEN 2İ+1 KARŞILAŞTIRMAYA İHTİYAÇ DUYULUR.
• BÖYLECE KARŞILAŞTIRMALARIN ORTALAMA SAYISI:
3 + 5 + 7 + ....... + (2n + 1) 2(1 + 2 + 3......... + n) + n
=
n
n
n(n + 1)
1 + 2 + 3 + ..... + n =
2
LİNEER ARAMA ALGORİTMASI
• BÖYLECE LİNEER ARAMA ALGORİTMADA KULLANILAN KARŞILAŞTIRMALARIN ORTALAMA SAYISI:
2(n(n + 1) / 2)
+ 1 = n + 2 = O ( n)
n
İKİLİ ARAMA (BİNARY SEARCH) ALGORİTMASI
• BU ALGORİTMA LİSTEDEKİ TERİMLERİN ARTAN BİR ŞEKİLDE SIRALI OLMASI HALİNDE
KULLANILABİLİR. (TERİMLER SAYI İSE KÜÇÜKTEN BÜYÜĞE, EĞER KELİME İSE ALFABETİK OLARAK
SIRALAMALIDIR).
• BU İKİNCİ ALGORİTMA İKİLİ ARAMA ALGORİTMASI OLARAK ADLANDIRILIR.
• ELEMAN LİSTENİN ORTASINA YERLEŞTİRİLMİŞ TERİMLER KARŞILAŞTIRILARAK İLERLER.
İKİLİ ARAMA (BİNARY SEARCH) ALGORİTMASI
• LİSTE AYNI BOYUTTA İKİ KÜÇÜK LİSTEYE AYRILIR VEYA KÜÇÜK LİSTELERDEN BİRİNDEKİ
TERİM SAYISI DİĞERİNDEN BİR TANE AZ OLABİLİR.
• DİĞER BÖLÜMDE İKİLİ ARAMA ALGORİTMASININ SIRALI ARAMA ALGORİTMASINDAN
DAHA ETKİLİ OLDUĞU GÖSTERİLECEKTİR.
• İKİLİ ARAMANIN NASIL ÇALIŞTIĞI AŞAĞIDAKİ ÖRNEKTE GÖSTERİLMİŞTİR.
İKİLİ ARAMA (BİNARY SEARCH) ALGORİTMASI
• 19 SAYISI İÇİN ARAMA YAPILMASI:
•
1 2 3 5 6 7 8 10 12 13 15 16 18 19 20 22
• 16 TERİMDEN OLUŞAN LİSTEYİ 8 TERİMLİ İKİ LİSTEYE AYIRIYORUZ.
•
1 2 3 5 6 7 8 10
12 13 15 16 18 19 20 22
İKİLİ ARAMA (BİNARY SEARCH) ALGORİTMASI
• İLK LİSTEDEKİ EN BÜYÜK TERİMLE 19 SAYISI KARŞILAŞTIRILIYOR. 10<19 OLDUĞUNDAN ARAMA
ORİJİNAL LİSTEDEKİ 9. VE 16. TERİME SINIRLANDIRILIYOR.
• DAHA SONRA BU LİSTE 4 TERİMDEN OLUŞAN İKİ LİSTEYE AYRILIYOR.
• 12 13 15 16
18 19 20 22
İKİLİ ARAMA (BİNARY SEARCH) ALGORİTMASI
• İLK LİSTEDEKİ EN BÜYÜK TERİMLE 19 KARŞILAŞTIRILIYOR.
• 16<19 OLDUĞUNDAN ARAMA ORİJİNAL LİSTEDEKİ 13. VE 16. TERİM ARASINA
SINIRLANDIRILIYOR. LİSTE İKİ PARÇAYA AYRILIYOR.
•
18 19
20 22
İKİLİ ARAMA (BİNARY SEARCH) ALGORİTMASI
• İLK LİSTENİN EN BÜYÜK TERİMİ OLAN 19 SAYISI 19’DAN BÜYÜK OLMADIĞINDAN
DOLAYI ARAMA İLK LİSTEDEKİ 18 İLE 19 SAYILARI İLE SINIRLANDIRILIYOR. (ORİJİNAL
LİSTEDEKİ 13. VE 14.TERİM).
• SONRA İKİ TERİMİN LİSTESİ TEK BİR TERİM OLARAK AYRILIYOR.
• 18<19 OLDUĞUNDAN ARAMA İKİNCİ LİSTEYE SINIRLANIYOR.
• LİSTE 14.TERİMİ İÇEREN 19 SAYISIDIR.
• ŞU AN ARAMA BİR TERİME İNDİRİLİYOR, KARŞILAŞTIRMA YAPILIYOR VE 19 SAYISI ORİJİNAL
LİSTENİN 14. TERİMİNE YERLEŞTİRİLİYOR.
İMPORT MATH
__NAME__ = "İKİLİ_ARAMA"
DEF İKİLİ_ARAMA(ARANANDEGER,DİZİ):
L=0
R= LEN(DİZİ)-1
WHİLE L <= R:
ORTA = MATH.CEİL(L + (R - L)/2);
İF DİZİ[ORTA] == ARANANDEGER:
RETURN ORTA
def main():
dizi = [1, 2, 3, 5, 6, 7, 8, 10, 12, 13, 15, 16, 18,
19, 20, 22]
arananDeger = 19
sonuc = ikili_arama(arananDeger,dizi)
if sonuc != -1:
print('Elemanın konumu :', sonuc)
else:
print("Aranan eleman bulunamadı")
if __name__ == "ikili_arama":
main()
ELİF DİZİ[ORTA] < ARANANDEGER:
L = ORTA + 1
ELSE:
R = ORTA - 1
RETURN -1
İkili Arama (Binary Search) Algoritması
(Python)
İKİLİ ARAMA (BİNARY SEARCH) ALGORİTMASI
(PYTHON)
• YUKARIDAKİ PYTHON KODLARI İNCELENDİĞİNDE ALGORİTMANIN DÖNGÜLÜ BİR ŞEKİLDE
YAZILDIĞI GÖRÜLMEKTEDİR.
• DAHA ÖNCEKİ BÖLÜMLERDE DE BELİRTİLDİĞİ GİBİ TEORİK OLARAK HER DÖNGÜLÜ
ALGORİTMAYI ÖZYİNELEMELELİ BİR ŞEKİLDE YAZMAK MÜMKÜNDÜR.
• BU DOĞRULTUDA AŞAĞIDA VERİLEN PYTHON KODLARI İKİLİ ARAMA ALGORİTMASININ
ÖZYİNELEMELİ ŞEKİLDE YAZILMIŞ HALİNİ İÇERMEKTEDİR.
• PROGRAMIN KODLARI İNCELENDİĞİNDE FONKSİYONUN SÜREKLİ OLARAK KENDİNİ ÇAĞIRARAK
ÇÖZÜME ULAŞTIĞI GÖRÜLMEKTEDİR.
İMPORT MATH
__NAME__ = "İKİLİ_ARAMA"
DEF İKİLİ_ARAMA (ARANANDEGER, DİZİ):
L=0
R=LEN(DİZİ)-1
İF R >= L:
ORTA = MATH.CEİL(L + (R - L)/2)
İF DİZİ[ORTA] == ARANANDEGER:
RETURN ORTA
ELİF DİZİ[ORTA] > ARANANDEGER:
def main():
dizi = [1,2,3,5,6,7,8,10,12,13,15,16,18,19,20,22]
arananDeger = 19
sonuc = ikili_arama(arananDeger,dizi)
if sonuc != -1:
print('Elemanın konumu :', sonuc)
else:
print("Aranan eleman bulunamadı")
if __name__ == "ikili_arama":
main()
YDİZİ = DİZİ[L:ORTA]
X = İKİLİ_ARAMA(ARANANDEGER,YDİZİ)
RETURN X
ELSE:
YDİZİ = DİZİ[ORTA+1:]
İ = ORTA+1;
X = İKİLİ_ARAMA(ARANANDEGER,YDİZİ)
RETURN İ+X
ELSE:
RETURN -1
İkili Arama (Binary Search) Algoritması (Python-Recursive)
FUNCTİON CİKTİ = İKİLİ_ARAMA(ARANANDEGER , DİZİ)
L=1;
R= LENGTH(DİZİ);
CİKTİ = -1;
WHİLE( L<=R)
ORTA = CEIL(L + (R - L)/2);
İF(DİZİ(ORTA) == ARANANDEGER)
CİKTİ = ORTA;
BREAK;
ELSEİF(DİZİ(ORTA) < ARANANDEGER)
L = ORTA + 1;
ELSE
function main()
dizi =
[1,2,3,5,6,7,8,10,12,13,15,16,18,19,20,22];
arananDeger = 19;
sonuc = ikili_arama(arananDeger,dizi);
if( sonuc ~= -1)
fprintf('Elemanýn konumu : %i\n', sonuc)
else
fprintf("Aranan eleman bulunamadý\n")
end
end
R = ORTA - 1;
END
END
END
İkili Arama (Binary Search) Algoritması
(Matlab)
İKİLİ ARAMA (BİNARY SEARCH) ALGORİTMASI
• KOLAYLIK İÇİN LİSTEDE N=2K ELEMAN OLDUĞUNU FARZ EDELİM.
• K POZİTİF TAMSAYI LİSTEDE K=LOG N GEÇMEKTE, 2’ NİN KUVVETİ DEĞİLDİR.
• 2K+1 ELEMANLA DAHA BÜYÜK BİR LİSTE DİKKATE ALINABİLİR.
• BURADA 2 K< N < 2K+1 ‘DİR.
• ALGORİTMANIN HER BÖLÜMÜNDE, İ VE J İLK TERİMİN YERİNDE VE EN SON TERİMLE SINIRLANDIRILMIŞTIR.
• KARŞILAŞTIRMADA BİR TERİMDEN DAHA FAZLA TERİM SINIRLANDIRILAMAYACAĞI GÖZLENİR.
• EĞER İ<J, SINIRLANDIRILMIŞ LİSTENİN ORTA TERİMİNDEN, X’ İN DAHA BÜYÜK OLUP OLAMAYACAĞI HESAPLANIR.
İKİLİ ARAMA (BİNARY SEARCH) ALGORİTMASI
• İLK KISIMDA, SEÇİM 2K-1 TERİMLE SINIRLANDIRILARAK YAPILIR.
• ŞİMDİYE KADAR 2 KARŞILAŞTIRMA KULLANILDI.
• BU PROSEDÜRE DEVAM EDERSEK, BİR LİSTEDE HER BÖLGENİN SINIRLANDIRILMASINDA İKİ
KARŞILAŞTIRMA KULLANARAK BİRÇOK TERİMİN YARISIYLA BİR LİSTE SEÇİMİNDE.
• DİĞER DURUMLARDA, LİSTE 2K ELEMANA SAHİP OLDUĞU ZAMAN ALGORİTMANIN İLK KISMINDA
İKİ KARŞILAŞTIRMA KULLANILIR.
İKİLİ ARAMA (BİNARY SEARCH) ALGORİTMASI
• İKİDEN FAZLA SEÇİM YAPILACAĞI ZAMAN 2K-1 ELEMANLA LİSTE YAPILIR.
• SONUÇ OLARAK LİSTEDE BİR TERİM AYRILACAĞI ZAMAN, BİRİNCİ KARŞILAŞTIRMADA TAKİP EDEN
TERİMLER ATILIR VE BİR DAHA KARŞILAŞTIRMADA EĞER TERİM X İSE HESAPLAMADA KULLANILIR.
• BÖYLECE, EN ÇOK 2K+2=2LOGN+2 KARŞILAŞTIRMAYLA, 2K ELEMANA SAHİP SEÇİLEN BİT LİSTEDE
İKİLİ BİR İKİLİ SEÇİMİ GERÇEKLEŞTİRDİK.
• SONUÇ OLARAK BİR İKİLİ SEÇİM YAPILIRKEN O(LOGN) KARŞILAŞTIRMA YAPILIR.
• BU ANALİZ BİZE GÖSTERMİŞTİR Kİ ALGORİTMADA İKİLİ SEÇİM LİNEER SEÇİMDEN DAHA ETKİNDİR.
ATLAMALI ARAMA (JUMP SEARCH) ALGORİTMASI
• ATLAMALI ARAMA ALGORİTMASI İKİLİ ARAMAYA BENZER ŞEKİLDE SIRALI DİZİLER ÜZERİNDE
ÇALIŞMAKTADIR.
• BU ALGORİTMANIN ARKASINDAKİ TEMEL FİKİR LİNEER ARAMADAKİ GİBİ TÜM ELEMANLARI
KONTROL ETMEK YERİNE BELİRLİ BİR ADIM BOYUTU İLE ATLAMA GERÇEKLEŞTİREREK ULAŞILAN
DEĞERİ KONTROL ETMEKTİR.
• ARANAN DEĞER ULAŞILAN DEĞERDEN BÜYÜKSE İLERİYE DOĞRU ATLAMAYA DEVAM EDİLİR.
• AKSİ TAKTİRDE GERİYE DOĞRU GİDİP TEKRAR İLERİ DOĞRU ARAMA GERÇEKLEŞTİRİLİR.
ATLAMALI ARAMA (JUMP SEARCH) ALGORİTMASI
• ARALIK BİR KERE TESPİT EDİLDİKTEN SONRA LİNEER ARAMA İŞLEMİ GERÇEKLEŞTİRİLİR.
• BU ALGORİTMADA BAŞLANGIÇ ADIM SAYISI OLARAK ARAMA YAPILACAK DİZİDEKİ ELEMAN
SAYISININ KAREKÖKÜ KULLANILMAKTADIR.
• KARMAŞIKLIK HESABI KISMINDA NEDEN BU DEĞERİN TERCİH EDİLDİĞİ AÇIKLANACAKTIR.
ATLAMALI ARAMA (JUMP SEARCH) ALGORİTMASI
• ATLAMALI ARAMA ALGORİTMASININ NASIL ÇALIŞTIĞI AŞAĞIDAKİ ÖRNEK ÜZERİNDE
İNCELENMİŞTİR.
• 0, 1, 2, 3, 5, 6, 8, 12, 24, 33, 66, 78, 145, 257, 488, 799
• ŞEKLİNDE BİR DİZİ VERİLDİĞİNİ VE BU DİZİ ÜZERİNDE 66 SAYISININ ARANDIĞINI VARSAYALIM.
• DİZİDEKİ ELEMAN SAYISININ 16 OLMASI NEDENİYLE ATLAMA DEĞERİ 4 OLARAK
BELİRLENMEKTEDİR.
ATLAMALI ARAMA (JUMP SEARCH) ALGORİTMASI
• BU DURUMDA ARAMA İŞLEMLERİ ŞU ADIMLARLA GERÇEKLEŞTİRİLİR:
1.
ADIM: 0. İNDEKSTEN 4’E ATLA VE DEĞERİ KARŞILAŞTIR
2.
ADIM: 4. İNDEKSTEN 8’E ATLA VE DEĞERİ KARŞILAŞTIR
3.
ADIM: 8. İNDEKSTEN 12’YE ATLA VE DEĞERİ KARŞILAŞTIR
4.
ADIM: 12. İNDEKSTEKİ DEĞER 145 > 66 OLDUĞU İÇİN 8. İNDEKSE GERİ DÖN
5.
ADIM: 8. İNDEKSTEN İTİBAREN LİNEER ARAMA GERÇEKLEŞTİR
İMPORT MATH
__NAME__ = "ATLAMALİ_ARAMA"
DEF ATLAMALİ_ARAMA(ARANANDEGER, DİZİ):
def main():
dizi = [ 0,1,2,3,5,6,8,12,24,33,66,78,145,257,488,799 ]
arananDeger = 66
L=LEN(DİZİ)
ADİM = İNT(MATH.SQRT(L))
ONCEKİ = 0
WHİLE DİZİ[MİN(ADİM, L)-1] < ARANANDEGER:
ONCEKİ = ADİM
ADİM += İNT(MATH.SQRT(L))
sonuc = atlamali_arama(arananDeger,dizi)
if sonuc != -1:
print('Elemanın konumu :', sonuc)
else:
print("Aranan eleman bulunamadı")
İF ONCEKİ >= L:
RETURN -1
WHİLE DİZİ[İNT(ONCEKİ)] < ARANANDEGER:
if __name__ == "atlamali_arama":
main()
ONCEKİ += 1
İF ONCEKİ == MİN(ADİM, L):
RETURN -1
İF DİZİ[ONCEKİ] == ARANANDEGER:
RETURN ONCEKİ
RETURN -1
Atlamalı Arama (Jump Search) Algoritması
(Python)
FUNCTİON CİKTİ = ATLAMALİ_ARAMA(ARANANDEGER , DİZİ)
L = LENGTH(DİZİ);
ADİM = FİX(SQRT(L));
ONCEKİ = 1;
function main_jump()
dizi = [0,1,2,3,5,6,8,12,24,33,66,78,145,257,488,799] ;
arananDeger = 66;
CİKTİ = -1;
WHİLE(DİZİ(MİN(ADİM, L)) < ARANANDEGER)
sonuc = atlamali_arama(arananDeger,dizi);
ONCEKİ = ADİM;
ADIM = ADIM + FIX(SQRT(L));
İF (ONCEKİ >= L)
CİKTİ = -1;
BREAK;
END
END
WHİLE( DİZİ(ONCEKİ) < ARANANDEGER)
IF (ONCEKI == MIN(ADIM, L))
if( sonuc ~= -1)
fprintf('Elemanýn konumu : %i\n', sonuc)
else
fprintf("Aranan eleman bulunamadý\n")
end
end
CİKTİ= -1;
BREAK;
END
ONCEKİ = ONCEKİ + 1;
END
İF (DİZİ(ONCEKİ) == ARANANDEGER)
CİKTİ = ONCEKİ;
END
END
Atlamalı Arama (Jump Search) Algoritması
(Matlab)
ATLAMALI ARAMA (JUMP SEARCH) ALGORİTMASI
• ATLAMALI SIRLAMA ALGORİTMASINDA KRİTİK ADIMLARDAN BİR TANESİ ADIM UZUNLUĞUNUN
BELİRLENMESİDİR.
• ARAMA YAPILACAK DİZİ UZUNLUĞU N VE ADIM BOYUTU S OLMAK ÜZERE EN KÖTÜ DURUMDA
N/S ADET ATLAMA YAPMAK GEREKİR.
• DOĞRUSAL ARAMA AŞAMASINDA İSE S-1 ADET KIYASLAMA İŞLEMİ GERÇEKLEŞTİRİLİR.
• DOLAYISIYLA EN KÖTÜ DURUMDA YAPILMASI GEREKEN TOPLAM İŞLEM SAYISI ŞU ŞEKİLDE İFADE
EDİLEBİLİR:
ATLAMALI ARAMA (JUMP SEARCH) ALGORİTMASI
• BU DURUMDA YUKARIDAKİ FONKSİYONUN EN KÜÇÜK DEĞERİNİ ALMASINI SAĞLAYAN 𝑠 = 𝑛
DEĞERİ ATLAMA ADIMI OLARAK BELİRLENİR.
• ATLAMALI ARAMA ALGORİTMASININ İDEAL ATLAMA DEĞERİ 𝑛 OLDUĞUNDAN DOLAYI ZAMAN
KARMAŞIKLIĞI 𝑂( 𝑛) OLUR.
• BU DEĞER LİNEER ARAMA ALGORİTMASININ KARMAŞIKLIĞINDAN O(N) DAHA İYİYKEN İKİLİ
ARAMA ALGORİTMASINDAN O(LOGN) DAHA KÖTÜDÜR.