Python 该算法的算法复杂度为查找长度为X的所有有序排列

我编写了一个递归函数，用于为字符列表生成长度为X的所有有序排列的列表

例如，['a'，b'，c'，d'，X=2将给出['a'，a'，['a'，b'，['a'，c']，['a'，d']，['b'，a']，['b'，b']，…，['d'，d']]

不过，我不确定它的算法复杂性（至少我知道它相当可怕）。我想说的是，这是周围的东西：

O（X*N^（L+X））

（其中L是不同字符的数量，这里是4，因为我们有'A'，'B'，'C'，'D'，X是我们想要生成的排列的长度）。 因为我有两个嵌套循环，它们将运行X次（好吧，X-1是因为X=1的特殊情况）。 对吗

def generate_permutations(symbols, permutations_length):
    if permutations_length == 1:
        return [[symbol] for symbol in symbols]

    tails = generate_permutations(symbols, permutations_length-1)
    permutations = []

    for symbol in symbols:
        for tail in tails:
            permutation = [symbol] + tail

            permutations.append(permutation)

    return permutations


print(generate_permutations(['a', 'b', 'c', 'd'], 2))

顺便说一句：我知道这不是惯用的Python，如果它难看的话，我很抱歉，但这只是我在用另一种表达性较差的语言编写代码之前正在做的一些原型设计。 我也知道我可以使用itertools.permutations来完成这个任务。顺便说一句，如果有人碰巧知道itertool置换函数的算法复杂性，以及是否有某种方法可以提高我自己算法的复杂性，我会感兴趣

---

谢谢

当

X

=1时生成的步骤数为：

N(1) = L

在递归步骤中，步骤数是由于递归调用而在

X-1

处的步骤数，加上由于循环而在

L*N（X-1）

处的步骤数：

N(X) = N(X-1) + L * N(X-1)

显然

L*N（X-1）

支配

N（X-1）

，因此我们可以忽略

N（X-1）

项

渐近代价为O（L^X）

---

LX恰好也是结果中的项数，因此使用python列表不可能有更好的渐近代价。

从数学上讲，所有有序排列本身的数量等于LPX，如上所述

LPX

=L*（L-1）*.*（L-X+1）

大约等于LX

现在，通过在现有字符串长度中一次添加一个字符，逐步生成长度

X

的每个最终排列，即总复杂度值

O（1+2+3+…+X）

，或O（X2）

---

最后，您的python实现实际上是一个最佳递归的示例，并采用了算法复杂性O（X2*LPX）

我认为应该在这里的代码审查部分问这个问题：嗨！我不确定codereview.stackexchange.com和stackoverflow之间的区别。你认为这里不是合适的地方吗？不同的是你希望你的代码被审查。这意味着您想知道您的代码是否性能良好、干净，以及是否可以改进。代码审查堆栈仅用于此目的。实际上，我不想知道我的代码是否干净或可以改进（我相信它可以），我只对其对数复杂性感兴趣。这就是审查@Matthieu，您将在那里得到更多响应。谢谢！但是说实话，我不明白为什么循环的复杂度是L*N（X-1）。你知道有没有更好的算法，而不是你所建议的列表吗？想想有多少项是在

尾部

中。然后您将嵌套for循环，迭代

符号

和

尾部

，因此步数是这两个长度的乘积。