Python 排列算法分析

我一直在疯狂地学习算法，准备参加一个大型面试。这个特殊的算法快把我逼疯了，我给一些不懂的行添加了注释

def permute(s):
    out = []

    if len(s) == 1:
        # wouldn't setting out replace everything in out?
        out = [s]

    else:
        for i, let in enumerate(s):

            # how does it know that I only want 2 strings?
            for perm in permute(s[:i] + s[i+1:]):

                out += [let + perm]

    return out

print permute("cat")

---

说这个算法的时间复杂度是O（n！）是正确的吗？

最初out是在permute方法的上下文中定义的，因此每个调用都有自己的out向量。因此，当重新定义

out=[s]

时，只需覆盖方法上下文中的

out=[]

如果输入大于一个字符，则会发生以下情况：

# Iterate for each char
for i, let in enumerate(s):
    # Iterate for each permutation of the string without the char i
    for perm in permute(s[:i] + s[i+1:]):
            # Put the removed char in the beginning of the permutation
            # and add it to the list.
            out += [let + perm]

---

最初out是在permute方法的上下文中定义的，因此每个调用都有自己的out向量。因此，当重新定义

out=[s]

时，只需覆盖方法上下文中的

out=[]

如果输入大于一个字符，则会发生以下情况：

# Iterate for each char
for i, let in enumerate(s):
    # Iterate for each permutation of the string without the char i
    for perm in permute(s[:i] + s[i+1:]):
            # Put the removed char in the beginning of the permutation
            # and add it to the list.
            out += [let + perm]

---

为了好玩，这里是该算法的生成器版本。它更好一点，因为它不需要那些

out

列表

def permute(s):
    if len(s) == 1:
        yield s
    else:
        for i, let in enumerate(s):
            for perm in permute(s[:i] + s[i+1:]):
                yield let + perm

for s in permute("abc"):
    print(s)

输出

abc
acb
bac
bca
cab
cba

---

当然，除非问题需要递归（例如处理递归数据结构，如树），否则最好避免递归（尤其是在Python中）。当然，真正的Python程序通常会使用，除非它需要正确处理基序列中的重复项。在这种情况下，我推荐Narayana Pandita的迭代算法，如所示。

为了好玩，这里是该算法的生成器版本。它更好一点，因为它不需要那些

out

列表

def permute(s):
    if len(s) == 1:
        yield s
    else:
        for i, let in enumerate(s):
            for perm in permute(s[:i] + s[i+1:]):
                yield let + perm

for s in permute("abc"):
    print(s)

输出

abc
acb
bac
bca
cab
cba

---

当然，除非问题需要递归（例如处理递归数据结构，如树），否则最好避免递归（尤其是在Python中）。当然，真正的Python程序通常会使用，除非它需要正确处理基序列中的重复项。在这种情况下，我推荐Narayana Pandita的迭代算法，如所示。

作为旁白——在面试中，面试官通常不在乎你是否得到了正确的答案。他们试图找出你是如何处理问题的。它实际上比O（n！）更糟糕，给出了顺序：1，3，10，4120612378660，…我没有得到这样的评论：“#它怎么知道我只需要两个字符串？”

s[：I]+s[I+1:]

创建一个字符串，它是

s

的副本，索引

i

处的字符被删除。至于您的第一条评论，请记住对

permute

的每个递归调用都会得到自己的新

列表。我实际上会将
out=[s]
更改为
返回[s]
。这是一个基本情况，直接从中返回对我来说似乎更清楚。作为旁白——在面试中，面试官通常不在乎你是否得到了正确的答案。他们试图找出你是如何处理问题的。它实际上比O（n！）更糟糕，给出了顺序：1，3，10，4120612378660，…我没有得到这样的评论：“#它怎么知道我只需要两个字符串？”
s[：I]+s[I+1:]
创建一个字符串，它是
s
的副本，索引
i
处的字符被删除。至于您的第一条评论，请记住对
permute
的每个递归调用都会得到自己的新
列表。我实际上会将
out=[s]
更改为
返回[s]
。这是一个基本情况，直接从它返回对我来说似乎更清楚。