Как делают я пишу вид, хуже, чем O (n!)

Chris и я упомянули Bozosort и Bogosort в другом вопросе.

Вы могли всегда делать Случайный вид. Это работает путем реконструкции всех элементов случайным образом, затем проверки, чтобы видеть, отсортировано ли это. В противном случае это случайным образом обращается их. Я не знаю, как это вписалось бы в нотацию "большого О", но это определенно будет медленно!

Всегда существует NeverSort, который является O (∞):

def never_sort(array)
  while(true)
  end
  return quicksort(array)
end

PS: Я действительно хочу видеть Ваш детерминированный O (n!) вид; я не могу думать ни о ком, которые являются O (n!), но имеют конечную верхнюю границу в классическом вычислении (иначе детерминированы).

PPS: Если Вы волнуетесь по поводу компилятора, вытирающего настолько пустой, в то время как блок, можно вызвать его не к при помощи переменной оба внутри и снаружи блока:

def never_sort(array)
  i=0
  while(true) { i += 1 }
  puts "done with loop after #{i} iterations!"
  return quicksort(array)
end

Вот самый медленный, конечный вид, который можно получить:

Свяжите каждую деятельность Quicksort к Занятой функции Бобра.

К тому времени, когда Вы добираетесь> 4 операции, Вам будет нужна нотация стрелки вниз :)

Существует (доказанный!) худший алгоритм сортировки, названный медленным видом, который использует “, умножает и сдает” парадигму и выполнения в экспоненциальное время.

В то время как Ваш алгоритм медленнее, он не прогрессирует постоянно, но вместо этого выполняет случайные переходы. Кроме того, замедлитесь, лучший случай вида все еще экспоненциален, в то время как Ваш является постоянным.

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

Я не положителен, что это даст Вам O (n!), но это должно все еще быть довольно медленно.

Я думаю, что, если Вы делаете большое копирование затем, можно получить "разумный" поиск грубой силы (N!) для взятия времени N^2 на случай, дающий N! *N^2

Как насчет цикличного выполнения по всем массивам t n целых чисел (n-кортежи целых чисел исчисляемы, таким образом, это выполнимо, хотя это - бесконечный цикл, конечно), и для каждого из них:

• если его элементы являются точно теми из входного массива (см. алгоритм ниже!) и массив отсортирован (линейный алгоритм, например, но я уверен, что мы можем сделать хуже), затем возвратите t;
• иначе продолжите цикличное выполнение.

Чтобы проверить, что два массива a и b длины n содержат те же элементы, как насчет следующего рекурсивного алгоритма: цикл по всем парам (я, j) индексов между 0 и n-1, и для каждой такой пары

• протестируйте если [я] == b [j]:
• если так, возвратите TRUE, если и только если рекурсивный вызов в списках, полученных путем удаления [я] из a и b [j] от b, возвращает TRUE;
• продолжите цикличное выполнение по парам, и если все пары сделаны, возвращают FALSE.

Время будет во многом зависеть от распределения целых чисел во входном массиве.

Серьезно, тем не менее, существует ли точка к такому вопросу?

Править:

@Jon, Ваш случайный вид был бы в O (n!) в среднем (так как существуют n! перестановки, у Вас есть вероятность 1/n! из нахождения правильного). Это содержит для массивов отличных целых чисел, могло бы немного отличаться, если бы некоторые элементы имеют несколько происшествий во входном массиве и затем зависели бы от распределения элементов входных массивов (в целых числах).