Python 这些置换算法的大O表示法是什么

通过“破解编码面试”，一个练习题说

给定两个字符串，编写一个方法来确定其中一个字符串是否是另一个字符串的置换

作者的python解决方案如下：

def check_permutation(str1, str2):
    if len(str1) != len(str2):
        return False
    counter = Counter()
    for c in str1:
        counter[c] += 1
    for c in str2:
        if counter[c] == 0:
            return False
        counter[c] -= 1
    return True 

def perm(str1,str2):
    if(len(str1) != len(str2)):
        return False
    for c in str1:
        if c not in Str2:
            return False
    return True 

它声称在O（N）时间内

我的解决办法如下：

def check_permutation(str1, str2):
    if len(str1) != len(str2):
        return False
    counter = Counter()
    for c in str1:
        counter[c] += 1
    for c in str2:
        if counter[c] == 0:
            return False
        counter[c] -= 1
    return True 

def perm(str1,str2):
    if(len(str1) != len(str2)):
        return False
    for c in str1:
        if c not in Str2:
            return False
    return True 

我相信这也是O（N）。这是真的吗？哪种算法是有利的？作者的数据类型似乎不必要

最后，这个算法是O（NlogN）吗

---

首先，作者的解决方案是一个优化版本的

计数器（str1）=计数器（str2）

（它更快地返回

False

，并创建

计数器的单个实例）。
它确实是
O（n）
，因为哈希表（
Counter
）访问是
O（1）

接下来，您的解决方案是二次的（
O（n^2）
），因为
中的每个
都是
O（n）
——它必须遍历整个字符串。
在有重复的字符串上也是错误的

第三，
sorted（str1）==sorted（str2）
确实是线性的（
O（n*log（n））
）
因此比原始线性解更差

但是，请注意，对于小字符串，常量可能会导致
差异和线性（
排序
）解决方案可能是
比线性（
计数器
）计数器快

最后，请注意Python通常是使用解释器实现的，因此实际性能可能取决于您使用的是用C还是用Python实现的功能。例如，如果
计数器
是用C实现的，那么
计数器（str1）=计数器（str2）
可能会轻而易举地超过作者的解决方案，即使在算法上，作者的解决方案更好。
对于第一个代码，使用
集合可能很容易。计数器
代替循环：

def check_permutation(str1, str2):
    if len(str1) != len(str2):
        return False
    return Counter(str1) == Counter(str2)

它又是
O（n）
。最后一个algorihtm，因为有一个排序，使用
排序
它是
O（nlogn）

您的算法不正确，因为您在另一个字符串中找到一个字符，而不考虑该字符的重复次数。如果这是真的，它将是
O（n^2）

因此，一般来说，第一种算法具有最佳的时间复杂度，并且易于实现。
作者的代码不能简化为这样：
返回计数器（str1）=计数器（str2）
？对于
置换（“ABB”，“BAA”）
，函数返回true，这两种置换不是彼此的置换。作者的解决方案计算字符的出现次数。是的，你的代码根本不能很好地处理重复。如果你对两个字符串进行排序，然后在每个索引中检查是否相等，那么你可以很容易地生成一个
O（nlogn）
解决方案。现在请查看我的缺陷，谢谢@khelwood。第三种算法有效吗？