Bogosort'tan (Maymun Sıralama olarak da bilinir) daha kötü sıralama algoritmaları var mı? [kapalı]

İş arkadaşlarım beni bu sabah sıralama algoritmaları tartışmasıyla Üniversite günlerime geri götürdü. StupidSort gibi favorilerimizi anlattık ve içimizden biri, bir sıralama algoritması gördüğümüzden emindi O(n!). Bu, bulabildiğim "en kötü" sıralama algoritmalarını aramaya başladı.

Tamamen rastgele bir sıralamanın oldukça kötü olacağını varsaydık (yani öğeleri rastgele sıralayın - sırayla mı? Hayır? Tekrar rasgele) ve etrafa baktım ve görünüşe göre BogoSort veya Maymun Sıralaması veya bazen sadece Rasgele Sıralama olarak adlandırıldığını öğrendim .

Monkey Sort en kötü vaka performansına O(∞), en iyi vaka performansına O(n)ve ortalama performansına sahip gibi görünüyor O(n·n!).

En kötü ortalama sıralama performansına sahip resmi kabul edilen sıralama algoritması O(n·n!)nedir?

Gönderen David Morgan-Mar 'ın Ezoterik Algoritmalar sayfa: Akıllı Tasarım Sıralama

Giriş

Akıllı tasarım sıralama, akıllı tasarım teorisine dayanan bir sıralama algoritmasıdır.

Algoritma Tanımı

Orijinal giriş listesinin tam sırayla olma olasılığı 1 / (n!). Bunun o kadar küçük bir olasılığı var ki, bunun tesadüfen gerçekleştiğini söylemek saçmadır, bu yüzden akıllı bir Sıralayıcı tarafından bilinçli olarak bu sıraya konmuş olmalıdır. Bu nedenle, naif ölümlü “artan düzen” anlayışımızı aşan bir şekilde zaten optimum şekilde sıralandığını varsaymak güvenlidir. Kendi önyargılarımıza uyması için bu düzeni değiştirme girişimleri aslında daha az sıralı hale getirecektir.

analiz

Bu algoritma zaman içinde sabittir ve ek bellek gerektirmeden listeyi yerinde sıralar. Aslında, bu şüpheli teknolojik bilgisayar malzemelerini bile gerektirmez. Sıralayıcıyı övün!

geri bildirim

Gary Rogers şöyle yazıyor:

Sıralamayı zamanında sabitlemek Sıralayıcının gücünü reddediyor. Sıralayıcı zamanın dışında var, bu yüzden sıralama zamansız. Sıralamanın doğrulanması için zamana ihtiyaç duyulması, Sıralayıcının rolünü azaltır. Böylece ... bu tür kusurludur ve 'Sıralayıcıya' atfedilemez.

Sapkınlık!

Yıllar önce, MiracleSort'u icat ettim (ama aslında hiç uygulamadı).

Start with an array in memory.
loop:
    Check to see whether it's sorted.
    Yes? We're done.
    No? Wait a while and check again.
end loop

Sonunda, bellek yongalarındaki bitleri çeviren alfa parçacıkları başarılı bir sıralama ile sonuçlanmalıdır.

Daha fazla güvenilirlik için diziyi korumalı bir konuma kopyalayın ve potansiyel olarak sıralanmış dizileri orijinal ile karşılaştırarak kontrol edin.

Peki, potansiyel olarak sıralanmış diziyi orijinaline göre nasıl kontrol edersiniz? Her diziyi sıralayıp eşleşip eşleşmediğini kontrol edersiniz. MiracleSort bu adım için kullanılacak bariz bir algoritmadır.

EDIT: Kesin olarak, bu bir algoritma değildir, çünkü sona erdirilmesi garanti edilmez. "Bir algoritma", "daha kötü bir algoritma" olarak nitelendiriliyor mu?

Kuantum Bogosort

Kuantum mekaniğinin birçok dünya yorumunun doğru olduğunu varsayan bir sıralama algoritması:

1. Listenin sıralandığını kontrol edin. Değilse, evreni yok et.

Algoritmanın sonunda, liste ayakta kalan tek evrende sıralanacaktır. Bu algoritma en kötü durum O (N) ve ortalama durum O (1) zaman alır. Aslında, yapılan ortalama karşılaştırma sayısı 2'dir: evrenin ikinci elementte imha edilme şansı% 50, üçüncü elementte imha edilme şansı% 25, ​​vb.

Henüz kimsenin pijamadan bahsetmediğine şaşırdım ... Yoksa fark etmedim mi? Neyse:

#!/bin/bash
function f() {
    sleep "$1"
    echo "$1"
}
while [ -n "$1" ]
do
    f "$1" &
    shift
done
wait

örnek kullanım:

./sleepsort.sh 5 3 6 3 6 3 1 4 7
./sleepsort.sh 8864569 7

Performans açısından korkunç (özellikle ikinci örnek). 2 sayı sıralamak için yaklaşık 3.5 ay beklemek biraz kötü.

Burada açıklandığı gibi Jingle Sort .

Listenizdeki her bir değeri Noel'de farklı bir çocuğa verirsiniz. Çocuklar, korkunç insanlar olarak, armağanlarının değerini karşılaştıracak ve kendilerini buna göre sıralayacaktır.

Ben bir kez rasgele bir dizi oluşturma önerdi, sıralanmış olup olmadığını kontrol ve daha sonra veri sıralanacak dizi ile aynı olup olmadığını kontrol eden bir öğretim görevlisi vardı.

En iyi durum O (N) (ilk kez bebek!) En kötü durum O (Asla)

Algoritmayı herhangi bir şekilde anlamlı O(n!)tutarsanız, elde edebileceğiniz en kötü üst sınırdır.

Bir kümenin permütasyonlarının sıralanması için her olasılığı kontrol etmek n!adım atacağından , bundan daha kötü olamazsınız.

Bundan daha fazla adım atıyorsanız, algoritmanın gerçek bir yararlı amacı yoktur. Aşağıdaki basit sıralama algoritmasından bahsetmiyorum bile O(infinity):

list = someList
while (list not sorted):
    doNothing

Bogobogosort. Evet, bir şey. Bogobogosort'a ilk unsur Bogosort. Bir öğenin sıralanıp sıralanmadığını kontrol edin. Bir unsur olmak, öyle olacak. Sonra ikinci öğeyi ve sıralanana kadar bu ikisini Bogosort ekleyin. Sonra bir eleman daha eklersiniz Bogosort. Sonunda her bir öğeyi yapana kadar öğeler ve Bogosorting eklemeye devam edin. Bu, evrenin sıcak ölümünden önce hiçbir zaman büyük bir listeyle başaramayacak şekilde tasarlandı.

Pessimal Algoritmalar ve Simpleksite Analizi'nin heyecan verici alanına biraz araştırma yapmalısınız . Bu yazarlar, kötümser en iyi durumla bir tür geliştirme sorunu üzerinde çalışırlar (bogosort'unuzun en iyi durumu Omega (n), slowsort (kağıda bakın) polinom olmayan en iyi durum karmaşıklığına sahiptir).

Bogobogosort adı verilen bir tür var. İlk olarak, ilk 2 unsuru kontrol eder ve bogosorts yapar. Daha sonra ilk 3'ü kontrol eder, bogosorts, vb.

Liste herhangi bir zamanda bozulursa, ilk 2'yi yeniden sıralayarak yeniden başlar. Düzenli bogosort ortalama karmaşıklığına sahiptir O(N!), bu algoritma ortalama karmaşıklığına sahiptir.O(N!1!2!3!...N!)

Düzenleme : bu sayı, için ne kadar büyük bir fikir vermek için 20elemanları, bu algoritma bir ortalama alır 3.930093*10^158 yıl içinde (olur ise) iyi evrenin konu ısı ölümü üzerine, 10^100 yıllardır ,

ancak birleştirme sıralaması .0000004 saniyeler , kabarcık sıralaması .0000016 saniyeler ve bogosort bir yıl 365.242 gün ve bir bilgisayar saniyede 250.000.000 32 bit tamsayı işlemi yaptığını varsayarak 308 yıllar , 139 günler , 19 saatler , 35 dakikalar , 22.306 saniyeler alır .

Edit2 : Bu algoritma "algoritma" mucize sıra kadar yavaş değil, muhtemelen, bu tür gibi, başarıyla 20 elemtts sıralar önce bilgisayar kara delik emilir alacak, ama eğer öyleyse, ortalama bir karmaşıklık tahmin ediyorum arasında 2^(32(the number of bits in a 32 bit integer)*N)(the number of elements)*(a number <=10^40) yıllar ,

yerçekimi alfa hareketini hızlandırdığı için ve 2 ^ N durumu vardır 2^640*10^40, ya da yaklaşık 5.783*10^216.762162762 yıllardır , ancak liste sıralanırsa, karmaşıklığı sadece O(N)birleştirme sıralamasından daha hızlı olurdu , sadece N log N bile en kötü durumda.

Edit3 : Bu algoritma boyutu 1000 çok büyük olduğundan, mucize sıralama daha yavaştır, çünkü algoritmamın çalışma süresi 2.83*10^1175546 yıl olurken, mucize sıralama algoritması çalışma süresi 1.156*10^9657 yıl olacaktır .

İşte üniversitede oda arkadaşımla geldiğim 2 çeşit

1) Siparişi kontrol edin 2) Belki bir mucize oldu, 1'e gidin

ve

1) uygun olup olmadığını kontrol edin, değilse 2) her bir elemanı bir pakete koyun ve uzaktaki bir sunucudan kendinize geri döndürün. Bu paketlerin bazıları farklı bir sırayla geri dönecek, bu yüzden 1'e gidin

Her zaman Bogobogosort vardır (Bogoception!). Listenin gittikçe daha büyük alt kümelerinde Bogosort'u gerçekleştirir ve daha sonra liste hiç sıralanmazsa baştan başlar.

for (int n=1; n<sizeof(list); ++n) {
  while (!isInOrder(list, 0, n)) {
    shuffle(list, 0, n);
  }
  if (!isInOrder(list, 0, n+1)) { n=0; }
}

1 Eşyalarınızı dizin kartlarına göre
sıralayın 2 Rüzgarlı bir günde, evinizden bir mil uzakta havaya atın.
2 Bir şenlik ateşine atın ve tamamen yok olduklarını onaylayın.
3 Mutfak zemininizde doğru sipariş olup olmadığını kontrol edin.
4 Doğru sipariş değilse bu işlemi tekrarlayın.

En iyi senaryo O (∞)

Düzen yukarıda KennyTM tarafından zeki gözleme dayalı.

"Ne olmasını istersiniz?" çeşit

1. Sistem saatini not edin.
2. Quicksort'u (ya da makul olarak makul olan herhangi bir şeyi) kullanarak, son takası atlayarak sıralama.
3. Sistem saatini not edin.
4. Gerekli zamanı hesaplayın. Genişletilmiş hassasiyet aritmetiği bir gerekliliktir.
5. Gerekli zamanı bekleyin.
6. Son değiştirme işlemini gerçekleştirin.

Sonsuzluktan dolayı akla gelebilecek herhangi bir O (x) değeri uygulamakla kalmaz, aynı zamanda alınan zaman da doğrudur (bu kadar bekleyebilirseniz).

Sonsuzluktan daha kötü bir şey olamaz.

Bozo sort, listenin sıralanıp sıralanmadığını kontrol eden ve değilse iki öğeyi rastgele değiştiren ilgili bir algoritmadır. Aynı en iyi ve en kötü durum performanslarına sahiptir, ancak sezgisel olarak ortalama davanın Bogosort'tan daha uzun olmasını beklerim. Bu algoritmanın performansı hakkında herhangi bir veri bulmak (veya üretmek) zordur.

Π segmentleri

Varsayalım possible tüm olası sonlu sayı kombinasyonlarını içerir. Math.stackexchange sorusuna bakın

1. Dizinin boyutundan gereken basamak sayısını belirleyin.
2. Dizinin nasıl yeniden sıralanacağını belirlemek için π yerlerinin segmentlerini dizin olarak kullanın. Bir segment bu dizi için boyut sınırlarını aşarsa, π ondalık uzaklığı ayarlayın ve baştan başlayın.
3. Yeniden sipariş edilen dizinin sıralanıp sıralanmadığını kontrol edin. Eğer woot ise, ofseti ayarlayın ve baştan başlayın.

O (∞) en kötü durum performansı onu bazılarına göre bir algoritma bile yapmayabilir .

Bir algoritma sadece bir dizi adımdır ve istenen çıktıyı daha önce attığından daha fazla adımda almak için biraz değiştirerek her zaman daha kötüsünü yapabilirsiniz. Bir kişi bilerek atılan adım sayısı bilgisini algoritmaya sokabilir ve sadece Xadım sayısı yapıldıktan sonra sonlandırıp doğru çıktıyı üretebilir . Bu Xçok iyi O (n ² ) veya O (n ^n! ) Ya da yapmak istediginiz algoritma olabilir. Bu, en iyi durumun yanı sıra ortalama vaka sınırlarını da etkili bir şekilde artıracaktır.

Ama en kötü senaryo üstesinden gelemez :)

En sevdiğim yavaş sıralama algoritması stooge sıralama:

void stooges(long *begin, long *end) {
   if( (end-begin) <= 1 ) return;
   if( begin[0] < end[-1] ) swap(begin, end-1);
   if( (end-begin) > 1 ) {
      int one_third = (end-begin)/3;
      stooges(begin, end-one_third);
      stooges(begin+one_third, end);
      stooges(begin, end-one_third);
   }
}

En kötü durum karmaşıklığı O(n^(log(3) / log(1.5))) = O(n^2.7095...).

Başka bir yavaş sıralama algoritmasına aslında slowsort adı verilir!

void slow(long *start, long *end) {
   if( (end-start) <= 1 ) return;
   long *middle = start + (end-start)/2;
   slow(start, middle);
   slow(middle, end);
   if( middle[-1] > end[-1] ) swap(middle-1, end-1);
   slow(start, end-1);
}

Bu O(n ^ (log n))en iyi durumda olur ... stoogesort'tan bile daha yavaş.

Recursive Bogosort (probably still O(n!){
if (list not sorted)
list1 = first half of list.
list 2 = second half of list.
Recursive bogosort (list1);
Recursive bogosort (list2);
list = list1 + list2
while(list not sorted)
    shuffle(list);
}

Bu sayfa konuyla ilgili ilginç bir okuma: http://home.tiac.net/~cri_d/cri/2001/badsort.html

Benim kişisel favorim Tom Duff'ın aptallığı:

/*
 * The time complexity of this thing is O(n^(a log n))
 * for some constant a. This is a multiply and surrender
 * algorithm: one that continues multiplying subproblems
 * as long as possible until their solution can no longer
 * be postponed.
 */
void sillysort(int a[], int i, int j){
        int t, m;
        for(;i!=j;--j){
                m=(i+j)/2;
                sillysort(a, i, m);
                sillysort(a, m+1, j);
                if(a[m]>a[j]){ t=a[m]; a[m]=a[j]; a[j]=t; }
        }
}

Çift bogosort

İki kez Bogosort yapın ve sonuçları tekrar karşılaştırın (karşılaştırıldığından emin olmak için)

Herhangi bir sıralama algoritmasını "sıralandı mı" adımınızı rastgele çalıştırarak yavaşlatabilirsiniz. Gibi bir şey:

1. Sıraladığınız diziyle aynı boyutta booleans dizisi oluşturun. Hepsini yanlış olarak ayarlayın.
2. Bogosort yinelemesi yapma
3. İki rastgele eleman seçin.
4. İki öğe birbiriyle ilişkili olarak sıralanıyorsa (i <j && dizi [i] <dizi [j]), boolean dizisindeki her ikisinin dizinlerini true olarak işaretleyin. Tersine, baştan başlayın.
5. Dizideki tüm boolean'ların doğru olup olmadığını kontrol edin. Değilse, 3'e geri dönün.
6. Bitti.

Evet, SimpleSort teoride o çalışır O(-1)ancak bu eşdeğerO(...9999) dönüş eşdeğeri olduğu için O (∞ - 1), olduğu gibi hangi zamanda eşdeğerdir için O (∞). İşte benim örnek uygulama:

/* element sizes are uneeded, they are assumed */
void
simplesort (const void* begin, const void* end)
{
  for (;;);
}

Sadece üzerinde çalıştığım biri, iki rastgele nokta seçmeyi içeriyor ve yanlış sıradalarsa, aralarındaki tüm alt menzili tersine çevirmek. Algoritmayı http://richardhartersworld.com/cri_d/cri/2001/badsort.html adresinde buldum, bu da ortalama durumun muhtemelen O (n ^ 3) veya O (n ^ 2 log n) ( o gerçekten emin değil).

Daha verimli bir şekilde yapmak mümkün olabileceğini düşünüyorum, çünkü O (1) zamanında tersine çevirme işlemini yapmak mümkün olabileceğini düşünüyorum.

Aslında, bunu yapmanın belki de söylediğim her şeyi yapacağını fark ettim, çünkü sadece aklımdaki veri yapısının O (log n) 'deki rasgele öğelere erişmeyi ve O (n ).

Randomsubsetsort.

Bir n eleman dizisi verildiğinde, 1 / n olasılığı olan her elemanı seçin, bu elemanları rastgele seçin ve dizinin sıralanıp sıralanmadığını kontrol edin. Sıralanana kadar tekrarlayın.

Beklenen süre okuyucu için bir alıştırma olarak bırakılmıştır.