Clone Graph --- LeetCode

Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.

OJ's undirected graph serialization:

Nodes are labeled uniquely.

We use # as a separator for each node, and , as a separator for node label and each neighbor of the node.

As an example, consider the serialized graph {0,1,2#1,2#2,2}.

The graph has a total of three nodes, and therefore contains three parts as separated by #.

1. First node is labeled as 0. Connect node 0 to both nodes 1 and 2.
2. Second node is labeled as 1. Connect node 1 to node 2.
3. Third node is labeled as 2. Connect node 2 to node 2 (itself), thus forming a self-cycle.

解题思路：使用BSF遍历图，使用HashMap保存原节点->新节点的克隆，使用HashSet记录已经访问过的节点。

                队列中node节点poll,同时将node加入到set中记录已经visited。

               map中是否已经有node的克隆，若无则创建新节点cNode，有则取得该节点cNode。

               遍历node的neighbers并将neighbers创建或取得，克隆到cNode的neighbers中。

               同时neighbers若未访问过且队列中无，则入队列。

               循环遍历queue直至空。

/**
 * Definition for undirected graph.
 * class UndirectedGraphNode {
 *     int label;
 *     List<UndirectedGraphNode> neighbors;
 *     UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
 * };
 */
public class Solution {
    public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
           if(node==null){
          return null;
           }       
      Queue<UndirectedGraphNode> queue=new LinkedList<UndirectedGraphNode>();       
      queue.add(node);
      UndirectedGraphNode root=new UndirectedGraphNode(node.label);
      Set<UndirectedGraphNode> visited=new HashSet<UndirectedGraphNode>();
      Map<UndirectedGraphNode,UndirectedGraphNode> map=new            HashMap<UndirectedGraphNode,UndirectedGraphNode>();
      map.put(node, root);     
      while(!queue.isEmpty()){
      UndirectedGraphNode tmp=queue.poll();
      UndirectedGraphNode  cNode=map.get(tmp);
      visited.add(tmp);
      for(int i=0;i<tmp.neighbors.size();i++){
     UndirectedGraphNode neighber=tmp.neighbors.get(i);
     UndirectedGraphNode cNeighber=null;
     if(!map.containsKey(neighber)){
     cNeighber=new UndirectedGraphNode(neighber.label);
     map.put(neighber, cNeighber);
     }else{
     cNeighber=map.get(neighber);
     }      
     cNode.neighbors.add(cNeighber);
     if(!visited.contains(neighber)&&!queue.contains(neighber)){
     queue.add(neighber); 
     }
           
      }
            
      }      
           return root;
         
    }
}