Ne özellikleridir

Bazen dikkatle incelediğim bir algoritmanın zaman karmaşıklığını tanımlamak kolaydır. İki iç içe döngüsüne sahip algoritmalar açıkça . İki değerden oluşan gruplarının tüm olası kombinasyonlarını araştıran algoritmalar açıkça .N 2 N 2 $N$$N^2$$N$$2^N$

Ancak karmaşıklığı ile bir algoritma "nasıl" bilmiyorum . Örneğin, özyinelemeli bir birleştirme uygulaması gerçekleştirilebilir. Birleştirme veya diğer algoritmalarının, analiz edersem bana ipucu verecek ortak özellikleri nelerdir ?Θ ( N log N $\Theta(N \log N)$$\Theta(N \log N)$

Eminim bir algoritma karmaşıklığı olabilir, bu yüzden herhangi ve tüm cevaplar takdir birden fazla yolu vardır. BTW Sıkı kanıtlar değil, genel özellikler ve ipuçları arıyorum.$\Theta(N \log N)$

İşletme Arketipsel a, bölme ve fethet algoritması, bölme (ve yeniden birleşir) çalışma lineer zaman ve parçalar üzerinde recurses. Birleştirme sıralaması şu şekilde çalışır: girdiyi kabaca eşit iki parçaya bölerek zaman harcar, her parçayı özyineli olarak sıralar ve sıralanan iki yarıyı birleştirerek zaman harcar .$\Theta(n \log n)$$O(n)$$\Theta(n)$

Sezgisel olarak, böl ve fethet fikrini sürdürürken, her bölme aşaması toplamda doğrusal zaman alır, çünkü bölmek için parça sayısındaki artış, bölme tarafından alınan zaman doğrusal olduğundan, parçaların boyutundaki azalmayla tam olarak eşleşir. Toplam çalışma süresi, bir bölüm aşamasının toplam maliyetinin, bölüm aşamalarının sayısıyla çarpımıdır. Parçaların boyutu her seferinde yarıya indirildiğinden bölüm aşamaları olduğundan toplam çalışma süresi . (Çarpıcı bir sabite kadar, logaritmanın tabanı önemsizdir.)$\log_2(n)$$n \cdot \log(n)$

Denklemlere () koymak , böyle bir algoritmanın çalışma süresini tahmin etmenin bir yolu onu tekrar tekrar ifade etmektir: . Bu algoritmanın doğrusal zamandan daha fazla sürdüğü açıktır ve : iki katına çıktığında , sabit bir miktarda artar: logaritmik olarak veya başka bir deyişle artar .$T(n)$$T(n) = 2 T(n/2) + \Theta(n)$$n$

Bu daha genel bir kalıp örneğidir: ana teorem . Herhangi bir yinelemeli algoritması için bu bölme büyüklüğü, giriş içine ebatta parçalar ve bir zaman alır bölünme ve birleşmeyi gerçekleştirmek üzere, çalışma süresi tatmin . Bu, ve değerlerine ve şekline bağlı olan kapalı bir forma yol açar . Eğer ve , olduğu ana teoremi durumları .$n$$a$$n/b$$f(n)$$T(n) = a \cdot T(n/b) + f(n)$$a$$b$$f$$a = b$$f(n) = \Theta(n)$$T(n) = \Theta(n \log n)$

zaman alan diğer iki algoritma kategorisi :$\Theta(n \log n)$

Her bir öğenin sırayla işlendiği algoritmalar ve her öğenin işlenmesi logaritmik zaman alır (örneğin, HeapSort veya düzlemin çoğunun hesaplama geometrisi algoritmalarını süpürür).

Çalışma süresinin bir sıralama ön işleme adımının hakim olduğu algoritmalar. (Örneğin, Kruskal'ın minimum yayılan ağaç algoritmasında, ilk adım olarak kenarları ağırlık olarak sıralayabiliriz).

$\Theta(n \log n)$$\Theta(n \log n)$

Bu tür algoritmaların ayrıntıları genellikle bölme ve fethetme tekniklerini kullanıyor olsa da, zorunlu olarak bunu yapmak zorunda değildir. Çalışma zamanı temelde sorulan sorudan gelir ve bu yüzden ayrı ayrı bahsetmeye değer olduğunu düşünüyorum.

Bu, her düğümün o düğümün alt ağacındaki yapraklar üzerinde arama yapmak için doğrusal boyutlu bir veri yapısı depoladığı artırılmış bir ikili arama ağacına dayanan veri yapılarında ortaya çıkar. Bu tür veri yapıları genellikle geometrik aralık araştırmasında ortaya çıkar ve genellikle bir ayrışma şemasına dayanır . Bakınız Agarwal Anketi .

$O(n \log n)$$O(\log n)$

$O(n\log n)$$k$$O(n)$$O(n)$$O(n)$

Bunlar tipik olarak, “böl ve fethet” çeşidinin algoritmalarıdır; burada, bölünmeleri bölme ve birleştirme maliyeti “çok büyük” değildir. Bu davranışa ne tür yinelemelerin yol açtığını görmek için bu SSS'ye göz atın .

Tipik olarak, Böl ve fethet algoritmaları O (N log N) karmaşıklığı verir.

$O(n \log n)$

for (i = 0; i < constant; i++){
    for(j = 0; j < n; j++){
        // Do some O(1) stuff on the input
    }
}

// Alternative Variant:
for (i = 0; i < constant; i++){
    for(j = n; j < constant; j++){
        // Do some O(1) stuff on the input
    }
}

$O(n^2)$

Bu döngüyü kullanan bir algoritmanın somut bir örneğini veremiyorum, ancak özel algoritmaları kodlarken sıklıkla ortaya çıkıyor.