Question

我为我的娱乐写了一个O（n！）排序，不能轻易优化以便在不完全替换它的情况下更快地运行。 [不，我不只是将这些项目随机化，直到它们被排序]。

我怎么可能写出更糟糕的Big-O排序，而不仅仅是添加可以拉出以减少时间复杂度的无关垃圾？

http://en.wikipedia.org/wiki/Big_O_notation有各种时间复杂度按生长顺序排序。

编辑：我找到了代码，这里是我的O（n！）确定性排序，有趣的黑客生成列表的所有组合的列表。我有一个稍微长一点的get_all_combinations版本，它返回一组可迭代的组合，但遗憾的是我无法将它作为单个语句。 [希望我没有通过修复拼写错误和删除下面代码中的下划线来引入错误]

def mysort(somelist):
    for permutation in get_all_permutations(somelist):
        if is_sorted(permutation):
            return permutation

def is_sorted(somelist):
    # note: this could be merged into return... something like return len(foo) <= 1 or reduce(barf)
    if (len(somelist) <= 1): return True
    return 1 > reduce(lambda x,y: max(x,y),map(cmp, somelist[:-1], somelist[1:]))

def get_all_permutations(lst):
    return [[itm] + cbo for idx, itm in enumerate(lst) for cbo in get_all_permutations(lst[:idx] + lst[idx+1:])] or [lst]

Answer 1

有一种称为slow sort的最差排序算法（使用“乘法和退出”范式）并以指数时间运行。

虽然您的算法速度较慢，但它不会稳定地进行，而是执行随机跳转。另外，慢速排序的最佳情况仍然是指数级的，而你的是恒定的。

Answer 2

Chris我在Bozosort

中提到了Bogosort和different question.

Answer 3

永远存在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

Answer 4

您可以随时进行随机排序。它通过随机重新排列所有元素，然后检查它是否已排序。如果没有，它会随机调整它们。我不知道它如何适合大O符号，但它肯定会很慢！

Answer 5

这是你可以获得的最慢，有限的排序：

将Quicksort的每个操作链接到Busy Beaver功能。

当您获得＆gt; 4次操作时，您需要使用向上箭头表示法：）

Answer 6

我能想到的一种方法是通过一个函数来计算每个元素的post位置，这个函数逐渐变化，将大元素移动到最后，将小元素移动到开头。如果您使用了基于触发器的函数，则可以使元素通过列表填充，而不是直接朝向它们的最终位置。处理完集合中的每个元素后，再进行完全遍历以确定数组是否已排序。

我不肯定这会给你O（n！），但它仍然应该很慢。

Answer 7

我认为如果你进行大量的复制，那么你可以得到一个“合理的”暴力搜索（N！），每个案例花费N ^ 2次给N！* N ^ 2

Answer 8

如何循环遍历n个整数的所有数组t（整数的n元组是可数的，所以这是可行的，虽然它当然是无限循环），并且对于每个整数：

如果它的元素正好是输入数组的那些（参见下面的算法！）并且数组已经排序（例如线性算法，但我确信我们可以做得更糟），然后返回t;
否则继续循环。

要检查长度为n的两个数组a和b是否包含相同的元素，下面的递归算法如何：循环遍历0到n-1之间索引的所有对（i，j），并且对于每个这样的对< / p>

测试a [i] == b [j]：
如果是这样，当且仅当通过从a中删除[i]并从b中删除b [j]获得的列表上的递归调用返回TRUE时，返回TRUE;
继续循环夫妻，如果所有夫妻都完成了，则返回FALSE。

时间将在很大程度上取决于输入数组中整数的分布。

但是，说真的，有这样一个问题吗？

编辑：

@Jon，你的随机排序平均在O（n！）中（因为有n个排列，你有1 / n！找到正确的概率）。这适用于不同整数的数组，如果某些元素在输入数组中有多个出现，则可能略有不同，然后依赖于输入数组元素的分布（在整数中）。

我怎么写比O更糟糕的那种（n！）

8 个答案: