在BFS算法中，嵌套循环嵌套的时间复杂性是什么？

Question

因此，我编写了一种算法，该算法返回连接到一个给出节点的节点列表，并且在无方向图中的最大跃点内。

注意：无向图表示如果A连接到B，则B也将B连接到A。

基本上，EDGES如下：

"A", "B"
"A", "C"
"B", "D"
"C", "E"
"E", "F"
"E", "G"

边缘存储在Hashmap中如下：

{"A": ["B","C"]}, {"B", ["A", "D"]}... goes on.

和findNodes（“ C”，2）返回[“ a”，“ b”，“ e”，“ f”，“ f”，“ g”] 或findnodes（“ A”，1）返回[“ B”，“ C”]。

我应用了BFS算法如下：

• 将第一个节点添加到队列。
• 创建循环直到队列变为nil或 counter 变得与 maxhop 相同。
• 获取队列中的节点数量。
• 轮询节点并将其标记为 CurrentNode
• 根据队列数量创建循环。
• 然后创建另一个循环以获取 CurrentNode 的邻居，

因此，该算法如下。我对算法的时间复杂性感到非常困惑。有什么建议吗？

我不像具有o（n^3）时间复杂性的算法。达到正确时间复杂的正确方法是什么？因为每个循环和循环都取决于某种条件（应该是），但是时间复杂性是多少？

// FindNodes returns list of nodes connected to a given node and within a max number of hops
// e.g. "A", 2 -> ["B", "C", "D", "E"]
func (ug *UndirectedGraph) FindNodes(node string, maxHops int) []string {
    // if hop number is 0 then it returns the root, node itself.
    if maxHops == 0 {
        return []string{node}
    }

    result := []string{}
    counter := 0
    queue := Queue{Nodes: []string{}}
    queue.add(node)

    for len(queue.Nodes) != 0 && counter != maxHops {

        cnt := len(queue.Nodes)
        for i := 0; i < cnt; i++ {
            currentNode := queue.poll()
            if _, ok := ug.Visited[currentNode]; ok {
                continue
            }

            ug.Visited[currentNode] = true
            neighbours := ug.Edges[currentNode]
            for _, neighbour := range neighbours {
                if _, ok := ug.Visited[neighbour]; !ok {
                    result = append(result, neighbour)
                    queue.add(neighbour)
                }
            }
        }

        counter += 1
    }
    return result
}