อัลกอริธึมการเรียงลำดับที่คลุมเครือที่สุดที่คุณรู้คืออะไร [ปิด]

ฉันเพิ่งอ่านเกี่ยวกับcyclesortผ่านทางโพสต์บล็อก sortvis.org นี่อาจเป็นสิ่งที่คลุมเครือที่สุดเท่าที่ฉันเคยได้ยินมาเพราะใช้คณิตศาสตร์ที่ฉันไม่คุ้นเคย

อะไรคือสิ่งที่คลุมเครือที่สุดที่คุณรู้

เคยได้ยินเรื่องของความอดทนการเรียงลำดับ ? ตอนนี้คุณมี ...

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

สิ่งนี้จะชดเชยมันจาก bogosort เพราะในกรณีที่ดีที่สุด bogosort นั้นค่อนข้างมีประสิทธิภาพ - กล่าวคือเมื่ออาร์เรย์ถูกเรียงลำดับแล้ว Slowsort จะไม่“ ทนทุกข์” จากพฤติกรรมที่ดีที่สุด แม้ในกรณีที่ดีที่สุดก็ยังคงมีรันไทม์ สำหรับε > 0

นี่คือ pseudocode ของมันดัดแปลงมาจากบทความ Wikipediaภาษาเยอรมัน:

function slowsort(A, i, j):
  if i >= j: return

  m = (i + j) / 2
  slowsort(A, i, m)
  slowsort(A, m + 1, j)

  if A[j] < A[m]:
    swap(A[j], A[m])

  slowsort(A, i, j - 1)

ผมไม่ทราบว่าข้อหานี้เป็นปิดบัง แต่หนึ่งในที่สุดเรียงลำดับไร้สาระ "ขั้นตอนวิธีการ" เป็นBogosort ลิงค์จากหน้า Bogosort ก็สนุกเช่นกัน

และมีอัญมณีนี้จากส่วนที่เกี่ยวกับ "quantum bogo-sort"

เนื้อหาการสร้างจักรวาล2 ^Nนั้นก็เป็นความทรงจำที่เข้มข้นเช่นกัน

อืม ... คุณพูดได้เลยว่า :-)

"อัลกอริทึม" ที่คลุมเครืออีกอย่างคือIntelligent Design Sort - แต่ไม่มีอัลกอริทึมใดที่เร็วกว่าหรือใช้หน่วยความจำน้อยกว่า :)

Sleep Sortค่อนข้างแปลก

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

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

    ./sleepsort.bash 5 3 6 3 6 3 1 4 7

ฉันคิดว่าการเรียงลำดับฟองจะเป็นคำตอบที่ไม่ถูกต้องในสถานการณ์นี้เช่นกัน

:)

Knuth เล่มที่ 3 ¹ในคำตอบของแบบฝึกหัดข้อใดข้อหนึ่งให้ใช้งานอัลกอริธึมการเรียงแบบนิรนามซึ่งเป็นพื้นฐานของรหัสกอล์ฟโบราณ - การเรียงลำดับสั้นที่สุดที่คุณสามารถเขียนในภาษาแอสเซมบลี MIX รหัสย่อมาจากราคาที่ซับซ้อนดังนั้น O (N ³ ) ถึงแม้ว่า ...

¹อย่างน้อยในรุ่นที่เก่ากว่า จากการแก้ไข MIXAL สำหรับฉบับใหม่ฉันไม่แน่ใจว่ามันยังอยู่หรือไม่

สำหรับการเรียนโครงสร้างข้อมูลของฉันฉันได้ไป (อย่างชัดเจน) พิสูจน์ความถูกต้องของสมุนจัดเรียง มันมีเวลาทำงานของ O (n ^ {log 3 / log 1.5}) = O (n ^ 2.7095 ... )

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

หนึ่งในหนังสือ Knuth ดั้งเดิม "การเรียงลำดับและการค้นหา" มีการพับกึ่งกลางที่อธิบายกระบวนการที่เรียงลำดับไฟล์เทปโดยไม่ใช้ฮาร์ดดิสก์ ฉันคิดว่ามันใช้เทปไดรฟ์หกตัวและแสดงให้เห็นอย่างชัดเจนว่าเมื่อแต่ละไฟล์ถูกอ่านไปข้างหน้าอ่านย้อนกลับกรอกลับหรือไม่ได้ใช้งาน วันนี้มันเป็นอนุสาวรีย์ของเทคโนโลยีที่ล้าสมัย

ฉันเคยลงทะเบียนในการจัดเรียงฟองเวกเตอร์ในแอสเซมเบลอร์ CRAY เครื่องมีคำสั่งเลื่อนคู่ซึ่งอนุญาตให้คุณเลื่อนเนื้อหาของเวกเตอร์ลงทะเบียนขึ้น / ลงหนึ่งคำ ใส่ทุกจุดลงในเวกเตอร์สองตัวจากนั้นคุณสามารถเรียงลำดับฟองเต็มโดยไม่ต้องทำการอ้างอิงหน่วยความจำอื่นจนกว่าคุณจะเสร็จสิ้น ยกเว้นการเรียงลำดับฟองแบบ N ** 2 มันมีประสิทธิภาพ

ฉันยังจำเป็นต้องทำการจัดเรียงจุดลอยตัวของความยาว 4 เวกเตอร์เร็วที่สุดเท่าที่จะทำได้สำหรับการเรียงลำดับเดียว ทำได้โดยการค้นหาตาราง (เครื่องหมายบิตของ A2-A1 คือหนึ่งบิต, เครื่องหมายของ A3-A1 เป็นอีกบิตหนึ่ง ... , จากนั้นคุณค้นหาเวกเตอร์การเปลี่ยนแปลงในตารางมันเป็นวิธีแก้ปัญหาที่เร็วที่สุดที่ฉันสามารถหาได้ ด้วยการใช้งานไม่ได้กับสถาปัตยกรรมสมัยใหม่แม้ว่าหน่วยลอยและจำนวนเต็มจะถูกแยกออกจากกันเกินไป

Google Code Jam มีปัญหาเกี่ยวกับอัลกอริทึมที่เรียกว่า Gorosort ซึ่งฉันคิดว่าพวกเขาคิดค้นปัญหาขึ้นมา

Goro มี 4 แขน Goro แข็งแกร่งมาก คุณไม่ยุ่งกับ Goro Goro ต้องเรียงลำดับอาร์เรย์ของจำนวนเต็ม N ตัวที่แตกต่างกัน อัลกอริธึมไม่ใช่จุดแข็งของ Goro ความแข็งแกร่งคือความแข็งแกร่งของ Goro แผนการของ Goro คือการใช้นิ้วมือทั้งสองในมือเพื่อจับองค์ประกอบหลายอย่างของอาเรย์แล้วกดที่โต๊ะด้วยหมัดที่สามและสี่ของเขาให้มากที่สุด สิ่งนี้จะทำให้องค์ประกอบที่ไม่มีความปลอดภัยของอาเรย์บินขึ้นไปในอากาศสับแบบสุ่มและถอยกลับลงไปในตำแหน่งอาเรย์ที่ว่างเปล่า

http://code.google.com/codejam/contest/dashboard?c=975485#s=p3

อย่าจำชื่อ แต่โดยทั่วไปแล้ว

while Array not sorted

  rearrange the array in a random order

เรียงเปลือก

บางทีอัลกอริทึมนั้นอาจไม่ชัดเจน แต่ใครสามารถตั้งชื่อการนำไปใช้ที่จริงแล้วใช้จริง ฉันสามารถ!

TIGCC (คอมไพเลอร์ที่ใช้ GCC สำหรับเครื่องคิดเลขกราฟ TI-89/92 / V200) ใช้การจัดเรียงเชลล์สำหรับqsortการนำไปใช้ในไลบรารีมาตรฐาน:

__ATTR_LIB_C__ void qsort(void *list, short num_items, short size, compare_t cmp_func)
{
  unsigned short gap,byte_gap,i,j;                
  char *p,*a,*b,temp;                       
  for (gap=((unsigned short)num_items)>>1; gap>0; gap>>=1)    // Yes, this is not a quicksort,
    {                                                         // but works fast enough...    
      byte_gap=gap*(unsigned short)size;
      for(i=byte_gap; i<((unsigned short)num_items)*(unsigned short)size; i+=size)
        for(p=(char*)list+i-byte_gap; p>=(char*)list; p-= byte_gap)
          {
            a=p; b=p+byte_gap;
            if(cmp_func(a,b)<=0) break;
            for(j=size;j;j--)
              temp=*a, *a++=*b, *b++=temp;
          }
    }
}

การเรียงลำดับของเชลล์ได้รับการเลือกเพื่อสนับสนุน quicksort เพื่อให้ขนาดรหัสต่ำ แม้ว่าความซับซ้อนเชิงซีกจะแย่กว่านั้น TI-89 ไม่มี RAM ทั้งหมด (190K ลบขนาดโปรแกรมและขนาดทั้งหมดของตัวแปรที่ไม่ได้เก็บถาวร) ดังนั้นจึงค่อนข้างปลอดภัยที่จะสมมติว่าจำนวนรายการจะ ใจต่ำ

การเขียนที่ใช้งานได้เร็วขึ้นหลังจากที่ฉันบ่นว่ามันช้าเกินไปในโปรแกรมที่ฉันเขียน มันใช้ขนาดช่องว่างที่ดีกว่าพร้อมกับการเพิ่มประสิทธิภาพการชุมนุม สามารถพบได้ที่นี่: qsort.c