Algoritmalar nasıl tanımlanır, kanıtlanır ve analiz edilir?

Bilgisayar Programlama Sanatı'nı (TAOCP) okumadan önce bu soruları derinlemesine düşünmedim. Ben algoritmaları tanımlamak, onları anlamak ve sadece büyüme siparişleri hakkında çalışma süresini tahmin etmek için sahte kod kullanırdım. TAOCP iyice fikrimi değiştirir.

TAOCP , algoritmayı tanımlamak için adımlar ve goto ile karıştırılmış İngilizce kullanır ve algoritmayı daha kolay resmetmek için akış şemalarını kullanır. Düşük seviyeli görünüyor, ancak özellikle çok fazla göz ardı ettiğim akış şemasında bazı avantajlar olduğunu düşünüyorum. Hesaplamanın bu oku geçtiği andaki mevcut durum hakkında bir iddiayla okların her birini etiketleyebilir ve algoritma için endüktif bir kanıt oluşturabiliriz. Yazar diyor ki:

Bir algoritmanın neden geçerli olduğunu gerçekten anladığımız yazarın tartışmasıdır, ancak Şekil 4'te olduğu gibi zihinlerimizin tüm iddiaları örtülü olarak doldurduğu noktaya ulaştığımızda.

Ben böyle şeyler yaşamadım. Başka bir avantaj, her adımın kaç kez yürütüldüğünü sayabilmemizdir. Kirchhoff'un ilk yasasını kontrol etmek kolaydır. Çalışma süresini tam olarak analiz , bu yüzden çalışma süresini tahmin ederken bazı atlanmış olabilir.$\pm1$

Büyüme emirlerinin analizi bazen işe yaramaz. Örneğin, quicksort'u heatsort'tan ayırt edemeyiz çünkü hepsi , burada beklenen rasgele değişken sayısıdır , bu nedenle sabit, ve , böylece ve T_2 daha iyi. Ve ayrıca, bazen varyanslar gibi diğer miktarları karşılaştırmalıyız. Çalışma zamanının büyüme emirlerinin sadece kaba bir analizi yeterli değildir. As TAOCP$E(T(n))=\Theta(n\log n)$$EX$$X$$E(T_1(n))=A_1n\lg n+B_1n+O(\log n)$T 1 T $E(T_2(n))=A_2\lg n+B_2n+O(\log n)$$T_1$$T_2$ algoritmaları montaj diline çevirir ve çalışma süresini hesaplar, Benim için çok zor, bu yüzden çalışma süresini biraz daha kabaca analiz etmek için bazı teknikleri bilmek istiyorum, bu da C, C ++ gibi daha üst düzey diller için yararlıdır veya sözde kodlar.

Ve esas olarak araştırma çalışmalarında hangi açıklama tarzının kullanıldığını ve bu sorunların nasıl ele alınacağını bilmek istiyorum.

Çok çeşitli uygulanabilir yaklaşımlar vardır. Hangisi daha uygun?

• ne göstermeye çalışıyorsun,
• ne kadar detay istediğiniz veya ihtiyacınız.

Algoritma, altyordam olarak kullandığınız yaygın olarak biliniyorsa, genellikle daha yüksek bir seviyede kalırsınız. Algoritma araştırılan ana nesne ise, muhtemelen daha ayrıntılı olmak istersiniz. Aynı şey analizler için de söylenebilir: kaba bir üst çalışma zamanı sınırına ihtiyacınız varsa, ifadelerin tam olarak sayılmasını istediğinizden farklı şekilde devam edersiniz.

Size umarım bunu gösteren iyi bilinen algoritma Mergesort için üç örnek vereceğim.

Yüksek seviye

Mergesort algoritması bir liste alır, iki (yaklaşık) eşit uzunlukta uzun parçaya ayırır, bu kısmi listelerde geri çekilir ve sonuçların sıralanması için (sıralanmış) sonuçları birleştirir. Tekli veya boş listelerde girdiyi döndürür.

Bu algoritma açık bir şekilde doğru bir sıralama algoritmasıdır. Listeyi bölmek ve birleştirmek her zaman zamanında uygulanabilir , bu da bize en kötü çalışma zamanı için bir yineleme sağlar . Ana teorem ile bu değerlendirilir .T ( n ) = 2 T ( $\Theta(n)$T(n)∈Θ(nlogn$T(n) = 2T\left(\frac{n}{2}\right) + \Theta(n)$$T(n) \in \Theta(n\log n)$

Orta düzey

Mergesort algoritması aşağıdaki sahte kodla verilir:

procedure mergesort(l : List) {
  if ( l.length < 2 ) {
    return l
  }

  left  = mergesort(l.take(l.length / 2)
  right = mergesort(l.drop(l.length / 2)
  result = []

  while ( left.length > 0 || right.length > 0 ) {
    if ( right.length == 0 || (left.length > 0 && left.head <= right.head) ) {
      result = left.head :: result
      left = left.tail
    }
    else {
      result = right.head :: result
      right = right.tail
    }
  }

  return result.reverse
}

Doğruluğu tümevarım ile kanıtlarız. Sıfır veya bir uzunluktaki listeler için algoritma önemsizdir. Tümevarım hipotezi olarak, bazı keyfi, ancak sabit doğal için mergesortuzunluk listelerinde en fazla doğru çalıştığını varsayın . Şimdi uzunluğunun bir listesi olsun . Tümevarım hipotezleri ve ilk azalan (azalan olmayan) sıralanmış versiyonları tutun. özyinelemeli çağrılardan sonra ikinci yarısı . Bu nedenle, döngü her yinelemede henüz araştırılmamış en küçük elemanı seçer ve ekler ; böylece , tüm öğeleri içeren ven > 1 L n + 1 L $n$$n>1$$L$$n+1$leftright$L$whileresultresultleftright. Bunun tersi, döndürülen ve istenen sonuç olan azaltılmayan bir versiyonudur .$L$

Çalışma zamanına gelince, öğe karşılaştırmalarını ve çalışma zamanlarını asimptotik olarak domine eden işlemleri listeleyelim. İkiden az uzunluk listeleri de neden olmaz. uzunluk listelerinde , yinelemeli çağrılar için girişlerin, özyinelemeli çağrıların kendileri artı döngü ve bir için girişlerin hazırlanmasından kaynaklanan bu işlemlere sahibiz . Her iki özyinelemeli parametrenin her biri en fazla liste işlemi ile hesaplanabilir . Döngü tam olarak yürütülür en fazla bir elemanı karşılaştırma zamanları ve her yineleme nedenlerini ve tam iki liste operasyonları. Final kullanmak için uygulanabilirn n 2 $n>1$whilereverse$n$while$n$reverse$2n$liste işlemleri - her eleman girişten çıkarılır ve çıkış listesine eklenir. Bu nedenle, işlem sayısı aşağıdaki yinelemeyi karşılar:

$\qquad \begin{align}T(0) = T(1) &= 0 \\ T(n) &\leq T\left(\left\lceil\frac{n}{2}\right\rceil\right) + T\left(\left\lfloor\frac{n}{2}\right\rfloor\right) + 7n\end{align}$

Olarak açık azalmayan, değerlendirmek yeterlidir; asimptotik büyüme için. Bu durumda , nüks basitleşirn = 2 $T$$n=2^k$

$\qquad \begin{align}T(0) = T(1) &= 0 \\ T(n) &\leq 2T\left(\frac{n}{2}\right) + 7n\end{align}$

Ana teorem ile, çalışma zamanına kadar uzanan da alırız .$T \in \Theta(n \log n)$mergesort

Ultra düşük seviye

Mergesort'un Isabelle / HOL'daki bu (genelleştirilmiş) uygulamasını düşünün :

types dataset  =  "nat * string"

fun leq :: "dataset \<Rightarrow> dataset \<Rightarrow> bool" where
   "leq (kx::nat, dx) (ky, dy) = (kx \<le> ky)"

fun merge :: "dataset list \<Rightarrow> dataset list \<Rightarrow> dataset list" where
"merge [] b = b" |
"merge a [] = a" |
"merge (a # as) (b # bs) = (if leq a b then a # merge as (b # bs) else b # merge (a # as) bs)"

function (sequential) msort :: "dataset list \<Rightarrow> dataset list" where
  "msort []  = []" |
  "msort [x] = [x]" |
  "msort l   = (let mid = length l div 2 in merge (msort (take mid l)) (msort (drop mid l)))"
by pat_completeness auto
  termination
  apply (relation "measure length")
by simp+

Bu zaten iyi tanımlanmış ve feshedilmiş kanıtları da içermektedir. Burada (neredeyse) tam bir doğruluk kanıtı bulun .

"Çalışma zamanı", yani karşılaştırma sayısı için, önceki bölümdekine benzer bir yineleme ayarlanabilir. Master teoremini kullanmak ve sabitleri unutmak yerine, asemptotik olarak gerçek miktara eşit bir yaklaşım elde etmek için analiz edebilirsiniz. Analizin tamamını [1] 'de bulabilirsiniz; İşte kaba bir taslak (mutlaka Isabelle / HOL koduna uymuyor):

Yukarıdaki gibi, karşılaştırma sayısının tekrarlaması

$\qquad \begin{align}f_0 = f_1 &= 0 \\ f_n &= f_{\left\lceil\frac{n}{2}\right\rceil} + f_{\left\lfloor\frac{n}{2}\right\rfloor} + e_n\end{align}$

burada , kısmi sonuçların birleştirilmesi için gerekli karşılaştırma sayısı²'dir. Zemin ve tavanlardan kurtulmak için eşit olup olmadığı konusunda bir vaka ayrımı yaparız :$e_n$$n$

$\qquad \displaystyle \begin{cases} f_{2m} &= 2f_m + e_{2m} \\ f_{2m+1} &= f_m + f_{m+1} + e_{2m+1} \end{cases}$

İç içe kullanma ileri / geri farklılıkları arasında ve bunu almake $f_n$$e_n$

$\qquad \displaystyle \sum\limits_{k=1}^{n-1} (n-k) \cdot \Delta\kern-.2em\nabla f_k = f_n - nf_1$ .

Toplam, Perron formülünün sağ tarafıyla eşleşir . Bu tanımlar Dirichlet üreten serisi arasında olarak$\Delta\kern-.2em\nabla f_k$

$\qquad \displaystyle W(s) = \sum\limits_{k\geq 1} \Delta\kern-.2em\nabla f_k k^{-s} = \frac{1}{1-2^{-s}} \cdot \underbrace{\sum\limits_{k \geq 1} \frac{\Delta\kern-.2em\nabla e_k}{k^s}}_{=:\ \boxminus(s)}$

Perron'un formülü ile birlikte bizi

$\qquad \displaystyle f_n = nf_1 + \frac{n}{2\pi i} \int\limits_{3-i\infty}^{3+i\infty} \frac{\boxminus(s)n^s}{(1-2^{-s})s(s+1)}ds$ .

değerlendirilmesi hangi vakanın analiz edildiğine bağlıdır. Bunun dışında - bazı hilelerden sonra - elde etmek için kalıntı teoremini uygulayabiliriz$\boxminus(s)$

$\qquad \displaystyle f_n \sim n \cdot \log_2(n) + n \cdot A(\log_2(n)) + 1$

burada , daki değerlere sahip periyodik bir fonksiyondur .$A$$[-1,-0.9]$

1. Mellin dönüşümleri ve asimptotikler: Flajolet ve Golin tarafından yapılan birleşmenin tekrarlanması (1992)
2. En iyi durum: En kötü durum: Ortalama vaka:$e_n = \left\lfloor\frac{n}{2}\right\rfloor$
   $e_n = n-1$
   $e_n = n - \frac{\left\lfloor\frac{n}{2}\right\rfloor}{\left\lceil\frac{n}{2}\right\rceil + 1} - \frac{\left\lceil\frac{n}{2}\right\rceil}{\left\lfloor\frac{n}{2}\right\rfloor + 1}$

Dijkstra'nın "Programlama disiplini" algoritmaları analiz etmek ve ispatlamak ve ispat için tasarım yapmakla ilgilidir. Bu kitabın önsözünde Dijkstra, analiz edilmesi için uygun şekilde tasarlanmış çok basit bir şekilde inşa edilmiş bir mini dilin birçok algoritmayı resmi olarak açıklamak için nasıl yeterli olduğunu açıklıyor:

Böyle bir kitaba başlarken derhal “Hangi programlama dilini kullanacağım?” Sorusuyla karşı karşıya kalırsınız ve bu değildir.sadece bir sunum sorusu! Herhangi bir aracın en önemli, ama aynı zamanda en zorlayıcı yönü, kullanımında kendilerini eğitenlerin alışkanlıkları üzerindeki etkisidir. Araç bir programlama diliyse, bu etki - ister beğenip beğenmeyelim - düşünme alışkanlıklarımız üzerinde bir etkidir. Bu etkiyi bilgim dahilinde analiz ettikten sonra, mevcut programlama dillerinden hiçbirinin veya alt kümesinin amacım için uygun olmadığı sonucuna vardım; Öte yandan, yeni bir programlama dilinin tasarımı için kendimi çoktan biliyordum ki önümüzdeki beş yıl boyunca bunu yapmama sözü verdim ve o dönemin henüz geçmediğine dair çok belirgin bir his vardı! (Bundan önce, diğer birçok şeyin yanında, bu monografinin yazılması gerekiyordu.

Daha sonra, mini dilini ne kadar küçük başardığını açıklıyor.

Okuyucuya mini dili neden bu kadar küçük tuttuğumun prosedürleri ve özyinelemeyi bile içermediğini açıklıyorum. ... Mesele şu ki, mesajımı iletmek için onlara ihtiyaç duymadım, yani. yüksek kaliteli programların tasarımı için endişelerin ayrılmasını ne kadar dikkatlice seçtiğini; mini dilin mütevazı araçları bize önemsiz, ancak çok tatmin edici tasarımlar için fazlasıyla yeterli enlem verdi.