我为我的娱乐写了一个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]

===============>>#1 票数:8

有一种(经过验证的!)最差的排序算法称为慢排序 ,它使用“乘法和投降”范式,并以指数时间运行。

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

===============>>#2 票数:3

克里斯和我在一个不同的问题上提到了BozosortBogosort

===============>>#3 票数:2

永远都是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

===============>>#4 票数:1

这是您可以得到的最慢,有限的排序:

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

当你获得> 4次操作时,你需要使用向上箭头表示法:)

===============>>#5 票数:1

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

===============>>#6 票数:0

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

我不肯定这会给你O(n!),但它仍然应该很慢。

===============>>#7 票数:0

我认为,如果你进行大量的复制,那么你可以得到一个“合理的”暴力搜索(N!),每个案例需要N ^ 2次,给N!* N ^ 2

===============>>#8 票数:0

如何循环遍历所有n个整数的数组(整数的n元组是可数的,所以这是可行的,虽然它当然是无限循环),并且对于以下每个:

  • 如果它的元素正好是输入数组的元素(参见下面的算法!)并且数组已经排序(例如,线性算法,但我确定我们可以做得更糟),然后返回t;
  • 否则继续循环。

为了检查长度为n的两个数组a和b是否包含相同的元素,下面的递归算法怎么样:循环遍历0到n-1之间索引的所有对(i,j),并且对于每个这样的对

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

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

但是,说真的,有这样一个问题吗?

编辑:

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

  ask by sphereinabox translate from so

未解决问题?本站智能推荐:

1回复

在O(n)中对m个总共O(n)个元素进行排序

假设我们有m个{1...n}中元素的集合S1,S2,...,Sm ,假定m = O(n), |S1|+|S2|+...+|Sm|=O(n)对O(n)时间和O(n)空间中的所有集合进行排序。 我当时正在考虑在每个集合上使用计数排序算法。 每个集合的计数排序将为O(S1)+O(S2)+...
1回复

在O中排序数组(n log(log n))

我试图解决以下任务:我给了一个n元素的数组。 众所周知,并非所有数组的键都是不同的,但我们有k个不同的元素(当然k <= n)。 赋值是在O(n log(log n))最坏情况下对数组进行稳定排序,而k = O(log n)。 我被允许使用O(n)额外的内存。 我目前的解决方案
2回复

你能说(n lg n)是O(n ^ 2)吗?

我知道给定O(n lg n)和O(n^2) ,当n足够高时, (n lg n)更小。 但O(n^2)是否正确评估(n lg n) ? O(n lg n)和O(n^2)有很大的不同,所以我不确定O(n^2)是(n lg n) “最坏情况”的最佳答案
6回复

为什么冒泡排序O(n ^ 2)?

内循环迭代:n +(n-1)+(n-2)+(n-3)+ ... + 1次。 外循环迭代:n次。 所以你得到n *(数字1到n的总和) 不是n *(n *(n + 1)/ 2)= n *((n ^ 2)+ n / 2) 哪个是(n ^ 3)+(n ^ 2)/ 2 = O(
4回复

通用和实用的排序算法比O(n log n)更快?

是否存在比O(n log n)运行得更快的通用元素(与计数排序或桶排序不同)的实用算法?
1回复

基数排序和O(N log N)效率

我最近一直在学习Radix排序,而我使用的来源之一是Wikipedia页面。 目前,存在以下有关算法效率的段落: 与其他排序算法相比,基数排序效率的主题有些棘手,并且存在很多误解。 基数排序是否比基于比较的最佳算法效率更高,效率更低或更低,取决于所做假设的细节。 基数排序复杂度为
1回复

如何改进已经为O(n)的递归排序算法?

我有用于分配的递归排序算法,我的老师说,有一种简单的方法可以缩短算法的运行时间...但是我根本不知道它是什么。 除非我没有记错,否则算法的复杂度为O(n)? 我不确定,因为我们没有学习如何计算类中递归方法的复杂性。 这是代码: 我唯一想到的就是添加if(done)返回值; 在第一
1回复

基数排序-O(n)时间

我听说如果我们要对n数字进行排序,并且将要排序的数字转换为基数n,那么可以在O(n)时间执行基数排序。 我说对了吗? 如果是这样,这是如何实现的。 如果我们要处理5个数字,并将它们全部转换为5,则可以将数字分成5个存储桶(0、1、2、3、4)。 即使我们处理的数字最多只有7位
2回复

在Java中优化Mergesort for O(Nlog(N))

合作伙伴和我正在尝试用Java编写Mergesort。 我们已经完成了算法,并且它正常运行。 但是,在测试各种输入的算法时,我们注意到它不在O(Nlog(N))的范围内执行。 我们一直在尝试进一步优化算法,并将欣赏任何和所有建议。 唯一的要求是我们无法更改方法标头。 我们的Java代码
3回复

改进的quicksort可以是O(n)最好的情况吗?

一般认为快速排序的最佳情况是O(nlogn),因为阵列每次分区大约一半。 还有人说最坏的情况是n ^ 2阶,假设数组已经排序。 我们不能通过设置一个名为swap的布尔值来修改quicksort吗? 例如,如果第一遍的位置没有初始交换,那么我们可以假设数组已经排序,因此不再对数据进行分区