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？