深度优先搜索的大 O = O(V+E) 如何？ [复制]

Question

我试图了解DFS 的复杂性如何/为什么为 O(V+E)。这是我分析伪代码迭代 DFS 复杂性的尝试。

DFS(G, t)
{

1   stack S = new empty Stack of size G.|V|  ... O(1)
2   S.push(t)                                ... O(1)

3   while(S is not Empty)                    ... O(|V|), this will always be =<|V|
    {
4       u = S.pop()                          ... O(1)

5       if(u.visited = false)                ... O(1)
        {
6            u.visited = true                ... O(1)

7            for-each edge (u,v) in G.E      ... O(|E|), this will always be =<|E|
8                if(v.visited = false)       ... O(1)
9                    S.push(v)               ... O(1)
        }
    }
}

现在结合我们拥有的每一行的复杂性：

O(1) + O(1) + O(|V|)[O(1) + O(1) + O(1) + O(E)[O(1) + O(1)] ] = O(2) + O(V) + O(V) + O(V) + O(V) + O(V * E) + O(V * E) = 4*O(V) + 2* O(V * E) = O(V * E)

我没有得到 O(V+E)？谁能告诉我数学上我们是如何达到 O(V+E) 的？

谁能提供见解？

Answer 1

让我们把它变得简单。

外部循环，它只循环S 一次，删除它看到的每个元素。因此 O(|V|) 在您的符号中。

内部循环，它只在你的边缘循环一次，删除它看到的每个元素。因此 O(|E|) 在您的符号中。

但是，并不是S 的每个元素都删除了每条边。您删除所有节点和所有边，因此 O(|V|+|E|)。

但应注意，上述内容仅在意图上是正确的。您的实现相对糟糕，实际上是O(|V|*|E|)，因为您没有从列表中删除边，您只将节点标记为已访问。最后的效果相同，但您仍然循环遍历每个节点的每条边。