Có thuật toán sắp xếp nào tệ hơn so với Bogosort (hay còn gọi là Monkey Sort) không? [đóng cửa]

Các đồng nghiệp của tôi đã đưa tôi trở lại thời gian vào thời đại học của tôi với một cuộc thảo luận về các thuật toán sắp xếp sáng nay. Chúng tôi đã hồi tưởng về các mục yêu thích của chúng tôi như StoolSort , và một trong số chúng tôi chắc chắn rằng chúng tôi đã thấy một thuật toán sắp xếp đó là O(n!). Điều đó khiến tôi bắt đầu tìm kiếm các thuật toán sắp xếp "tệ nhất" mà tôi có thể tìm thấy.

Chúng tôi mặc nhiên công nhận rằng một loại hoàn toàn ngẫu nhiên sẽ khá xấu (tức là randomize các yếu tố -? Là nó theo thứ tự không randomize một lần nữa), và tôi nhìn quanh và phát hiện ra rằng nó dường như gọi BogoSort, hoặc khỉ Sắp xếp, hoặc đôi khi chỉ là ngẫu nhiên Sắp xếp .

Monkey Sort dường như có hiệu suất trường hợp xấu nhất O(∞), hiệu suất trường hợp tốt nhất O(n)và hiệu suất trung bình là O(n·n!).

Thuật toán sắp xếp được chấp nhận chính thức hiện nay với hiệu suất sắp xếp trung bình tồi tệ nhất (và có thể thấy ong kém hơn O(n·n!)) là gì?

Từ trang Thuật toán bí truyền của David Morgan-Mar : Sắp xếp thiết kế thông minh

Giới thiệu

Sắp xếp thiết kế thông minh là một thuật toán sắp xếp dựa trên lý thuyết về thiết kế thông minh.

Mô tả thuật toán

Xác suất của danh sách đầu vào ban đầu theo thứ tự chính xác là trong 1 / (n!). Có một khả năng nhỏ đến mức này rõ ràng là vô lý khi nói rằng điều này xảy ra tình cờ, do đó, nó phải được sắp xếp một cách có ý thức bởi một Trình sắp xếp thông minh. Do đó, thật an toàn khi cho rằng nó đã được sắp xếp một cách tối ưu theo một cách nào đó vượt qua sự hiểu biết ngây thơ của chúng ta về "trật tự tăng dần". Bất kỳ nỗ lực nào để thay đổi thứ tự đó để phù hợp với định kiến ​​của chúng ta sẽ thực sự khiến nó ít được sắp xếp hơn.

Phân tích

Thuật toán này không đổi theo thời gian và sắp xếp danh sách tại chỗ, không yêu cầu thêm bộ nhớ. Trên thực tế, nó thậm chí không yêu cầu bất kỳ thứ máy tính công nghệ đáng ngờ nào. Khen ngợi Người sắp xếp!

Phản hồi

Gary Rogers viết:

Làm cho sắp xếp không đổi theo thời gian phủ nhận sức mạnh của Trình sắp xếp. Trình sắp xếp tồn tại ngoài thời gian, do đó sắp xếp là vô tận. Để yêu cầu thời gian để xác thực sắp xếp làm giảm vai trò của Trình sắp xếp. Do đó ... loại đặc biệt này là thiếu sót, và không thể được quy cho 'Trình sắp xếp'.

Dị giáo!

Nhiều năm trước, tôi đã phát minh ra (nhưng chưa bao giờ thực sự thực hiện) 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

Cuối cùng, các hạt alpha lật các bit trong các chip bộ nhớ sẽ dẫn đến việc sắp xếp thành công.

Để có độ tin cậy cao hơn, hãy sao chép mảng vào vị trí được che chắn và kiểm tra các mảng có khả năng được sắp xếp so với ban đầu.

Vì vậy, làm thế nào để bạn kiểm tra các mảng có khả năng sắp xếp so với ban đầu? Bạn chỉ cần sắp xếp từng mảng và kiểm tra xem chúng có khớp không. MiracleSort là thuật toán rõ ràng để sử dụng cho bước này.

EDIT: Nói đúng ra, đây không phải là một thuật toán, vì nó không được đảm bảo để chấm dứt. "Không phải là một thuật toán" có đủ điều kiện là "một thuật toán tồi tệ hơn" không?

Lượng tử

Một thuật toán sắp xếp giả định rằng sự giải thích nhiều thế giới của cơ học lượng tử là chính xác:

1. Kiểm tra xem danh sách đã được sắp xếp. Nếu không, phá hủy vũ trụ.

Khi kết thúc thuật toán, danh sách sẽ được sắp xếp trong vũ trụ duy nhất còn lại. Thuật toán này mất thời gian trường hợp xấu nhất O (N) và trường hợp trung bình O (1). Trên thực tế, số lượng so sánh trung bình được thực hiện là 2: có 50% khả năng vũ trụ sẽ bị phá hủy ở nguyên tố thứ hai, 25% khả năng nó sẽ bị phá hủy vào lần thứ ba, v.v.

Tôi ngạc nhiên không có ai đề cập đến giấc ngủ chưa ... Hay tôi không nhận thấy điều đó? Dù sao:

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

sử dụng ví dụ:

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

Về mặt hiệu suất thì thật kinh khủng (đặc biệt là ví dụ thứ hai). Chờ gần 3,5 tháng để sắp xếp 2 số là hơi tệ.

Jingle Sắp xếp, như được mô tả ở đây .

Bạn đưa từng giá trị trong danh sách của bạn cho một đứa trẻ khác nhau vào Giáng sinh. Trẻ em, là những con người tồi tệ, sẽ so sánh giá trị của những món quà của chúng và tự sắp xếp chúng cho phù hợp.

Tôi đã có một giảng viên từng đề nghị tạo ra một mảng ngẫu nhiên, kiểm tra xem nó đã được sắp xếp chưa và sau đó kiểm tra xem dữ liệu có giống với mảng được sắp xếp không.

Trường hợp tốt nhất O (N) (em bé lần đầu!) Trường hợp xấu nhất O (Không bao giờ)

Nếu bạn giữ thuật toán có ý nghĩa theo bất kỳ cách nào, O(n!)thì giới hạn trên tồi tệ nhất bạn có thể đạt được.

Vì việc kiểm tra từng khả năng cho một hoán vị của một tập hợp được sắp xếp sẽ thực n!hiện các bước, bạn không thể nhận được bất kỳ điều gì tồi tệ hơn thế.

Nếu bạn đang thực hiện nhiều bước hơn thế thì thuật toán không có mục đích thực sự hữu ích. Không đề cập đến thuật toán sắp xếp đơn giản sau đây với O(infinity):

list = someList
while (list not sorted):
    doNothing

Bogobogosort. Vâng, đó là một điều. đến Bogobogosort, bạn Bogosort là yếu tố đầu tiên. Kiểm tra xem nếu một yếu tố được sắp xếp. Là một yếu tố, nó sẽ được. Sau đó, bạn thêm phần tử thứ hai và Bogosort hai phần tử đó cho đến khi nó được sắp xếp. Sau đó, bạn thêm một yếu tố nữa, sau đó là Bogosort. Tiếp tục thêm các phần tử và Bogosorting cho đến khi bạn hoàn thành mọi phần tử. Điều này được thiết kế để không bao giờ thành công với bất kỳ danh sách lớn nào trước cái chết nóng của vũ trụ.

Bạn nên thực hiện một số nghiên cứu về lĩnh vực thú vị của Thuật toán Pessimal và Phân tích đơn giản . Các tác giả này nghiên cứu về vấn đề phát triển một loại với trường hợp tốt nhất (trường hợp tốt nhất của bogosort của bạn là Omega (n), trong khi làm chậm (xem giấy) có độ phức tạp về thời gian trong trường hợp tốt nhất không đa thức).

Có một loại gọi là bogobogosort. Đầu tiên, nó kiểm tra 2 phần tử đầu tiên và bogosorts chúng. Tiếp theo, nó kiểm tra 3 cái đầu tiên, bogosorts chúng, vân vân.

Nếu danh sách bị mất trật tự bất cứ lúc nào, nó sẽ khởi động lại bằng cách giả mạo 2 lần đầu tiên. Bogosort thông thường có độ phức tạp trung bình O(N!), thuật toán này có độ phức tạp trung bình làO(N!1!2!3!...N!)

Chỉnh sửa : Để cho bạn biết con số này lớn đến mức nào, đối với 20các yếu tố, thuật toán này mất trung bình 3.930093*10^158 nhiều năm , cao hơn cả cái chết nhiệt được đề xuất của vũ trụ (nếu nó xảy ra) trong 10^100 nhiều năm ,

trong khi merge sort mất khoảng .0000004 vài giây , bong bóng sắp xếp .0000016 giây , và bogosort mất 308 năm , 139 ngày , 19 giờ , 35 phút , 22.306 giây , giả sử một năm là 365,242 ngày và một máy tính không hoạt động 250.000.000 32 bit số nguyên mỗi giây.

Edit2 : Thuật toán này không chậm như loại phép lạ "thuật toán", có lẽ, giống như loại này, sẽ khiến máy tính bị hút vào lỗ đen trước khi nó sắp xếp thành công 20 elemtnts, nhưng nếu có, tôi sẽ ước tính độ phức tạp trung bình của 2^(32(the number of bits in a 32 bit integer)*N)(the number of elements)*(a number <=10^40) năm ,

do trọng lực tăng tốc các chip alpha di chuyển và có 2 ^ N trạng thái, tức là 2^640*10^40khoảng 5.783*10^216.762162762 năm , mặc dù nếu danh sách bắt đầu được sắp xếp, độ phức tạp của nó sẽ chỉ O(N)nhanh hơn so với sắp xếp hợp nhất, chỉ có N log N trong trường hợp xấu nhất

Edit3 : Thuật toán này thực sự chậm hơn so với sắp xếp phép lạ vì kích thước trở nên rất lớn, giả sử 1000, vì thuật toán của tôi sẽ có thời gian chạy 2.83*10^1175546 nhiều năm , trong khi thuật toán sắp xếp phép lạ sẽ có thời gian chạy 1.156*10^9657 nhiều năm .

Đây là 2 loại tôi đã đến với bạn cùng phòng của tôi ở trường đại học

1) Kiểm tra thứ tự 2) Có thể một phép lạ đã xảy ra, chuyển đến 1

và

1) kiểm tra xem nó có theo thứ tự không, nếu không 2) đặt từng phần tử vào một gói và trả lại cho một máy chủ ở xa trở lại chính bạn. Một số gói đó sẽ trả về theo thứ tự khác, vì vậy hãy chuyển đến 1

Luôn luôn có Bogobogosort (Không dùng thuốc!). Nó thực hiện Bogosort trên các tập con ngày càng lớn của danh sách, và sau đó bắt đầu lại nếu danh sách không bao giờ được sắp xếp.

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 Đặt vật phẩm của bạn được sắp xếp vào thẻ chỉ số
2 Ném chúng lên không trung vào một ngày gió, cách nhà bạn một dặm.
2 Ném chúng vào lửa trại và xác nhận chúng đã bị phá hủy hoàn toàn.
3 Kiểm tra sàn bếp của bạn để đặt hàng đúng.
4 Lặp lại nếu đó không phải là thứ tự đúng.

Scenerio trường hợp tốt nhất là O (∞)

Chỉnh sửa ở trên dựa trên sự quan sát sắc sảo của KennyTM.

"Bạn muốn nó là gì?" sắp xếp

1. Lưu ý thời gian hệ thống.
2. Sắp xếp bằng Quicksort (hoặc bất cứ điều gì hợp lý hợp lý), bỏ qua lần hoán đổi cuối cùng.
3. Lưu ý thời gian hệ thống.
4. Tính thời gian cần thiết. Số học chính xác mở rộng là một yêu cầu.
5. Chờ thời gian cần thiết.
6. Thực hiện trao đổi cuối cùng.

Nó không chỉ có thể thực hiện bất kỳ giá trị O (x) có thể hiểu được nào ở mức vô hạn, thời gian thực hiện là hoàn toàn chính xác (nếu bạn có thể đợi lâu như vậy).

Không có gì có thể tồi tệ hơn vô cùng.

Bozo sort là một thuật toán liên quan để kiểm tra xem danh sách có được sắp xếp hay không và nếu không, sẽ hoán đổi hai mục một cách ngẫu nhiên. Nó có các màn trình diễn trường hợp tốt nhất và tệ nhất, nhưng theo trực giác, tôi mong đợi trường hợp trung bình sẽ dài hơn Bogosort. Thật khó để tìm thấy (hoặc sản xuất) bất kỳ dữ liệu nào về hiệu suất của thuật toán này.

Phân đoạn của π

Giả sử π chứa tất cả các kết hợp số hữu hạn có thể. Xem câu hỏi math.stackexchange

1. Xác định số chữ số cần thiết từ kích thước của mảng.
2. Sử dụng các phân đoạn của các vị trí π làm chỉ mục để xác định cách sắp xếp lại mảng. Nếu một phân đoạn vượt quá ranh giới kích thước cho mảng này, hãy điều chỉnh phần bù thập phân π và bắt đầu lại.
3. Kiểm tra nếu mảng sắp xếp lại được sắp xếp. Nếu nó là woot, khác điều chỉnh bù và bắt đầu lại.

Một số trường hợp xấu nhất của O (∞) thậm chí có thể không biến nó thành một thuật toán theo một số người .

Một thuật toán chỉ là một chuỗi các bước và bạn luôn có thể làm tồi tệ hơn bằng cách điều chỉnh nó một chút để có được đầu ra mong muốn theo nhiều bước hơn so với trước đây. Người ta có thể cố tình đưa kiến ​​thức về số bước được thực hiện vào thuật toán và làm cho nó chấm dứt và tạo ra đầu ra chính xác chỉ sau khi Xsố bước đã được thực hiện. Đó Xrất có thể là thứ tự của O (n ² ) hoặc O (n ^n! ) Hoặc bất cứ thuật toán nào muốn làm. Điều đó sẽ có hiệu quả tăng trường hợp tốt nhất cũng như giới hạn trường hợp trung bình.

Nhưng trường hợp xấu nhất của bạn không thể đứng đầu :)

Thuật toán sắp xếp chậm yêu thích của tôi là sắp xếp stooge:

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

Trường hợp phức tạp nhất là O(n^(log(3) / log(1.5))) = O(n^2.7095...).

Một thuật toán sắp xếp chậm khác thực sự được đặt tên là làm chậm!

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

Điều này diễn ra O(n ^ (log n))trong trường hợp tốt nhất ... thậm chí chậm hơn so với 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);
}

Trang này rất thú vị về chủ đề này: http://home.tiac.net/~cri_d/cri/2001/badsort.html

Sở thích cá nhân của tôi là sự ngớ ngẩn của Tom Duff:

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

Đôi bogosort

Bogosort hai lần và so sánh kết quả (chỉ để chắc chắn rằng nó được sắp xếp) nếu không làm lại

Bạn có thể làm cho bất kỳ thuật toán sắp xếp nào chậm hơn bằng cách chạy ngẫu nhiên bước "is it sort". Cái gì đó như:

1. Tạo một mảng booleans có cùng kích thước với mảng bạn sắp xếp. Đặt tất cả thành sai.
2. Chạy một vòng lặp của bogosort
3. Chọn hai yếu tố ngẫu nhiên.
4. Nếu hai phần tử được sắp xếp liên quan đến nhau (i <j && mảng [i] <mảng [j]), hãy đánh dấu các chỉ mục của cả hai trên mảng boolean thành true. Quá, bắt đầu lại.
5. Kiểm tra xem tất cả các booleans trong mảng là đúng. Nếu không, quay lại 3.
6. Làm xong.

Đúng, SimpleSort, theo lý thuyết, nó chạy trong O(-1)tuy nhiên điều này tương đương vớiO(...9999) lần lượt tương đương với O (- 1), điều này xảy ra cũng tương đương với O (). Đây là mẫu thực hiện của tôi:

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

Một tôi chỉ đang làm việc liên quan đến việc chọn hai điểm ngẫu nhiên, và nếu chúng sai thứ tự, đảo ngược toàn bộ khoảng cách giữa chúng. Tôi đã tìm thấy thuật toán trên http://richardhartersworld.com/cri_d/cri/2001/badsort.html , trong đó nói rằng trường hợp trung bình có lẽ nằm ở đâu đó xung quanh O (n ^ 3) hoặc O (n ^ 2 log n) ( anh ấy không thực sự chắc chắn).

Tôi nghĩ rằng có thể thực hiện nó hiệu quả hơn, bởi vì tôi nghĩ có thể thực hiện thao tác đảo ngược trong thời gian O (1).

Trên thực tế, tôi chỉ nhận ra rằng làm điều đó sẽ làm cho toàn bộ điều tôi nói có thể bởi vì tôi chỉ nhận ra rằng cấu trúc dữ liệu tôi có trong đầu sẽ đặt truy cập các phần tử ngẫu nhiên tại O (log n) và xác định xem nó có cần đảo ngược tại O (n không ).

Randomsubetsort.

Cho một mảng gồm n phần tử, chọn từng phần tử có xác suất 1 / n, chọn ngẫu nhiên các phần tử này và kiểm tra xem mảng đó có được sắp xếp không. Lặp lại cho đến khi được sắp xếp.

Thời gian dự kiến ​​là một bài tập cho người đọc.