leetcode--Clone Graph

Depth-first search 深度优先算法，举个例子：二叉树中的前序遍历，一般用递归实现；

Breadth-first search 广度优先算法，举个例子：二叉树的层序遍历，需要用队列实现。

method1:DFS

UndirectedGraphNode *DFS(UndirectedGraphNode *node, unordered_map<int, UndirectedGraphNode *> *existed){
if (node == NULL)
return NULL;
UndirectedGraphNode *ret;
if ((*existed).find(node->label) == (*existed).end())
{

ret = new UndirectedGraphNode(node->label);
(*existed)[node->label] = ret;
}
else
{
ret = (*existed)[node->label];
return ret;
}
int n = node->neighbors.size();
int i = 0;
while (i<n){

ret->neighbors.push_back( DFS(node->neighbors[i],existed));
i++;

}
return ret;
}
UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
if (node == NULL)
return NULL;
unordered_map<int, UndirectedGraphNode *> *existed = new  unordered_map<int, UndirectedGraphNode *>;
return DFS(node, existed);
}

method 2:BFS

UndirectedGraphNode *cloneGraphII(UndirectedGraphNode *node) {
if (node == NULL)
return NULL;
unordered_map<int, UndirectedGraphNode *> visited;
queue<UndirectedGraphNode *> Q;
UndirectedGraphNode *head = new UndirectedGraphNode(node->label);
visited.insert({ node->label, head });
Q.push(node);
while (Q.size() > 0)
{
UndirectedGraphNode *tmp = Q.front();
Q.pop();
int n = tmp->neighbors.size();
head = visited[tmp->label];
for (int i = 0; i < n; ++i)
{
if (visited.find(tmp->neighbors[i]->label) == visited.end())
{
head->neighbors.push_back(new UndirectedGraphNode(tmp->neighbors[i]->label));
Q.push(tmp->neighbors[i]);
visited[tmp->neighbors[i]->label] = head->neighbors[i];
}
else
{
head->neighbors.push_back(visited[tmp->neighbors[i]->label]);
}
}
}
return visited[node->label];
}

用map记录已经出现过的节点。

C++要注意：vector不能通过下标增加原来没有的原素，map可以； new 和malloc一样返回指针

理论上应该是BFS比较快，因为没有递归调用，但是两个程序的验证时间DFS比较快，可能是程序还可以优化，也可能是因为使用queue？