มีอัลกอริทึมการเรียงลำดับที่แย่กว่า Bogosort (หรือที่รู้จักกันในชื่อว่า Monkey Sort) หรือไม่? [ปิด]

เพื่อนร่วมงานของฉันพาฉันย้อนเวลากลับไปที่มหาวิทยาลัยของฉันด้วยการอภิปรายเกี่ยวกับขั้นตอนวิธีการเรียงลำดับในเช้านี้ เราระลึกถึงรายการโปรดของเราเช่น StupidSortO(n!)และคนของเราได้รับการแน่ใจว่าเราได้เห็นขั้นตอนวิธีการจัดเรียงที่เป็น นั่นทำให้ฉันเริ่มมองหาอัลกอริธึมการเรียงลำดับที่แย่ที่สุดที่ฉันหาได้

เราตั้งสมมติฐานว่าการเรียงลำดับแบบสุ่มสมบูรณ์จะค่อนข้างแย่ (เช่นการสุ่มองค์ประกอบ - เป็นไปตามลำดับหรือไม่ไม่สุ่มอีกครั้ง) และฉันมองไปรอบ ๆ และพบว่ามันถูกเรียกอย่างชัดเจนว่า BogoSort หรือ Monkey Sort หรือบางครั้งแค่เรียงแบบสุ่ม .

Monkey Sort ดูเหมือนจะมีประสิทธิภาพเคสที่แย่ที่สุดO(∞)ซึ่งเป็นประสิทธิภาพเคสที่ดีที่สุดO(n)O(n·n!)และผลการดำเนินงานเฉลี่ยของ

คืออะไรอย่างเป็นทางการในขณะนี้ได้รับการยอมรับขั้นตอนวิธีการเรียงลำดับการเรียงลำดับมีประสิทธิภาพการทำงานเฉลี่ยที่เลวร้ายที่สุด (และก่อนมี beeing เลวร้ายยิ่งกว่าO(n·n!))?

จากหน้าอัลกอริทึมลึกลับของDavid Morgan-Mar : การออกแบบที่ชาญฉลาด

บทนำ

การออกแบบที่ชาญฉลาดเป็นขั้นตอนวิธีการเรียงลำดับตามทฤษฎีของการออกแบบที่ชาญฉลาด

คำอธิบายอัลกอริทึม

ความน่าจะเป็นของรายการอินพุตดั้งเดิมที่อยู่ในลำดับที่แน่นอนคือ 1 / (n!) มีความเป็นไปได้เล็ก ๆ น้อย ๆ ที่มันไร้สาระอย่างชัดเจนที่จะบอกว่าสิ่งนี้เกิดขึ้นโดยบังเอิญดังนั้นจึงต้องมีการเรียงลำดับอย่างมีสติโดยนักเรียงลำดับอัจฉริยะ ดังนั้นจึงปลอดภัยที่จะสมมติว่ามันถูกจัดเรียงอย่างเหมาะสมแล้วในวิธีที่เหนือกว่าความเข้าใจอันไร้มนุษยธรรมของเราเกี่ยวกับ "ลำดับจากน้อยไปมาก" ความพยายามใด ๆ ที่จะเปลี่ยนคำสั่งนั้นเพื่อให้สอดคล้องกับความคิดของเราจริง ๆ แล้วจะทำให้เรียงลำดับน้อยลง

การวิเคราะห์

อัลกอริทึมนี้คงที่ในเวลาและเรียงลำดับรายการในสถานที่โดยไม่ต้องการหน่วยความจำเพิ่มเติมเลย อันที่จริงแล้วมันไม่จำเป็นต้องมีสิ่งที่น่าสงสัยในด้านเทคโนโลยีคอมพิวเตอร์ สรรเสริญตัวเรียงลำดับ!

ผลตอบรับ

Gary Rogers เขียน:

การจัดเรียงค่าคงที่ในเวลาปฏิเสธพลังของตัวเรียงลำดับ ตัวเรียงลำดับอยู่นอกเวลาดังนั้นการเรียงลำดับจึงเป็นอมตะ หากต้องการเวลาในการตรวจสอบความถูกต้องของการเรียงลำดับจะลดบทบาทของ Sorter ดังนั้น ... การเรียงลำดับนี้มีข้อบกพร่องและไม่สามารถนำมาประกอบกับ 'ตัวเรียงลำดับ'

บาป!

หลายปีที่ผ่านมาฉันคิดค้น (แต่ไม่เคยนำมาใช้จริง) MiracleSort

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

ในที่สุดอนุภาคแอลฟาพลิกบิตในชิปหน่วยความจำควรส่งผลให้เรียงลำดับที่ประสบความสำเร็จ

เพื่อความน่าเชื่อถือที่มากขึ้นให้คัดลอกอาร์เรย์ไปยังตำแหน่งที่มีการป้องกันและตรวจสอบอาร์เรย์ที่เรียงจากเดิม

ดังนั้นคุณจะตรวจสอบแถวเรียงที่อาจเกิดขึ้นกับต้นฉบับได้อย่างไร คุณเพียงแค่จัดเรียงแต่ละแถวแล้วตรวจสอบว่าตรงกันหรือไม่ MiracleSort เป็นอัลกอริทึมที่ชัดเจนสำหรับใช้ในขั้นตอนนี้

แก้ไข:พูดอย่างเคร่งครัดนี่ไม่ใช่อัลกอริทึมเนื่องจากไม่รับประกันว่าจะยุติ "ไม่ใช่อัลกอริทึม" มีคุณสมบัติเป็น "อัลกอริทึมที่แย่กว่า" หรือไม่

Quantum Bogosort

อัลกอริธึมการเรียงลำดับที่สมมติว่าการตีความกลศาสตร์ควอนตัมในหลาย ๆ โลกนั้นถูกต้อง:

1. ตรวจสอบว่ารายการเรียงลำดับแล้ว ถ้าไม่ทำลายจักรวาล

ในตอนท้ายของอัลกอริทึมรายการจะถูกจัดเรียงในเอกภพที่เหลือเท่านั้น อัลกอริธึมนี้ใช้เวลาตัวพิมพ์เล็กที่สุด (O) และเวลาเฉลี่ย O (1) ในความเป็นจริงจำนวนการเปรียบเทียบโดยเฉลี่ยคือ 2: มีโอกาส 50% ที่จักรวาลจะถูกทำลายในองค์ประกอบที่สองโอกาส 25% ที่มันจะถูกทำลายในวันที่สามและต่อไป

ฉันประหลาดใจที่ไม่มีใครพูดถึง sleepsort เลย ... หรือฉันไม่ได้สังเกต อย่างไรก็ตาม:

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

ตัวอย่างการใช้งาน:

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

ในแง่ของประสิทธิภาพมันแย่มาก (โดยเฉพาะตัวอย่างที่สอง) รอเกือบ 3.5 เดือนเพื่อเรียงลำดับหมายเลข 2 นั้นค่อนข้างแย่

Jingle Sort ดังที่อธิบายไว้ที่นี่ที่นี่

คุณให้แต่ละค่าในรายการของคุณกับเด็กที่แตกต่างกันในวันคริสต์มาส เด็กซึ่งเป็นมนุษย์ที่น่ากลัวจะเปรียบเทียบมูลค่าของของขวัญและเรียงลำดับตนเองตามนั้น

ฉันมีอาจารย์ที่เคยแนะนำให้สร้างอาเรย์สุ่มตรวจสอบว่ามันถูกเรียงลำดับแล้วตรวจสอบว่าข้อมูลนั้นเหมือนกับอาร์เรย์ที่จะเรียงลำดับหรือไม่

กรณีที่ดีที่สุด O (N) (เป็นครั้งแรกที่รัก!) กรณีที่เลวร้ายที่สุด O (ไม่เคย)

หากคุณรักษาอัลกอริทึมให้มีความหมายไม่ว่าในทางใด O(n!)ขอบเขตบนที่แย่ที่สุดที่คุณสามารถทำได้คือ

ตั้งแต่การตรวจสอบความเป็นไปได้สำหรับการเรียงสับเปลี่ยนของแต่ละชุดจะทำn!ตามขั้นตอนคุณจะไม่เลวร้ายไปกว่านั้น

หากคุณกำลังทำขั้นตอนมากกว่านั้นอัลกอริทึมไม่มีวัตถุประสงค์ที่เป็นประโยชน์จริง ไม่ต้องพูดถึงอัลกอริทึมการเรียงลำดับแบบง่าย ๆ ดังต่อไปนี้ด้วยO(infinity):

list = someList
while (list not sorted):
    doNothing

Bogobogosort ใช่มันเป็นเรื่องของ เพื่อ Bogobogosort คุณ Bogosort องค์ประกอบแรก ตรวจสอบเพื่อดูว่าองค์ประกอบหนึ่งเรียงลำดับหรือไม่ เป็นองค์ประกอบเดียวก็จะเป็น จากนั้นคุณเพิ่มองค์ประกอบที่สองและ Bogosort ทั้งสองจนกว่าจะเรียงลำดับ จากนั้นคุณเพิ่มอีกหนึ่งองค์ประกอบแล้ว Bogosort เพิ่มองค์ประกอบและ Bogosorting ต่อไปจนกว่าคุณจะทำทุกองค์ประกอบเสร็จสิ้น สิ่งนี้ถูกออกแบบมาไม่ให้ประสบความสำเร็จกับรายการขนาดใหญ่ใด ๆ ก่อนที่ความร้อนจากเอกภพจะตาย

คุณควรทำวิจัยบางอย่างลงในช่องที่น่าตื่นเต้นของPessimal อัลกอริทึมและการวิเคราะห์ ผู้เขียนเหล่านี้ทำงานเกี่ยวกับปัญหาของการพัฒนาเรียงลำดับด้วยกรณีที่ดีที่สุดในแง่ร้าย (กรณีที่ดีที่สุดของ bogosort ของคุณคือ Omega (n) ในขณะที่ slowsort (ดูกระดาษ) มีความซับซ้อนของเวลาไม่ใช่พหุนามที่ดีที่สุด)

มีการจัดเรียงที่เรียกว่า bogobogosort ก่อนอื่นจะตรวจสอบ 2 องค์ประกอบแรกและโบกี้พวกมัน ถัดไปจะตรวจสอบ 3 ตัวแรกทำการโบกี้พวกมันและอื่น ๆ

หากรายการไม่ถูกต้องในเวลาใด ๆ ก็จะเริ่มต้นใหม่โดย bogosorting 2 ครั้งแรกอีกครั้ง bogosort ปกติมีความซับซ้อนโดยเฉลี่ยของO(N!)อัลกอริทึมนี้มีความซับซ้อนโดยเฉลี่ยO(N!1!2!3!...N!)

แก้ไข : เพื่อให้คุณทราบว่าจำนวนนี้มีจำนวนเท่าใดสำหรับ20อัลกอริธึมนี้ใช้เวลาโดยเฉลี่ย3.930093*10^158 นานกว่าความร้อนที่เสนอของเอกภพ (ถ้าเกิด) 10^100 หลายปี ,

ในขณะที่การผสานการเรียงลำดับใช้เวลาประมาณ.0000004 วินาทีฟองเรียงลำดับ.0000016 วินาทีและใช้เวลา bogosort 308 ปี , 139 วัน , 19 ชั่วโมง , 35 นาที , 22.306 วินาทีสมมติว่าปี 365.242 วันและคอมพิวเตอร์ไม่ 250,000,000 32 บิตจำนวนเต็มการดำเนินงานต่อวินาที

แก้ไข 2 : อัลกอริทึมนี้ไม่ช้าเท่ากับการเรียงลำดับปาฏิหาริย์ "อัลกอริธึม" ซึ่งอาจเหมือนกับคอมพิวเตอร์ประเภทนี้ที่จะถูกดูดเข้าสู่หลุมดำก่อนที่จะประสบความสำเร็จในการจัดเรียง 20 elemtnts แต่ถ้าเป็นเช่นนั้น ของ2^(32(the number of bits in a 32 bit integer)*N)(the number of elements)*(a number <=10^40) ปีที่ผ่านมา ,

เนื่องจากแรงโน้มถ่วงทำให้ชิปอัลฟาเคลื่อนที่เร็วขึ้นและมีสถานะเป็น ^ 2 N ซึ่งก็คือ2^640*10^40หรือประมาณ5.783*10^216.762162762 ปีแม้ว่ารายการจะเริ่มเรียงลำดับแล้วความซับซ้อนของมันก็จะO(N)เร็วกว่าการรวมเรียงซึ่งเป็น N log N เท่านั้น ในกรณีที่เลวร้ายที่สุด

Edit3 : ขั้นตอนวิธีการนี้เป็นจริงช้ากว่ามหัศจรรย์เรียงลำดับตามที่ได้รับขนาดใหญ่มากบอกว่า 1000 ตั้งแต่ขั้นตอนวิธีของฉันจะมีเวลาการทำงานของ2.83*10^1175546 ปีที่ผ่านมาในขณะที่ขั้นตอนวิธีการเรียงลำดับความมหัศจรรย์จะมีเวลาการทำงานของปีที่ผ่านมา1.156*10^9657

นี่คือ 2 ประเภทที่ฉันมากับเพื่อนร่วมห้องในวิทยาลัย

1) ตรวจสอบลำดับ 2) อาจมีปาฏิหาริย์เกิดขึ้นไปที่ 1

และ

1) ตรวจสอบว่ามันเป็นไปตามลำดับหรือไม่หากไม่ใช่ 2) ใส่แต่ละองค์ประกอบลงในแพ็คเก็ตแล้วเด้งมันออกจากเซิร์ฟเวอร์ที่อยู่ห่างไกลกลับมาที่ตัวคุณเอง แพ็กเก็ตเหล่านั้นบางส่วนจะกลับมาในลำดับที่ต่างกันดังนั้นไปที่ 1

มี Bogobogosort อยู่เสมอ (Bogoception!) จะดำเนินการกับ Bogosort กับชุดย่อยที่มีขนาดใหญ่ขึ้นเรื่อย ๆ ของรายการแล้วเริ่มต้นใหม่อีกครั้งหากไม่มีการเรียงลำดับรายการ

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 วางสิ่งของของคุณเพื่อจัดเรียงบนบัตรดัชนี
2 โยนมันขึ้นไปในอากาศในวันที่มีลมแรงโดยห่างจากบ้านของคุณไม่กี่ไมล์
2 โยนพวกเขาไปกองไฟและยืนยันว่าพวกเขาจะถูกทำลายอย่างสมบูรณ์
3 ตรวจสอบพื้นครัวของคุณสำหรับการสั่งซื้อที่ถูกต้อง
4 ทำซ้ำหากคำสั่งไม่ถูกต้อง

scenerio เคสที่ดีที่สุดคือ O (∞)

แก้ไขด้านบนตามการสังเกตอย่างชาญฉลาดโดย KennyTM

"สิ่งที่คุณต้องการจะเป็นอย่างไร" ประเภท

1. บันทึกเวลาของระบบ
2. จัดเรียงโดยใช้ Quicksort (หรืออะไรก็ตามที่สมเหตุสมผล) โดยไม่ใช้การสลับครั้งสุดท้าย
3. บันทึกเวลาของระบบ
4. คำนวณเวลาที่ต้องการ การเพิ่มความแม่นยำทางคณิตศาสตร์เป็นข้อกำหนด
5. รอเวลาที่ต้องการ
6. ทำการสลับครั้งสุดท้าย

ไม่เพียง แต่จะสามารถใช้ค่า O (x) ที่เป็นไปได้ที่สั้นไปจนถึงระยะอนันต์ แต่เวลาที่ใช้นั้นถูกต้อง (ถ้าคุณสามารถรอได้)

ไม่มีอะไรจะเลวร้ายยิ่งไปกว่าอินฟินิตี้

การเรียงลำดับ Bozo เป็นอัลกอริธึมที่เกี่ยวข้องซึ่งจะตรวจสอบว่ามีการเรียงลำดับรายการหรือไม่หากสลับรายการแบบสุ่มสองรายการ มันมีการแสดงเคสที่ดีที่สุดและแย่ที่สุดเท่ากัน แต่ฉันคาดหวังว่าเคสเฉลี่ยจะนานกว่า Bogosort มันยากที่จะหา (หรือสร้าง) ข้อมูลใด ๆ เกี่ยวกับประสิทธิภาพของอัลกอริทึมนี้

ส่วนของπ

สมมติว่าπมีการรวมจำนวน จำกัด ที่เป็นไปได้ทั้งหมด ดูคำถามทางคณิตศาสตร์

1. กำหนดจำนวนตัวเลขที่ต้องการจากขนาดของอาเรย์
2. ใช้เซ็กเมนต์ของπ places เป็นดัชนีเพื่อกำหนดวิธีการสั่งซื้ออาร์เรย์อีกครั้ง หากเซ็กเมนต์เกินขอบเขตขนาดของอาเรย์นี้ให้ปรับออฟเซตทศนิยม and และเริ่มต้นใหม่
3. ตรวจสอบว่ามีการเรียงลำดับอาร์เรย์ที่เรียงลำดับใหม่หรือไม่ ถ้าเป็น woot ให้ปรับ offset และเริ่มต้นใหม่

ประสิทธิภาพของกรณีที่แย่ที่สุดของ O (∞) อาจไม่ได้ทำให้มันเป็นอัลกอริทึมตามบางอย่างบาง

อัลกอริทึมเป็นเพียงชุดของขั้นตอนและคุณสามารถทำได้โดยการปรับแต่งเล็กน้อยเพื่อให้ได้ผลลัพธ์ที่ต้องการในขั้นตอนมากกว่าที่เคยทำมา เราสามารถใส่ความรู้เกี่ยวกับจำนวนขั้นตอนลงในอัลกอริธึมโดยจงใจและทำให้มันยุติและสร้างผลลัพธ์ที่ถูกต้องเฉพาะหลังจากXทำตามขั้นตอนจำนวนแล้ว นั่นXอาจเป็นคำสั่งของ O (n ² ) หรือ O (n ^n! ) หรืออัลกอริธึมที่ต้องการทำ ที่จะเพิ่มกรณีที่ดีที่สุดเช่นเดียวกับขอบเขตกรณีเฉลี่ยอย่างมีประสิทธิภาพ

แต่สถานการณ์กรณีที่เลวร้ายที่สุดของคุณไม่สามารถเติมได้ :)

อัลกอริทึมการเรียงลำดับช้าที่ฉันโปรดปรานคือการจัดเรียงลูกไล่:

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);
   }
}

ความซับซ้อนของกรณีที่แย่ที่สุดคือ O(n^(log(3) / log(1.5))) = O(n^2.7095...)ความซับซ้อนกรณีที่เลวร้ายที่สุดคือ

อัลกอริทึมการเรียงลำดับช้าอื่น ๆ ชื่อจริงช้า!

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);
}

อันนี้ใช้เวลาO(n ^ (log n))ในกรณีที่ดีที่สุด ... ช้ากว่า stoogesort

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);
}

หน้านี้เป็นเรื่องที่น่าอ่านในหัวข้อ: http://home.tiac.net/~cri_d/cri/2001/badsort.html

สิ่งที่ฉันชอบคือ Tom Duff's sillysort:

/*
 * 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; }
        }
}

คู่โบกี้

Bogosort สองครั้งและเปรียบเทียบผลลัพธ์ (เพื่อให้แน่ใจว่ามันถูกจัดเรียง) หากไม่ทำอีกครั้ง

คุณสามารถทำให้อัลกอริทึมการเรียงลำดับช้าลงโดยเรียกใช้ขั้นตอน "มันจัดเรียง" แบบสุ่ม สิ่งที่ต้องการ:

1. สร้างอาร์เรย์ของบูลีนขนาดเดียวกับอาร์เรย์ที่คุณกำลังเรียงลำดับ ตั้งค่าทั้งหมดเป็นเท็จ
2. รันการวนซ้ำของ bogosort
3. เลือกสององค์ประกอบแบบสุ่ม
4. หากองค์ประกอบทั้งสองนั้นเรียงตามสัมพันธ์กัน (i <j && array [i] <array [j]) ให้ทำเครื่องหมายดัชนีของทั้งสองในอาร์เรย์บูลีนเป็นจริง overwise เริ่มใหม่
5. ตรวจสอบว่าบูลีนทั้งหมดในอาร์เรย์นั้นเป็นจริงหรือไม่ ถ้าไม่กลับไปที่ 3
6. เสร็จสิ้น

ใช่ SimpleSort ในทางทฤษฎีมันทำงานในO(-1)อย่างไรก็ตามสิ่งนี้เทียบเท่ากับO(...9999)ซึ่งจะเทียบเท่ากับ O (∞ - 1) ซึ่งมันเกิดขึ้นก็เทียบเท่ากับ O (∞) นี่คือตัวอย่างการใช้งานของฉัน:

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

หนึ่งที่ฉันเพิ่งทำคือเกี่ยวข้องกับการเลือกสองคะแนนสุ่มและหากพวกเขาอยู่ในลำดับที่ไม่ถูกต้องกลับรายการย่อยทั้งหมดระหว่างพวกเขา ฉันพบอัลกอริทึมในhttp://richardhartersworld.com/cri_d/cri/2001/badsort.htmlซึ่งบอกว่ากรณีเฉลี่ยน่าจะอยู่แถว ๆ O (n ^ 3) หรือ O (n ^ 2 log n) ( เขาไม่แน่ใจจริงๆ)

ฉันคิดว่ามันอาจเป็นไปได้ที่จะทำอย่างมีประสิทธิภาพมากขึ้นเพราะฉันคิดว่ามันเป็นไปได้ที่จะทำการดำเนินการกลับรายการในเวลา O (1)

ที่จริงแล้วฉันเพิ่งรู้ว่าการทำเช่นนั้นอาจทำให้ทุกอย่างที่ฉันพูดอาจเป็นเพราะฉันเพิ่งรู้ว่าโครงสร้างข้อมูลที่ฉันมีอยู่ในใจจะทำให้เข้าถึงองค์ประกอบแบบสุ่มที่ O (log n) และพิจารณาว่าจำเป็นต้องย้อนกลับที่ O หรือไม่ )

Randomsubsetsort

กำหนดอาร์เรย์ขององค์ประกอบ n ให้เลือกแต่ละองค์ประกอบด้วยความน่าจะเป็น 1 / n สุ่มองค์ประกอบเหล่านี้และตรวจสอบว่ามีการเรียงลำดับอาร์เรย์หรือไม่ ทำซ้ำจนกระทั่งเรียงลำดับ

เวลาที่เหลือจะเป็นแบบฝึกหัดสำหรับผู้อ่าน