Есть ли худшие алгоритмы сортировки, чем Bogosort (иначе Monkey Sort)? [закрыто]

Мои коллеги вернули меня во время моих университетских дней с обсуждением алгоритмов сортировки сегодня утром. Мы вспомнили о наших избранных, таких как StupidSort , и один из нас был уверен, что мы видели алгоритм сортировки, который был O(n!). Это заставило меня начать искать "худшие" алгоритмы сортировки, которые я мог найти.

Мы постулировали, что совершенно случайная сортировка была бы довольно плохой (то есть рандомизировать элементы - по порядку? Нет? Снова рандомизировать), и я оглянулся и обнаружил, что она, очевидно, называется BogoSort, или Monkey Sort, или иногда просто Random Sort ,

Сортировка обезьяны имеет худшую производительность O(∞), лучшую производительность O(n)и среднюю производительность O(n·n!).

Каков в настоящее время официально принятый алгоритм сортировки с худшей средней производительностью сортировки (и, следовательно, хуже, чем O(n·n!))?

Со страницы Эзотерических Алгоритмов Дэвида Морган-Мара : Интеллектуальный Сортировка Проекта

Введение

Интеллектуальный проект сортировки - это алгоритм сортировки, основанный на теории интеллектуального проектирования.

Описание алгоритма

Вероятность того, что исходный входной список находится в точном порядке, в котором он находится, равна 1 / (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

В конце концов, альфа-частицы, переворачивающие биты в микросхемах памяти, должны привести к успешной сортировке.

Для большей надежности скопируйте массив в экранированную папку и сравните потенциально отсортированные массивы с оригиналом.

Так как же проверить потенциально отсортированный массив по сравнению с оригиналом? Вы просто сортируете каждый массив и проверяете, совпадают ли они. MiracleSort - это очевидный алгоритм для использования на этом этапе.

РЕДАКТИРОВАТЬ: Строго говоря, это не алгоритм, так как это не гарантирует завершение. «Алгоритм» не квалифицируется как «худший алгоритм»?

Квантовый Богосорт

Алгоритм сортировки, который предполагает правильность многомерной интерпретации квантовой механики:

1. Проверьте, что список отсортирован. Если нет, уничтожьте вселенную.

По завершении алгоритма список будет отсортирован в единственной оставшейся вселенной. Этот алгоритм требует времени O (N) для наихудшего случая и времени O (1) для среднего случая. Фактически, среднее число выполненных сравнений равно 2: есть вероятность 50%, что вселенная будет уничтожена на втором элементе, вероятность 25%, что она будет уничтожена на третьем, и так далее.

Я удивлен, что никто еще не упомянул о сне ... Или я этого не заметил? Тем не мение:

#!/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 (Никогда)

Если вы сохраняете алгоритм осмысленным в любом случае, O(n!)это худшая верхняя граница, которую вы можете достичь.

Поскольку проверка каждой возможности для перестановок набора, который будет отсортирован, будет предпринимать n!шаги, хуже не будет.

Если вы делаете больше шагов, чем этот, тогда алгоритм не имеет реальной полезной цели. Не говоря уже о следующем простом алгоритме сортировки O(infinity):

list = someList
while (list not sorted):
    doNothing

Bogobogosort. Да, это вещь. Богобогосорт, вы Богосорт первый элемент. Проверьте, отсортирован ли этот элемент. Будучи одним элементом, это будет. Затем вы добавляете второй элемент, и Bogosort эти два, пока он не отсортирован. Затем вы добавляете еще один элемент, затем Bogosort. Продолжайте добавлять элементы и Bogosorting, пока вы, наконец, не сделаете каждый элемент. Это было разработано, чтобы никогда не преуспеть с каким-либо значительным списком до тепловой смерти вселенной.

Вы должны сделать некоторые исследования в захватывающей области пессимальных алгоритмов и анализа симплексности . Эти авторы работают над проблемой разработки сортировки с пессимальным лучшим случаем (лучший случай вашей богосорты - Омега (n), в то время как медленная сортировка (см. Статью) имеет неполиномиальную сложность времени лучшего случая).

Существует разновидность, которая называется богобогосорт. Сначала он проверяет первые 2 элемента и сортирует их. Затем он проверяет первые 3, bogosorts их, и так далее.

Если список в любой момент выходит из строя, он перезапускается путем повторной сортировки первых 2. Обычный богосорт имеет среднюю сложность 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-битных целочисленных операций в секунду.

Edit2 : этот алгоритм не такой медленный, как «алгоритм» чудо-сортировки, которая, вероятно, подобно этому виду, засунет компьютер в черную дыру, прежде чем он успешно отсортирует 20 элементов, но если это произойдет, я бы оценил среднюю сложность от 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

Всегда есть Богобогосорт (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 Повторите, если это не правильный порядок.

Лучший вариант сценария - O (∞)

Отредактируйте выше, основываясь на проницательных наблюдениях KennyTM.

"Что бы вы хотели, чтобы это было?" Сортировать

1. Обратите внимание на системное время.
2. Сортировка с использованием быстрой сортировки (или любой другой разумно разумной), пропуская самый последний обмен.
3. Обратите внимание на системное время.
4. Рассчитайте необходимое время. Требуется повышенная точность арифметики.
5. Подождите необходимое время.
6. Выполните последний обмен.

Мало того, что он может реализовать любое мыслимое значение O (x), кроме бесконечности, время, которое доказуемо корректно (если вы можете ждать так долго).

Ничто не может быть хуже бесконечности.

Бозо-сортировка - это связанный алгоритм, который проверяет, отсортирован ли список, и, если нет, меняет два элемента наугад. У него такие же лучшие и худшие показатели, но я бы интуитивно ожидал, что средний случай будет длиннее, чем у Bogosort. Трудно найти (или получить) какие-либо данные о производительности этого алгоритма.

Сегменты π

Предположим, что π содержит все возможные комбинации конечных чисел. Смотрите вопрос math.stackexchange

1. Определите количество необходимых цифр от размера массива.
2. Используйте сегменты π мест в качестве индексов, чтобы определить, как переупорядочить массив. Если сегмент превышает границы размера для этого массива, отрегулируйте смещение на π и начните заново.
3. Проверьте, отсортирован ли переупорядоченный массив. Если это woot, иначе отрегулируйте смещение и начните сначала.

Производительность 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))в лучшем случае ... даже медленнее, чем стогесорт.

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.

Мой личный фаворит - глупая сортировка Тома Даффа:

/*
 * 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. Проверьте, все ли логические значения в массиве верны. Если нет, вернитесь к 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) ).

Randomsubsetsort.

Учитывая массив из n элементов, выберите каждый элемент с вероятностью 1 / n, рандомизируйте эти элементы и проверьте, отсортирован ли массив. Повторите, пока не отсортировано.

Ожидаемое время оставлено в качестве упражнения для читателя.