字符串置换算法的时间复杂度答案

【问题标题】：Time complexity of string permutation algorithm字符串置换算法的时间复杂度
【发布时间】：2020-09-25 03:50:13
【问题描述】：

我写了一个简单的算法来返回一个字符串所有可能排列的列表，如下：

def get_permutations(sequence):

'''
Enumerate all permutations of a given string

sequence (string): an arbitrary string to permute. Assume that it is a
non-empty string.

Returns: a list of all permutations of sequence
'''

if len(sequence) <= 1:
    return list(sequence)
else:
    return_list = get_permutations(sequence[1:])
    new_list = []
    for e in return_list:
        for pos in range(len(e) + 1):
            new_list.append(e[:pos] + sequence[0] + e[pos:])
return new_list

从这段代码中，我看到了 O(n* n!) 的时间复杂度，O(n!) 是“return_list”中元素“e”数量的增加趋势，并且有一个嵌套循环随着每个新的递归线性增加，所以据我了解，O(n)。结论是该算法作为一个整体具有 O(n*n!) 复杂度。

然而，在寻找类似的解决方案时，我发现很多线程说这种算法的最佳情况应该只有 O(n!)，所以我的问题是：

是我在复杂性分析中遗漏了什么，还是我的代码不是最优的？如果不是，我该如何正确纠正它？

【问题讨论】：

标签： python algorithm performance time-complexity permutation

【解决方案1】：

采用任何算法，该算法生成并打印出 n 个不同元素序列的所有排列。那么，既然有 n!不同的排列并且每个排列都有 n 个元素，简单地打印出所有排列将花费时间 Θ(n · n!)。在评估生成排列的成本时，请牢记这一点——即使您可以在 O(n!) 时间内生成所有排列，但如果不进行 O(n · n!) 工作查看，您将无法访问所有这些排列他们都。

话虽如此 - 您上面的递归排列生成代码确实在时间 Θ(n · n!) 中运行。还有一些其他生成排列的算法可以生成但不能打印时间 Θ(n!) 的排列，但它们的工作原理不同。

根据经验，我发现除非您仔细查看对排列生成算法的运行时分析，否则您应该怀疑运行时是否为 Θ(n!)。大多数算法都不会达到这个运行时，在那些这样做的情况下，分析有些微妙。换一种说法——你不会错过任何东西；那里有很多“在正确的轨道上但不正确”的主张。 :-)

【讨论】：

【解决方案2】：

我认为您的算法是 O(n * n!)，因为要计算长度为 n 的字符串 x 的排列，您的算法将使用 x 的子字符串的排列，即没有第一个字符的 x。我将把这个子字符串称为 y。但是要计算 y 的排列，需要计算 y 的子串的排列。这将一直持续到要计算其排列的子字符串的长度为 1。这意味着要计算 x 的排列，您将需要计算 n - 1 个其他字符串的排列。

这是一个例子。假设输入字符串是“pie”。然后你的算法所做的是它接受“pie”并用“ie”再次调用它自己，然后用“e”调用它自己。因为“e”的长度为 1，所以它返回并且找到了“ie”的所有排列，即“ie”和 ei”。然后该函数调用将返回“ie”的排列，只有在这一点上“pie”的排列是使用“ie”的排列来计算的。

我查找了一种称为堆算法的置换生成算法，它的时间复杂度为 O(n!)。它的时间复杂度为 n!是因为它使用交换生成排列，并且它在数组上执行的每个交换都会为输入字符串生成一个唯一的排列。但是，您的算法会生成输入字符串的 n-1 个子字符串的排列，这就是 O(n * n!) 的时间复杂度的来源。

我希望这会有所帮助，如果我过于冗长，我深表歉意。

【讨论】：