Есть ли какие-то худшие алгоритмы сортировки, чем Bogosort (a.k.a Monkey Sort)?

Ответ 1

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

Введение

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

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

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

Анализ

Этот алгоритм является постоянным во времени и сортирует список на месте, не требуя дополнительной памяти. На самом деле, это даже не требуют любого из этого подозрительного технологического компьютера. Хвалить Сортировщик!

Обратная связь

Гэри Роджерс пишет:

Ведение сортировки во времени   отрицает силу Сортировщика.   Сортер существует вне времени, таким образом   сорт вечен. Чтобы потребовать время   для подтверждения вида уменьшает роль   Сортировщика. Таким образом... этот конкретный   сортировка является ошибочной и не может быть   приписывается "Сортировщику".

Ересь!

Ответ 2

Много лет назад я изобрел (но никогда не реализованный) MiracleSort.

Start with an array in memory.
loop:
    Check to see whether it sorted.
    Yes? We're done.
    No? Wait a while and check again.
end loop

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

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

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

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

Ответ 3

Quantum Bogosort

Алгоритм сортировки, предполагающий, что многомировная интерпретация квантовой механики верна:

• Убедитесь, что список отсортирован. Если нет, уничтожьте вселенную.

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

Ответ 4

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

#!/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 числа, является неадекватным.

Ответ 5

Jingle Sort, как описано здесь.

Вы даете каждое значение в своем списке другому ребенку на Рождество. Дети, будучи ужасными людьми, будут сравнивать ценность своих даров и соответственно сортировать их.

Ответ 6

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

Лучший случай O (N) (первый раз, детка!) Худший случай O (Никогда)

Ответ 7

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

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

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

list = someList
while (list not sorted):
    doNothing

Ответ 8

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

Ответ 9

Здесь 2 вида я придумал своего соседа по комнате в колледже

1) Проверить заказ 2) Возможно, произошло чудо, перейдите к 1

и

1) проверьте, если он в порядке, если не 2) помещает каждый элемент в пакет и отскакивает его от удаленного сервера обратно к себе. Некоторые из этих пакетов возвращаются в другом порядке, поэтому перейдите к 1

Ответ 10

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

Ответ 11

Всегда Богбогосорт (Богообразование!). Он выполняет 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; }
}

Ответ 12

1 Поместите свои предметы для сортировки по индексным картам
  2 Бросьте их в воздух в ветреный день, в миле от вашего дома.
 2 Бросьте их в костер и убедитесь, что они полностью уничтожены.
 3 Проверьте свой пол кухни для правильного заказа.
 4 Повторите, если это не правильный порядок.

Лучшим случаем scenerio является O (∞)

Изменить выше на основе проницательного наблюдения KennyTM.

Ответ 13

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

• Обратите внимание на системное время.
• Сортировать по Quicksort (или что-нибудь еще разумно разумное), опустив последний обмен.
• Обратите внимание на системное время.
• Вычислите требуемое время. Требуется арифметика с высокой точностью.
• Подождите требуемое время.
• Выполните последний обмен.

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

Ответ 14

Существует вид, называемый bogobogosort. Во-первых, он проверяет первые 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 (число бит в 32-битном целочисленном) N) (количество элементов) (число <= 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 лет.

Ответ 15

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

Ответ 16

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

Ответ 17

Наихудшая производительность O (∞) может даже не сделать ее алгоритмом согласно некоторым.

Алгоритм - это всего лишь последовательность шагов, и вы всегда можете сделать что-то хуже, немного изменив его, чтобы получить желаемый результат в большем количестве шагов, чем это было раньше. Можно было бы точно указать количество шагов, взятых в алгоритм, и заставить его закончить и произвести правильный вывод только после X было сделано несколько шагов. То, что X вполне может быть порядка O (n ²) или O (n ^n!) или независимо от того, какой алгоритм желает сделать. Это будет эффективно увеличивать его наилучшие, а также средние оценки.

Но ваш худший сценарий не может быть увенчан:)

Ответ 18

Сегменты π

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

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

Ответ 19

Мой любимый медленный алгоритм сортировки - это сортировка мародерства:

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.

Ответ 20

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

Ответ 21

Эта страница интересна для чтения на тему: 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; }
        }
}

Ответ 22

Двойной богосорс

Bogosort дважды и сравните результаты (просто чтобы убедиться, что они отсортированы), если не сделать это снова

Ответ 23

Вы можете сделать любой алгоритм сортировки медленнее, выполнив произвольный шаг "он отсортирован". Что-то вроде:

• Создайте массив булевых чисел того же размера, что и сортируемый массив. Установите для них все значение false.
• Запустить итерацию bogosort
• Выберите два случайных элемента.
• Если два элемента сортируются по отношению друг к другу (i < j && array [i] < array [j]), пометьте индексы обоих значений в булевом массиве равным true. Снова, начните сначала.
• Проверьте, истинны ли все логические числа в массиве. Если нет, вернитесь к 3.
• Готово.

Ответ 24

Да, SimpleSort, теоретически он работает в O(-1), но это эквивалентно O(...9999), что в свою очередь эквивалентно O (& infin; - 1), что, как это бывает, также эквивалентно O (& infin;). Вот моя примерная реализация:

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

Ответ 25

Один из них, над которым я только работал, включает в себя сбор двух случайных точек, и если они находятся в неправильном порядке, перевернув весь поддиапазон между ними. Я нашел алгоритм на http://richardhartersworld.com/cri_d/cri/2001/badsort.html, в котором говорится, что средний случай, вероятно, где-то вокруг O (n ^ 3) или O (n ^ 2 log n) (он не уверен).

Я думаю, что было бы возможно сделать это более эффективно, потому что я думаю, что можно было бы сделать операцию разворота в течение O (1).

На самом деле, я просто понял, что это сделает все, что я скажу, может быть, потому, что я просто понял, что структура данных, которую я имел в виду, будет обращаться к случайным элементам в O (log n) и определять, нужно ли ей реверсировать на О (п).

Ответ 26

Randomsubsetsort.

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

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