Bogosort (일명 Monkey Sort)보다 나쁜 정렬 알고리즘이 있습니까? [닫은]

저의 동료들은 오늘 아침 정렬 알고리즘에 대한 토론으로 제 대학 시절로 시간을 되돌 렸습니다. 우리는 StupidSort 와 같은 즐겨 찾기를 연상 시켰으며 , 우리 중 한 명이 정렬 알고리즘을 보았을 것이라고 확신했다 O(n!). 그것은 내가 찾을 수있는 "가장 최악의"정렬 알고리즘을 찾기 시작했다.

(- 아니 RANDOMIZE 다시는 순서에? 즉 RANDOMIZE 요소), 나는 주위를 둘러 보았다 그리고 그것은 분명히라고 사실을 발견 우리는 완전히 임의의 종류가 아주 나쁜 될 것이라고 가정 보고 정렬, 또는 원숭이를 정렬하거나, 때로는 랜덤 정렬 .

Monkey Sort는 최악의 성능 O(∞), 최상의 성능 O(n)및 평균 성능 을 가진 것으로 보입니다 O(n·n!).

최악의 평균 정렬 성능을 가진 현재 공식적으로 허용되는 정렬 알고리즘은 무엇입니까 O(n·n!)?

에서 데이비드 모건-월 의 비전 알고리즘 페이지 : 지적 설계 정렬

소개

지능형 디자인 정렬은 지능형 디자인 이론을 기반으로 한 정렬 알고리즘입니다.

알고리즘 설명

원래 입력 목록이 정확한 순서로있을 확률은 1 / (n!)입니다. 이런 일이 우연히 일어났다 고 말할 수는 없을 정도로 작은 가능성이 있기 때문에, 그것은 지능적으로 분류기에 의해 의식적으로 그 순서대로 놓여져 있어야합니다. 따라서 "오름차순"에 대한 순진한 필사자의 이해를 초월하는 방식으로 이미 최적으로 정렬되어 있다고 가정하는 것이 안전합니다. 우리 자신의 선입견을 따르기 위해 그 순서를 바꾸려고하면 실제로는 덜 분류 될 것입니다.

분석

이 알고리즘은 시간이 일정하며 추가 메모리가 필요하지 않고 목록을 적절하게 정렬합니다. 사실, 그것은 의심스러운 기술적 인 컴퓨터를 필요로하지 않습니다. 분류기를 찬양하라!

피드백

게리 로저스의 글을 참고하세요 :

정렬 시간을 일정하게 설정하면 분류기의 성능이 거부됩니다. 분류기는 시간이 지남에 따라 정렬되므로 시간이 없습니다. 정렬을 확인하는 데 시간이 걸리면 정렬 기의 역할이 어려워집니다. 따라서 ...이 특정 종류는 결함이 있으며 'The 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는이 단계에서 사용할 확실한 알고리즘입니다.

편집 : 엄밀히 말하면, 이것은 종료가 보장되지 않기 때문에 알고리즘이 아닙니다. "알고리즘이 아닌"이 "나쁜 알고리즘"으로 인정됩니까?

양자보고 르 소트

양자 역학에 대한 많은 세계 해석이 정확하다고 가정하는 정렬 알고리즘 :

1. 목록이 정렬되어 있는지 확인하십시오. 그렇지 않다면 우주를 파괴하십시오.

알고리즘의 결론에 따라, 목록은 유일하게 남아있는 유일한 우주에서 정렬됩니다. 이 알고리즘은 최악의 경우 O (N) 및 평균의 경우 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 개의 숫자를 정렬하는 것은 다소 나쁘다.

여기에 설명 된대로 징글 정렬 .

당신은 당신의 목록에있는 각 가치를 크리스마스에 다른 어린이에게줍니다. 끔찍한 인간 인 아이들은 선물의 가치를 비교하고 그에 따라 분류합니다.

한 번 무작위 배열 생성을 제안한 강사가 정렬되어 있는지 확인한 다음 정렬 할 배열과 데이터가 동일한 지 확인했습니다.

최고의 사례 O (N) (처음으로 베이비!) 최악의 경우 O (Never)

알고리즘을 어떤 식 으로든 의미있게 유지한다면 O(n!)달성 할 수있는 최악의 상한입니다.

집합의 순열을 정렬 할 수있는 가능성을 확인 n!하면 단계가 수행되므로 그보다 더 나빠질 수는 없습니다.

그보다 더 많은 단계를 수행하면 알고리즘에 유용한 목적이 없습니다. 다음과 같은 간단한 정렬 알고리즘은 말할 것도 없습니다 O(infinity).

list = someList
while (list not sorted):
    doNothing

보고 보소 트. 그렇습니다. Bogobogosort에게는 첫 번째 요소 인 Bogosort가 있습니다. 하나의 요소가 정렬되어 있는지 확인하십시오. 하나의 요소가 될 것입니다. 그런 다음 두 번째 요소를 추가하고 정렬 될 때까지 두 요소를 추가합니다. 그런 다음 요소를 하나 더 추가 한 다음 Bogosort를 추가하십시오. 마지막으로 모든 요소를 ​​완료 할 때까지 요소 및보고 분류를 계속 추가하십시오. 이것은 우주의 더위가 죽기 전에 규모가 큰 목록으로 성공하지 못하도록 설계되었습니다.

흥미로운 Pessimal Algorithms and Simplexity Analysis 분야에 대한 연구가 필요 합니다. 이 저자들은 pessimal best-case로 정렬을 개발하는 문제에 대해 연구하고 있습니다 (bogosort의 가장 좋은 경우는 Omega (n)이며 slowsort (종이 참조)는 비 다항식의 경우가 복잡합니다).

bogobogosort라는 종류가 있습니다. 먼저, 처음 2 개의 요소를 확인하여보고합니다. 다음으로 처음 3 개를 확인하고보고 정렬합니다.

목록이 언제라도 순서가 맞지 않으면 처음 2 개를 다시 분류하여 다시 시작합니다. 일반 bogosort의 평균 복잡도는 O(N!)이 알고리즘의 평균 복잡도는O(N!1!2!3!...N!)

편집 : 당신이 숫자가,이 얼마나 큰 아이디어 부여하려면 20요소,이 알고리즘의 평균 소요 3.930093*10^158 년 의 (그런 일 경우)도 우주의 제안 열 사망 위를, 10^100 년 ,

반면, 병합 정렬은 약 .0000004 초 , 버블 정렬 .0000016 초 , 그리고 bogosort는 연도가 365.242 일이고 컴퓨터가 초당 250,000,000 개의 32 비트 정수 연산을 수행한다고 가정하면 몇 308 년 , 139 일 , 19 시간 , 35 분 , 22.306 초가 소요 됩니다.

Edit2 :이 알고리즘은 "알고리즘"기적 정렬만큼 느리지는 않습니다. 아마도이 정렬과 같이 20 개의 elemtnt를 성공적으로 정렬하기 전에 컴퓨터가 블랙홀에 빨려 들어가게됩니다. 의 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 로그 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 바람이 부는 날, 집에서 1 마일 떨어진 곳에 바람에 던져 넣습니다.
2 모닥불에 던져 완전히 파괴되었는지 확인하십시오.
3 부엌 바닥이 올바른 순서인지 확인하십시오.
4 순서가 맞지 않으면 반복하십시오.

최고의 경우 scenerio는 O (∞)입니다

KennyTM의 확실한 관찰을 기반으로 위의 편집 .

"무엇을 원하십니까?" 종류

1. 시스템 시간을 기록하십시오.
2. 마지막 스왑을 생략하고 Quicksort를 사용하여 정렬하십시오.
3. 시스템 시간을 기록하십시오.
4. 필요한 시간을 계산하십시오. 확장 정밀 산술이 필요합니다.
5. 필요한 시간을 기다리십시오.
6. 마지막 스왑을 수행하십시오.

상상할 수없는 O (x) 값을 무한대로 구현할 수있을뿐만 아니라 걸리는 시간도 정확합니다 (오래 기다릴 수있는 경우).

무한보다 더 나쁜 것은 없습니다.

Bozo 정렬은 목록이 정렬되어 있는지 확인하고 그렇지 않은 경우 두 항목을 무작위로 교환하는 관련 알고리즘입니다. 최고 성능과 최악의 성능이 동일하지만 평균 사례가 Bogosort보다 길 것으로 직관적으로 기대합니다. 이 알고리즘의 성능에 대한 데이터를 찾거나 생성하기가 어렵습니다.

π의 세그먼트

π에 가능한 모든 유한 숫자 조합이 포함되어 있다고 가정하십시오. math.stackexchange 질문을 참조하십시오

1. 배열 크기에서 필요한 자릿수를 결정하십시오.
2. π 자리의 세그먼트를 인덱스로 사용하여 배열 순서를 바꾸는 방법을 결정하십시오. 세그먼트가이 배열의 크기 경계를 초과하면 π 소수 오프셋을 조정하고 다시 시작하십시오.
3. 재정렬 된 배열이 정렬되어 있는지 확인하십시오. 그것이 엉망이라면 오프셋을 조정하고 다시 시작하십시오.

최악의 경우 O (∞)의 성능은 일부 알고리즘에 따라 알고리즘을 만들지 못할 수도 있습니다 .

알고리즘은 일련의 단계 일 뿐이며 이전에 수행했던 것보다 더 많은 단계에서 원하는 출력을 얻도록 알고리즘을 약간 조정하여 항상 더 나빠질 수 있습니다. 의도적으로 알고리즘에 취한 단계 수에 대한 지식을 넣고 단계 X수를 완료 한 후에 만 ​​종료하고 올바른 출력을 생성 할 수 있습니다. 그것은 XO (n ² ) 또는 O (n ^n! ) 또는 알고리즘이 원하는 순서 일 수 있습니다. 이를 통해 최고 사례와 평균 사례 범위를 효과적으로 늘릴 수 있습니다.

그러나 최악의 시나리오는 극복 할 수 없습니다 :)

내가 가장 좋아하는 느린 정렬 알고리즘은 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);
   }
}

최악의 경우 복잡성은 O(n^(log(3) / log(1.5))) = O(n^2.7095...)입니다.

또 다른 느린 정렬 알고리즘은 실제로 slowsort라고합니다!

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의 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]) 부울 배열에서 둘 다의 인덱스를 true로 표시하십시오. 다시 시작하세요.
5. 배열의 모든 부울이 true인지 확인하십시오. 그렇지 않으면 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 (n에서 역전이 필요한지 여부를 결정한다는 것을 깨달았 기 때문에 아마도 그렇게하는 것이 내가 말하는 모든 것을 만들 것이라는 것을 깨달았습니다. ).

무작위 하위 집합.

n 개의 요소가 배열 된 경우 확률이 1 / n 인 각 요소를 선택하고 해당 요소를 무작위 화하고 배열이 정렬되어 있는지 확인하십시오. 정렬 될 때까지 반복하십시오.

예상 시간은 독자의 연습으로 남아 있습니다.