Neden mergesort O (log n)?

Mergesort bir bölme ve fethetme algoritmasıdır ve O (log n) 'dir, çünkü giriş art arda yarıya indirilir. Ancak bu O (n) olmamalı, çünkü giriş her döngü yarıya inmiş olsa bile, her bir yarı dizi içinde değiş tokuş yapmak için her giriş öğesinin yinelenmesi gerekir mi? Bu aslında aklımda asimptotik olarak O (n) 'dir. Mümkünse lütfen örnekler verin ve işlemlerin doğru sayılmasını açıklayın! Henüz bir şey kodlamadım ama çevrimiçi algoritmalara bakıyorum. Ayrıca mergesort'un nasıl çalıştığını görsel olarak göstermek için wikipedia'un kullandığı bir gif ekledim.

O (n * log (n)), O (log (n)) değil. Doğru bir şekilde tahmin ettiğiniz gibi, girişin tamamı yinelenmeli ve bu O (log (n)) kez yapılmalıdır (giriş sadece O (log (n)) kez kesilebilir). n yinelenen log (n) çarpı sayısı O (n log (n)) olur.

Hiçbir karşılaştırma türünün bundan daha hızlı çalışamayacağı kanıtlanmıştır. Yalnızca radix sort gibi özel bir özelliğe dayanan türler bu karmaşıklığı yenebilir. Mergesort'un sabit faktörleri tipik olarak o kadar iyi değildir, bu yüzden daha kötü karmaşıklıktaki algoritmalar çoğu zaman daha az zaman alabilir.

Birleştirme türünün karmaşıklığı, O (nlogn) ve NOT O (logn) 'dir.

Birleştirme sıralama bir bölme ve fethetme algoritmasıdır. 3 adımda düşünün -

1. Bölme adımı, alt dizilerin her birinin orta noktasını hesaplar. Bu adımın her biri sadece O (1) zaman alır.
2. Fetih aşaması, n / 2 (hatta n) elemanlarının her iki alt dizisini tekrarlı bir şekilde sıralar.
3. Birleştirme adımı, O (n) zamanı alan n öğelerini birleştirir.

Şimdi, adım 1 ve 3 için, yani O (1) ve O (n) arasında, O (n) daha yüksektir. 1 ve 3 numaralı adımların toplamda O (n) zaman alacağını düşünelim. Bazı sabitler için cn olduğunu söyleyin c.

Bu adımlar kaç kez uygulanır?

Bunun için, aşağıdaki ağaca bakın - her seviye için yukarıdan aşağıya Seviye 2, her biri n / 2 uzunluktaki 2 alt dizide birleştirme yöntemini çağırır. Buradaki karmaşıklık 2 * (cn / 2) = cn Seviye 3, her biri n / 4 uzunluğunda 4 alt dizide birleştirme yöntemini çağırıyor. Buradaki karmaşıklık 4 * (cn / 4) = cn ve diğerleri ...

Şimdi, bu ağacın yüksekliği verilen n için (logn + 1). Böylece genel karmaşıklık (logn + 1) * (cn) olur. Bu birleştirme sıralama algoritması için O (nlogn) 'dir.

Resim kredisi: Khan Academy

Birleştirme Sıralaması özyinelemeli bir algoritmadır ve zaman karmaşıklığı tekrarlama ilişkisinin ardından ifade edilebilir.

T (n) = 2T (n / 2) + ɵ (n)

Yukarıdaki nüks, Nüks Ağacı yöntemi veya Master yöntemi kullanılarak çözülebilir. Master Metodunun II olması durumunda düşer ve nüksün çözümü ɵ (n log n) olur.

Birleştirme Sıralama zaman karmaşıklığı ity (nLogn) her 3 durumda da (en kötü, ortalama ve en iyi) birleştirme sıralama her zaman diziyi iki yarıya böler ve iki yarıyı birleştirmek için doğrusal zaman alır.

Giriş dizisini iki yarıya böler, kendisini iki yarıya çağırır ve ardından iki yarı yarıyı birleştirir. Merg () işlevi iki yarıyı birleştirmek için kullanılır. Birleştirme (arr, l, m, r), arr [l..m] ve arr [m + 1..r] 'nin sıralandığını ve iki sıralanmış alt diziyi bir araya getirdiğini varsayan anahtar işlemdir. Ayrıntılar için aşağıdaki C uygulamasını inceleyiniz.

MergeSort(arr[], l,  r)
If r > l
     1. Find the middle point to divide the array into two halves:  
             middle m = (l+r)/2
     2. Call mergeSort for first half:   
             Call mergeSort(arr, l, m)
     3. Call mergeSort for second half:
             Call mergeSort(arr, m+1, r)
     4. Merge the two halves sorted in step 2 and 3:
             Call merge(arr, l, m, r)

Diyagrama daha yakından bakarsak, dizinin boyut 1'e gelinceye kadar tekrarlı olarak iki yarıya bölündüğünü görebiliriz. Boyut 1 olduğunda, birleştirme işlemleri devreye girer ve dizinin tamamı dizinin sonuna kadar birleştirilmesi başlar. birleşti.

Karşılaştırma tabanlı sıralama algoritmaları daha düşük bir sınırlamaya sahiptir 𝞨(n*log(n)), bu da O(log(n))zaman karmaşıklığı ile karşılaştırma tabanlı bir sıralama algoritmasına sahip olmanın mümkün olmadığı anlamına gelir .

Bu arada, birleştirme sıralama O(n*log(n)). Bu şekilde düşün.

[ a1,a2,         a3,a4,         a5,a6,          a7,a8     .... an-3,an-2,     an-1, an ] 
   \ /            \  /           \ /             \  /            \  /            \  /    
    a1'            a3'            a5'             a7'            an-3'           an-1'    
      \            /                \             /                 \             /
            a1''                          a5''                       an-3''
             \                             /                         /
                          a1'''                                     /
                           \
                                              a1''''

Bu ters bir ikili ağaç görünüyor.

Giriş boyutu olsun n.

Her biri a_nbir öğeler listesini temsil eder. İlk satırın a_nsadece bir elemanı var.

Her seviyede, ortalama birleştirme maliyetinin toplamı ( nmaliyetin düşük olduğu köşe vakaları vardır [1]). Ve ağacın yüksekliği log_2(n).

Yani, birleştirme türünün zaman karmaşıklığı O(n*log_2(n)).

[1] önceden sıralanmış bir listede sıralama yapıyorsanız, buna en iyi durum denir. Maliyet düşürüldü n/2 + n/4 + n/8 + .... + 1 = 2^log_2(n) -1 ~ O(n). (uzunluğu niki güç olduğunu varsayalım )

Sıralama bilgisayar bilimlerinde NP-Komple bir problemdir (Polinom Dışı Problem). Bu, matematiksel olarak kanıtlanmadığı sürece, bir öğe listesi sıralarken O (n log n) seviyesinin altına düşemeyeceğiniz anlamına gelir.

Bu makaleyi Wikipedia'da okuyun ( https://en.wikipedia.org/wiki/P_versus_NP_problem )

Temelde şu ana kadar kimse bunu ispatlayamadı (P == NP) ve yaparsanız, önce milyoner olursunuz, ikincisi, kullanılan tüm pub / özel kilit güvenlik mekanizmalarını kırabileceğinizden dolayı, dünya savaşına III. bugünlerde her yerde :)