Sorting 如何编写比O（n！）更差的排序

我写了一个O（n！）排序是为了消遣，如果不完全替换它，就不能简单地优化以运行得更快。[不，我并不是在对项目进行排序之前随机化的]

我如何才能编写一个更糟糕的Big-O排序，而不只是添加可以被拉出以降低时间复杂性的无关垃圾

具有按增长顺序排序的各种时间复杂性

编辑：我找到了代码，这是我的O（n！）确定性排序，用有趣的技巧生成一个列表的所有组合的列表。我有一个稍微长一点的get_all_combination版本，它返回一个组合的iterable，但不幸的是，我不能使它成为一个单独的语句。[希望我没有通过在下面的代码中修复拼写错误和删除下划线来引入bug]

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]

def mysort（somelist）：
对于get_all_置换（somelist）中的置换：
如果已排序（排列）：
返回置换
def已排序（somelist）：
#注意：这可以合并为退货。。。类似return len（foo）的东西，我提到过，我能想到的一种方法是，通过一个函数来计算每个元素的后位置，该函数逐渐地将大元素移动到末尾，将小元素移动到开头。如果使用基于trig的函数，可以使元素在列表中紧密接触，而不是直接指向它们的最终位置。处理完集合中的每个元素后，执行完整遍历以确定数组是否已排序

我不确定这是否会给你O（n！），但它应该仍然非常慢。
永远不会有运动，这就是O(∞):

PS：我真的很想看看你的确定性O（n！）排序；我想不出任何一个是O（n！），但是在经典计算中有一个有限的上界（也就是确定性）

PPS：如果您担心编译器会清除空白while块，可以通过在块内和块外使用变量来强制它：

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

我认为如果你进行大量复制，那么你可以得到一个“合理的”暴力搜索（N！），每个案例需要N^2次，给出N！*N^2
有一个（经验证的！）最差的排序算法，它使用“乘法和投降”范例，并以指数时间运行

虽然您的算法速度较慢，但它不会稳定地进行，而是执行随机跳跃。此外，当您的算法是常量时，慢速排序的最佳情况仍然是指数型的。
如何循环n个整数的所有数组t（n个整数元组是可数的，因此这是可行的，尽管它是一个无限循环），而对于其中每一项：


如果它的元素正好是输入数组的元素（参见下面的algo！），并且数组被排序（例如线性algo，但我相信我们可以做得更糟），那么返回t
否则继续循环

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


测试a[i]==b[j]：
如果是，当且仅当通过从a中移除a[i]和从b中移除b[j]而获得的列表的递归调用返回TRUE时，才返回TRUE
继续在对上循环，如果所有对都完成了，则返回FALSE

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

不过，说真的，这样的问题有意义吗

编辑：

@Jon，你的随机排序平均为O（n！）（因为有n！个排列，你有1/n！的概率找到正确的一个）。这适用于具有不同整数的数组，如果某些元素在输入数组中多次出现，则可能略有不同，然后取决于输入数组元素的分布（在整数中）.
你总是可以进行随机排序。它的工作原理是随机重新排列所有元素，然后检查是否已排序。如果未排序，则随机对其进行排序。我不知道它如何适合大O表示法，但它肯定会很慢！
这是你可以得到的最慢、有限的排序：

将快速排序的每个操作链接到Busy Beaver函数

当您获得>4个操作时，您将需要向上箭头表示法：）

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