为什么此函数O（n ^ 2）最坏的情况？

我正在尝试教自己如何为任意函数计算BigO表示法。我在教科书中找到了此功能。该书断言该函数为O（n ²）。它解释了为什么这样做，但是我一直在努力遵循。我想知道是否有人能够向我展示为什么会这样。从根本上讲，我知道它小于O（n ³），但我无法独立降落在O（n ²）上

假设给定了三个数字序列，A，B和C。我们将假定没有单个序列包含重复值，但是在两个或三个序列中可能存在一些数字。三向不相交问题是确定三个序列的交点是否为空，即是否不存在元素x使得x∈A，x∈B和x∈C。

顺便说一句，这对我来说不是一个作业问题，因为这艘船几年前已经航行过：），只是我想变得更聪明。

def disjoint(A, B, C):
        """Return True if there is no element common to all three lists."""  
        for a in A:
            for b in B:
                if a == b: # only check C if we found match from A and B
                   for c in C:
                       if a == c # (and thus a == b == c)
                           return False # we found a common value
        return True # if we reach this, sets are disjoint

[编辑]根据教科书：

在改进的版本中，如果幸运的话，不只是节省时间。我们声称不相交的最坏情况下的运行时间为O（n ²）。

我难以理解的这本书的解释是：

为了说明整体运行时间，我们检查了执行每一行代码所花费的时间。在A上进行for循环的管理需要O（n）时间。B上的for循环的管理总共需要O（n ²）时间，因为该循环执行了n次不同的时间。测试a == b被评估O（n ²）次。剩下的时间取决于存在多少对匹配的（a，b）。正如我们已经指出的，最多有n个这样的对，因此对C的循环的管理以及该循环体内的命令最多使用O（n ²）时间。花费的总时间为O（n ²）。

（并给予应有的荣誉……）这本书是：Michael T. Goodrich等人的《 Python中的数据结构和算法》。全部，Wiley Publishing，第16页。135

理由 下面是优化前的代码：

def disjoint1(A, B, C):
    """Return True if there is no element common to all three lists."""
       for a in A:
           for b in B:
               for c in C:
                   if a == b == c:
                        return False # we found a common value
return True # if we reach this, sets are disjoint

在上面，您可以清楚地看到这是O（n ³），因为每个循环必须充分运行。这本书会断言，在简化的示例中（首先给出），第三个循环只是O（n ²）的复杂度，因此复杂度方程为k + O（n ²）+ O（n ²），最终得出O（n ²）。

虽然我不能证明是这种情况（因此是问题），但读者可以同意简化算法的复杂度至少要比原始算法少。

[编辑]并证明简化版本是二次的：

if __name__ == '__main__':
    for c in [100, 200, 300, 400, 500]:
        l1, l2, l3 = get_random(c), get_random(c), get_random(c)
        start = time.time()
        disjoint1(l1, l2, l3)
        print(time.time() - start)
        start = time.time()
        disjoint2(l1, l2, l3)
        print(time.time() - start)

产量：

0.02684807777404785
0.00019478797912597656
0.19134306907653809
0.0007600784301757812
0.6405444145202637
0.0018095970153808594
1.4873297214508057
0.003167390823364258
2.953308343887329
0.004908084869384766

由于第二个差相等，因此简化函数的确是二次的：

[编辑]还有进一步的证明：

如果我假设最坏的情况（A = B！= C），

if __name__ == '__main__':
    for c in [10, 20, 30, 40, 50]:
        l1, l2, l3 = range(0, c), range(0,c), range(5*c, 6*c)
        its1 = disjoint1(l1, l2, l3)
        its2 = disjoint2(l1, l2, l3)
        print(f"iterations1 = {its1}")
        print(f"iterations2 = {its2}")
        disjoint2(l1, l2, l3)

产量：

iterations1 = 1000
iterations2 = 100
iterations1 = 8000
iterations2 = 400
iterations1 = 27000
iterations2 = 900
iterations1 = 64000
iterations2 = 1600
iterations1 = 125000
iterations2 = 2500

使用第二次差异测试，最坏情况的结果恰好是二次的。

这本书确实是正确的，并且提供了很好的论据。请注意，时序并不是算法复杂度的可靠指标。时间安排可能仅考虑特殊的数据分布，或者测试用例可能太小：算法复杂度仅描述资源使用或运行时如何扩展超出某些适当大的输入大小。

本书提出这样的论点，即复杂度为O（n²），因为if a == b分支最多输入n次。这不是显而易见的，因为循环仍被编写为嵌套的。如果我们提取它，则更加明显：

def disjoint(A, B, C):
  AB = (a
        for a in A
        for b in B
        if a == b)
  ABC = (a
         for a in AB
         for c in C
         if a == c)
  for a in ABC:
    return False
  return True

此变量使用生成器表示中间结果。

• 在生成器中AB，我们最多具有 n个元素（因为保证输入列表不会包含重复项），并且生成生成器的复杂度为O（n²）。
• 制造发生器ABC包括在所述发电机的环路AB长度的Ñ及以上C长度的Ñ，使得其算法复杂度是O（N²）为好。
• 这些操作不是嵌套的，而是独立发生的，因此总复杂度为O（n²+n²）= O（n²）。

由于可以顺序检查成对的输入列表，因此可以在O（n²）时间内确定是否有任何数量的列表不相交。

这种分析是不精确的，因为它假定所有列表的长度都相同。我们可以更准确地说，AB最大长度为min（| A |，| B |），而产生它的复杂度为O（| A |•| B |）。生产ABC具有复杂度O（min（| A |，| B |）•| C |）。然后，总复杂度取决于输入列表的排序方式。与| A | ≤| B | ≤| C | 我们得到O（| A |•| C |）的总最坏情况复杂度。

请注意，如果输入容器允许进行快速成员资格测试，而不必遍历所有元素，则可能会提高效率。当对它们进行排序以便可以进行二进制搜索时，或者当它们是哈希集时，可能就是这种情况。如果没有显式的嵌套循环，则如下所示：

for a in A:
  if a in B:  # might implicitly loop
    if a in C:  # might implicitly loop
      return False
return True

或在基于生成器的版本中：

AB = (a for a in A if a in B)
ABC = (a for a in AB if a in C)
for a in ABC:
  return False
return True

请注意，如果假定每个列表中的所有元素都不相同，则只能对A中的每个元素进行一次C迭代（如果B中的元素相等）。因此内循环总数为O（n ^ 2）

我们将假定没有单个序列包含重复项。

是非常重要的信息

否则，当A和B相等且包含一个元素重复n次时，优化版本的最坏情况仍将是O（n³）：

i = 0
def disjoint(A, B, C):
    global i
    for a in A:
        for b in B:
            if a == b:
                for c in C:
                    i+=1
                    print(i)
                    if a == c:
                        return False 
    return True 

print(disjoint([1] * 10, [1] * 10, [2] * 10))

输出：

...
...
...
993
994
995
996
997
998
999
1000
True

因此，基本上，作者认为O（n³）最坏情况不应该发生（为什么？），并“证明”最坏情况现在是O（n²）。

真正的优化是使用集合或字典来测试O（1）中的包含。在这种情况下，disjoint每个输入为O（n）。

将事物放入您的书中所用的术语：

我认为您毫无疑问地了解，检查a == b是最坏情况下的O（n ²）。

现在，在最坏的情况下，第三个循环中，每个ain A都具有一个in匹配项B，因此，每次都会调用第三个循环。在a中不存在的情况下C，它将遍历整个C集合。

换句话说，这是1次，每个a1次c，或n * n。O（n ²）

因此，您的书指出了O（n ²）+ O（n ²）。

优化方法的诀窍是偷工减料。仅当a和b匹配时，c才值得一看。现在您可能会发现，在最坏的情况下，您仍然必须评估每个c。这不是真的。

您可能认为最坏的情况是，对a == b的每一次检查都会导致C的运行，因为对a == b的每一次检查都会返回一个匹配项。但这是不可能的，因为这样做的条件是矛盾的。为此，您需要包含相同值的A和B。它们的顺序可能不同，但是A中的每个值都必须在B中具有匹配的值。

现在是踢球者。无法组织这些值，因此对于每个a，您都必须在找到匹配项之前先评估所有b。

A: 1 2 3 4 5
B: 1 2 3 4 5

这将立即完成，因为匹配的1是两个系列中的第一个元素。关于什么

A: 1 2 3 4 5
B: 5 4 3 2 1

这将在A上的第一次运行中起作用：只有B中的最后一个元素才会产生匹配。但是，由于A中的最后一个点已经被1占用了，因此A上的下一个迭代必须已经更快。实际上，这一次只需要进行四次迭代。每次下一次迭代时，情况都会有所改善。

现在我不是数学家，所以我无法证明这会以O（n2）结尾，但是我在木log上可以感觉到。

起初感到困惑，但是Amon的回答确实很有帮助。我想看看我是否可以做一个非常简洁的版本：

对于ain 的给定值A，该函数a与bin中的所有可能值进行比较B，并且仅执行一次。因此，对于给定的时间，a它a == b恰好执行n时间。

B不包含任何重复项（列表中没有一个重复项），因此对于给定的项，最多a只能有一个匹配项。（那是关键）。如果存在匹配项，a则会将其与每种可能的结果进行比较c，这意味着将a == c精确地执行n次。没有匹配的地方，a == c根本不会发生。

因此，对于给定a，存在n比较或多个2n比较。这对于每个都会发生a，因此最佳情况是（n²），最坏情况是（2n²）。

TLDR：每一个值a是对每一个值进行比较b，并针对每一个值c，而不是针对每个组合的b和c。这两个问题加在一起，但不会相乘。

这样考虑，一些数字可能出现在两个或三个序列中，但是这种情况的平均情况是，对于集合A中的每个元素，在b中执行穷举搜索。可以保证对集合A中的每个元素进行迭代，但是这意味着对集合b中少于一半的元素进行迭代。

对集合b中的元素进行迭代时，如果存在匹配项，则会发生迭代。这意味着该不相交函数的平均情况为O（n2），但绝对最差情况可能为O（n3）。如果这本书没有详细介绍，它可能会为您提供一般情况作为答案。