instagram twitter linkedin github youtube

14.7.15

Derin Limitli Arama (Depth Limited Search) Algoritması

Bilgisayar bilimlerinde Kullanılan arama algoritmalarından birisidir. Bu algoritma Esas Olarak  derin Öncelikli arama (derinlik ilk arama DFS)  ile Cardio çalışmaktadır ancak tek farkı arama İşlemi sırasında özellikle dairelere (döngü) takılma ihtimaline Karşı sınır onlemi alınmış OLMASIDIR.  
Örneğin aşağıdaki şekli ele alalım:
Yukarıdaki sekil tanım İtibariyle Bir ağaç Özelliği göstermektedir. Yani A.Ş. yönlü daire içermeyen Bir şekildir (yönlendirilmiş Mercury grafik) . Ancak Cardio şekle aşağıdaki gibi Basit bir Bağlantı Daha eklenseydi artık ağaç olmayacaktı: 
Yukarıdaki yeni sekılde derin Öncelikli bir arama yaptığımızı A düğümünden İşleme başladığımızı düşünelim ettik. Örneğin orta Sıra (infix) ziyaretinde L NR (sol Üst sağ, sol düğüm sağ) sırasıyla arama yaptığımızı düşünelim. Daire içermeyen ilk sekılde LNR sırasına Göre aşağıdaki sonucun çıkması beklenir:  
DBEAFC
Ancak ikinci sekilde LNR sırasına Göre ÖNCE en soldaki terim yazılmaya çalışılacak, Böylece A> B-> D> A-> B> D> A-> B> D> A sırasıyla namütenahi dönülecek ziyaretinde hiçbir, zaman Bitmeyecek Bir fasit daireye girilecektir (Sonsuz döngü). Bu durum literatürde sol özyineleme (sol özyineleme) Olarak geçer. Yani şeklimizin (VEYA HERHANGİ Bir yapının) sol tarafında kendini tekrarlayan bir durum bulunmakta dolayısıyla derin Öncelikli arama yapılamamaktadır.
Çözüm Olarak bu Yazının da konusu Olan Sınırlı derin Öncelikli arama (derinlik sınırlı arama, DLS) algoritması Kullanılabilir. Bu algoritmada gidilebilecek düğüm sayısına Bir tahdit konulmakta ziyaretinde ancak Verilen sayıda düğüme gidilebilmektedir.
Algoritmanın kodlanması
Yukarıda izah edilen algoritma aşağıdaki sekılde kodlanabilir:
Yukarıdaki özyineli fonksiyonda (recursive fonksiyon) bakılan düğüm hedef olana Kadar dolaşma İşlemi devam etmektedir. Dolaşma İşlemi sırasında klasik derin Öncelikli aramalarda Kullanılan Yığın (stack) Düğümler geri geçilen ettik kullanılmıs dönülüp aranmak Üzere yığında tutulmuştur.   
Şayet aranan düğüm Verilen derinlikten Daha derin değilse arama İşlemi devam etmektedir ancak Verilen derinlik geçildiği zaman arama İşlemi Daha Derine gitmemekte Ana O artık ettik Kadar aranmak Üzere yığınladığı düğümleri işlemektedir.
Yukarıda anlatılan algoritma bilgisiz bir arama algoritmasıdır (bilgisiz arama algoritması) AYRICA algoritmanın hafıza karmaşıklığı (bellek karmaşıklığı) ziyaretinde sınırlıdır Çünkü algoritmada aranabilecek düğüm sayısında Bir sınır bulunmaktadır.  
Normal derinliği ilk arama gibi, derinlik Sınırlı arama bir olan bilgisiz arama. Bu derinliği ilk arama tam gibi Çalışır, ama arama derinliğine Bir Maksimum Paket limiti koyarak tamlığı Konusundaki sakıncaları önler. Arama hala O derinliğe Ötesinde tepe genişletmek bile, bunu yapmayacağım ettik böylece sonsuz derin takip EDECEK yolları VEYA takılıyorum döngüleri. Tüm Grafikleri en az tamlığını garanti derinlik Sınırı, icinde imkb nedenle derinlik Sınırlı arama Bir Çözüm bulacaksınız.
Arama Maksimum Paket arama derinliği atamanız Gereken yerde tepe belirleyin ziyaretinde başlatmak
Geçerli köşe hedefi devlet OLUP olmadığını Kontrol edin
Hicbir şey yapma: Değilse
Evet imkb: dönmek
Kontrol güncel köşe Maksimum Paket arama derinliği icinde imkb
Değilse: Hicbir şey yapma
Eger öyleyse:
Vertex genişletin ardılları Tüm ONUN ettik Tasarruf yığının
Yığının bütün, Köseler Click özyinelemeli DLS Çağrı Adım 2'ye geri donun A.Ş.

kod

DLS (düğüm, hedef, derinlik) { 
  if (derinlik> = 0) { 
    if (düğüm == gol) 
     x = gol (hedef = derinlik) eğer 
       Dönüş düğümü 

    Onun çocuk olarak Click genişletmek (düğüm) DLS (çocuk, hedef, derinlik -1) 
  } 
} Özellikler Uzay karmaşıklığı Derinlik Sınırlı arama Dahili Olarak Kullandığı bu Yana derinliği ilk arama, uzay karmaşıklığı normal derinliği ilk arama eşdeğerdir. Zaman karmaşıklığı Derinlik Sınırlı arama içten derinlik ilk arama kullandığından, Zaman karmaşıklığı normal derinliği ilk arama eşdeğerdir ziyaretinde ( \ Olduğu O Vert V \ vert + \ vert E \ vert Yerlerde) \ Vert V \ vert köşelerin Sayısı ziyaretinde stantlar Click \ Vert E \ vert keşfedilmeyi kenarların Sayısı Click grafikte. Tüm grafik KEŞFETMEK etmediğini derinlik Sınırlı arama, ancak Bağlı Belirtilen icinde yatıyor Sadece Bir Parçası Unutmayın. Bütünlük Derinlik Sınırlı arama sonsuz uzun yolları takip edemez, ne de genel olarak, Gösterilen döngü sıkışmış olsa bile bu Verilen arama derinliğinin Ötesinde Yatan HERHANGİ Bir Çözüm inançsız olmadigindan algoritma tam Değildir. En Fazla aranan derinliği Bir ​​çözelti derinliğinden Daha Büyük olacak sekılde seçilir Ancak algoritma tamamlandı olur. Optimalite Derinlik SınırlıSorumlu arama optimum Değildir. Hala ilk ziyaretinde böylece muhtemelen Başka yolu Bazi Çözüm Daha Pahalı Bir Çözüm bulma, Sonuna Kadar tek yol araştırıyor derinliği ilk aramanın sorunu Vardır.
      













Derin öncelikli arama (depth first search)

Bir ağaç dolaşma algoritmasının (ağaç travers algoritma, ağaç kastetmek) ilk ÖNCE alt seviyesinde Bulunan komşularını araması durumudur.
Örneğin aşağıdaki ağacı ele alalım:
Ağacı dolaşma sırlaması örneğin 3, 2, 7, 1, 9, 8, 5 şeklindeyse bu dolaşmaya derin Öncelikli arama (derinlik ilk arama) ismi VERİLEBİLİR.
Bu arama sıralamasında, dolaşma Sıralaması aşağıdaki ihtimallerden birisi Olabilir:
LRN: Sol Sağ Düğüm (Sol Sağ Düğüm)
RLN: Sağ Sol Düğüm (Sağ Sol Düğüm)
RNL: Sağ Düğüm Sol (Sağ Düğüm Sol)
RLN: Sağ Sol Düğüm (Sağ Sol Düğüm)
Yani Öncelikle düğüm Sonra Altındaki Üyelere hareket edilir.
Sığ Öncelikli Arama (Genişlik İlk Arama)  algoritma Tipine Göre imkb:
NLR: Düğüm Sol Sağ (Düğüm Sol Sağ)
NRL: Düğüm Sağ Sol (Düğüm Sağ Sol)
ihtimallerinden birisi Tercih Edilebilir. Buradaki fark ilk bakılan düğümün, MEVCUT düğümün Altında Olan Bir düğüm Yerine Cardio seviyede olmasinin. Yani derin Öncelikli aramada, sığ aramadan Farklı Olarak ÖNCE düğümün alt seviyedeki düğümlerden Aramaya başlanır.

başladığımız il merkezinden gidilebilecek en uzak ile  gidilir.Daha  sonda gidecek Başka Yer kalmayınca Bir Önceki ile geri Dönerek oradan gidilebilecek en uzak ile gidilir ziyaretinde Daha Sonra Başlangıç ​​noktasına dönülür.Bu algoritmada hep Daha Derine gitme isteği ile hareket eder.Başka bır sekılde anlatilmak İSTENİRSE Bir ağacın ana köünden beligbli Bir ​​çıkmaza denk gelene Kadar ağacın derinliklerine doğru Işaretleyerek hareket edilir. Sonrasında çıkmaz il karşılaşınca geri dönülüp kardeş Olan düğüm aranır ziyaretinde kardeş Olan ilk düğüme rastlayınca tekrardan Daha derinlere doğru hareket edilir. İlk resimde DFS algoritmasının psuedo kodu bulunmaktadır.  
dfs-300x157
Aşağıdaki görselde imkb DFS algoritmasının örnek graf uzerinde Anlık çalışma Durumu gösterilmiştir.
dfs
Graf dolaşmak Click planlanan bu algoritmalar ile çok Farklı Bir Yol izleyeceğiz.Öncelikle internet Sitelerinin İçeriği de graf Yapısı oluşturmaktadır. Örneğin http://preciselyconcise.com/apis_and_installations/downloadables/jsoup/test.php  şu sitenin kaynak Kodunu inceleyecek olursak
2014/07/16 21:52:24 arasında Ekran
Bu kodlar da Bir ağaç Yapısı olusturmus oluyorlar.
2014/07/16 21:52:01 arasında Ekran
Bu ağaç yapısını oluşturduktan Sonra imkb Jsoup kullanarak bütün, sitelerde istedigimiz graf yapısını kurabilir.BFS DFS A.Ş. Algoritmaları ile aramak istedigimiz kelimelerin HTML kodlarına ulaşabiliriz. Bir site içerisinde Bulunan Tüm kelimelerde gezebilir, siralama arama yapabiliriz ettik.  

Şekillerde (Graph) sığ öncelikli arama (Breadth First Search, BFS)

Bu yazı,  ağaçlardaki sığ Öncelikli arama  ile karıştırılmamalıdır . Ağaçlar (ağaçları)  bilindiği Üzere yönlü dairesel olmayan şekillerdir (yönlendirilmiş Mercury grafik) dolayısıyla ağaçlar uzerinde bu yazıda anlatılan Sıra (kuyruk)  yapısına ve İhtiyaç Duyulmaz.
Sığ Öncelikli arama Bir Başlangıç ​​düğümünden başlayarak Sıradaki Komşuları dolaşan arama algoritmasıdır. Bu arama algoritmasında amaç ÖNCE Başlangıç ​​düğümüne Yakın Manzara düğümlere bakmaktır.
Bu arama şekli suya atılan Bir damlanın suda çıkardığı halkalara benzetilebilir. Başlangıç ​​düğümüne en Yakın Manzara halka Sonra ikinci Yakın Manzara halka Sonra diğerleri şeklinde giden bir arama algoritmasıdır ettik.
Bu Durumu aşağıdaki örnek Üzerinden anlamaya çalışalım:
Örnek Olarak yukarıda Bulunan şekli ele alalım. Örneğimizde Başlangıç ​​düğümü (düğüm) Olarak bir düğümünü seçtiğimizi ziyaretinde aranan düğümün e düğümü oldugunu düşünelim.  
A düğümünün komşuluk listesini (adjacency listesi) çıkarıyoruz:  
komşu (A) = {C, B}
Bu komşulara sırasıyla bakılıyor ziyaretinde bu komşuların komşuluk Listeleri çıkarılıyor:
bakılanlar: {A, B, C}
komşular = komşu (B), komşu (C) = {D, E, E}
Arana düğüm E, bu Adımda bulunmuştur.
Yukarıdaki örnekte görüldüğü Üzere Bir Sonraki derinliğe inilmeden sonra, o derinlikte Olan (Başlangıç ​​düğümüne O UZAKLIKTA Olan) Bütün Düğümler dolaşılıyor Ardından Bir alt seviyeye iniliyor ziyaretinde.
Yukarıdaki örnekte bütün, ağaç dolaşılmış gibi dusunulebilir. Örneğin sekil (grafik) aşağıdaki gibi olsaydı:
Bu DURUMDA Z düğümüne hiçbir, zaman bakılmayacaktı Çünkü aranan düğüm Z düğümünden Daha sığ Bir derinlikte Olacaktı.
Kısacası BFS arama algoritması ile aranan düğümün derinliğine Kadar Olan bütün, düğümlere bakılır ancak bu derinlikten Daha aşağıda Olan düğümlere bakılmasına gerek yoktur.

Sığ Öncelikli Arama (Breadth First Search , BFS)

Bir ağaç dolaşma algoritmasının (ağaç hareket algoritması, ağaç geçişi) ilk ÖNCE Cardio seviyede Bulunan komşularını araması durumudur.
Örneğin aşağıdaki ağacı ele alalım:
Ağacı dolaşma sırlaması örneğin 5,7,8,3,2,1,9 şeklindeyse bu dolaşmaya sığ Öncelikli arama ismi VERİLEBİLİR.
Bu arama sıralamasında, dolaşma Sıralaması aşağıdaki ihtimallerden birisi Olabilir:
NLR: Düğüm Sol Sağ (Düğüm Sol Sağ)
NRL: Düğüm Sağ Sol (Düğüm Sağ Sol)
Yani Öncelikle düğüm Sonra Altındaki Üyelere hareket edilir.
Derin Öncelikli Arama (derinlik Önce Arama)  algoritma Tipine Göre imkb:
LRN: Sol Sağ Düğüm (Sol Sağ Düğüm)
RLN: Sağ Sol Düğüm (Sağ Sol Düğüm)
RNL: Sağ Düğüm Sol (Sağ Düğüm Sol)
LNR: Sol Düğüm Sağ (Sol Düğüm Sağ)
ihtimallerinden birisi Tercih Edilebilir. Buradaki fark ilk bakılan düğümün, MEVCUT düğümün Altında Olan Bir düğüm olmasinin. Yani sığ Öncelikli aramada Olduğu gibi Cardio seviyedeki düğümlerden ÖNCE alt seviyedeki düğümlere bakılır.

BFS (ilk arama genişlik) algoritmasının çalışma mantığı şu şekildedir. Bir düğüm dan başlayarak Ilgili düğüm un Tüm Komşuları gezilir Verilen. Daha Sonra gezilen komşuların Komşuları gezilerek Verilen grafiktir gezilmiş olur.
Algoritma
  1. Fonksiyona Gönderilen düğümü kuyruğa atılır.
  2. Kuyruk boşalıncaya Kadar döngü sürdürülür.
  3. Sıradaki düğümü kuyruktan çıkarılır.
  4. Çıkarılan düğüm Daha Önce gezilmemiş imkb, gezildi işareti Konur gezilmemiş Komşuları kuyruğa Konur A.Ş..
Sözde Kodunu şöyle yazabiliriz.
Kamu void bfs ( ) 
{ 
 // BFS Kuyruk veri yapısı kullanır 
 Kuyruk q = new 
  n = ( Düğüm ) q. çıkartın ( ) ; 
  Düğüm düğümler arasında ziyaret mülkiyet 
 clearNodes ( ) ; }
 
 
  
  
  
 
 
Alttaki sekil de bir grafik Verilen ın gezilirken nasıl renklendirildiğini görebilirsiniz
AYRICA göster buradaki animasyonu Izleyebilirsiniz.  
Şekil 1
Şekil 1 Örneğin Click bfs algoritmasıda c Kodunu yazmak Hakkında istersek şu sekılde Bir kod yazabiliriz.
#include <stdio.h> 
#include <math.h> 
#include <stdlib.h> 
#include <time.h>
 
Yapısı Başlangıcı ///////////////////// typedef struct köşe Öğe ; struct düğüm
 { 
 Öğe 
olsun ( ) { eğer ( ! isEmpty ( ) ) { 
  Item Kuyruk) "boş; }
 
 
 
 
 


 
 


 

 

 
 






 
 



  



 


 
 
  
  
  
 
 
 
  
 
 
} 
void koymak ( Öğe Yapısı Sonu - & Gt; color = , ver , 
    koyun ( arr [ FindIndex ( arr , mem - & gt ; harf ) ] ) ; printf ( "% C kuyruğu koyar \ n " , arr [ FindIndex ( arr , mem - & gt ; harf ) ] . madde ) ; } 
   mem = mem - & gt ; yanındaki , } 
  ver. renk = 'B' ; printf ( "% C - & gt; color = Siyah \ n " , . ver madde ) ; } } int ana ( ) { 
 queueInıt ( 1 ) ; // Kuyruk çıkacağı başlatılamıyor

 
 
 
  
 




 
 
   
    
    
   
  
  
 



 
 struct Vertex * arr =  ( struct köşe * ) malloc ( sizeof ( struct köşe ) * 6 ) ;
 
 arr [ 0 ] . item = 'A' ; 
 arr [ 1 ] . item = 'B' ; 
 arr [ 2 ] . item = 'C' ; 
 arr [ 3 ] . item = 'D' ; 
 arr [ 4 ] . item = 'E' ; 
 arr [ 5 ] . item = 'F' ; 
 //Bağlantılar atanıyor 
 arr [ 0 ] . connection =  ( struct members * ) malloc ( sizeof ( struct members ) ) ; 
 arr [ 0 ] . connection -& gt ; letter = 'D' ; 
 arr [ 0 ] . connection -& gt ; next = NULL ;
 
 arr [ 1 ] . connection =  ( struct members * ) malloc ( sizeof ( struct members ) ) ; 
 arr [ 1 ] . connection -& gt ; letter = 'C' ; 
 arr [ 1 ] . connection -& gt ; next = ( struct members * ) malloc ( sizeof ( struct members ) ) ; 
 arr [ 1 ] . connection -& gt ; next -& gt ; letter = 'E' ; 
 arr [ 1 ] . connection -& gt ; next -& gt ; next = NULL ;
 
 arr [ 2 ] . Bağlantı = null ;
 
 arr [ 3 ] . connection =  ( struct members * ) malloc ( sizeof ( struct members ) ) ; 
 arr [ 3 ] . connection -& gt ; letter = 'B' ; 
 arr [ 3 ] . connection -& gt ; next = ( struct members * ) malloc ( sizeof ( struct members ) ) ; 
 arr [ 3 ] . connection -& gt ; next -& gt ; letter = 'F' ; 
 arr [ 3 ] . connection -& gt ; next -& gt ; next = NULL ;
 
 arr [ 4 ] . connection =  ( struct members * ) malloc ( sizeof ( struct members ) ) ; 
 arr [ 4 ] . connection -& gt ; letter = 'D' ; 
 arr [ 4 ] . connection -& gt ; next = ( struct members * ) malloc ( sizeof ( struct members ) ) ; 
 arr [ 4 ] . connection -& gt ; next -& gt ; letter = 'C' ; 
 arr [ 4 ] . connection -& gt ; next -& gt ; next = ( struct members * ) malloc ( sizeof ( struct members ) ) ; 
 arr [ 4 ] . connection -& gt ; next -& gt ; next -& gt ; letter = 'F' ; 
 arr [ 4 ] . connection -& gt ; next -& gt ; next -& gt ; next = NULL ;
 
 arr [ 5 ] . Bağlantı = null ;
 
 bfs ( arr , 0 ) ; 
 iade  0 ; 
}