【leetcode】clone-graph

题目 ：

Clone an undirected graph. Each node in the graph contains alabeland a list of itsneighbors.

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 as0. Connect node0to both nodes1and2.
2. Second node is labeled as1. Connect node1to node2.
3. Third node is labeled as2. Connect node2to node2(itself), thus forming a self-cycle.

Visually, the graph looks like the following:

       1
      / \
     /   \
    0 --- 2
         / \
         \_/

问题分析：

上面的问题很明显的是一个图的问题  ；；

简单的来说的话，就是给定一张图，要我们来复制这张图 ；

要想来复制一张图 我们需要做到的是以下几点：

1、复制图的每一个将结点；

2、复制每一个结点之间的关系 ；

对于一张图的遍历，主要有两种方法：

1、深度优先遍历；

2、广度优先遍历；

代码实现：

1、广度优先遍历：

/**
 * Definition for undirected graph.
 * struct UndirectedGraphNode {
 *     int label;
 *     vector<UndirectedGraphNode *> neighbors;
 *     UndirectedGraphNode(int x) : label(x) {};
 * };
 */
#include<queue>
#include<unordered_set>
#include<unordered_map>
class Solution {
public:
    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
       if(node == NULL)
           return NULL;
        //用来保存当前的图的结点，来判断  当前的结点到底有没有遍历过
        unordered_set<UndirectedGraphNode*> datanode;
        //newnode用来保存的是新建立的结点
        unordered_map<int,UndirectedGraphNode*> newnode;
        //队列来保存的是 当前结点的邻接结点
        queue<UndirectedGraphNode*>  qn;
        qn.push(node);
        while(!qn.empty())
        {
            UndirectedGraphNode*  cur =  qn.front();
            //复制新的结点
            UndirectedGraphNode*  tmp = new UndirectedGraphNode(cur->label);
            //并将新复制的结点放到newnode
            newnode[cur->label] = tmp;
            datanode.insert(cur);
            int len = cur->neighbors.size();
            for(int i =0 ;i < len;++i)
            {
                //表示当前的结点还没有被遍历过 
                if(datanode.find(cur->neighbors[i]) == datanode.end())
                {
                    qn.push(cur->neighbors[i]);
                }
            }
            qn.pop();
        }
   		//接下来  开始对于新结点的  邻居赋值
        unordered_set<UndirectedGraphNode*>::iterator it = datanode.begin();
        while(it != datanode.end())
        {
            int len = (*it)->neighbors.size();
            for(int i =0 ;i < len;++i)
            {
                newnode[(*it)->label]->neighbors.push_back((*it)->neighbors[i]);
            }
            ++it;
        }
        return  newnode[node->label];  
    }
};

2、深度优先遍历：

/**
 * Definition for undirected graph.
 * struct UndirectedGraphNode {
 *     int label;
 *     vector<UndirectedGraphNode *> neighbors;
 *     UndirectedGraphNode(int x) : label(x) {};
 * };
 */
#include<stack>
#include<unordered_set>
#include<unordered_map>
class Solution {
public:
    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
       if(node == NULL)
           return NULL;
        //用来保存当前的图的结点，来判断  当前的结点到底有没有遍历过
        unordered_set<UndirectedGraphNode*> datanode;
        //newnode用来保存的是新建立的结点
        unordered_map<int,UndirectedGraphNode*> newnode;
        //队列来保存的是 当前结点的邻接结点
        stack<UndirectedGraphNode*>  qn;
        qn.push(node);
        while(!qn.empty())
        {
            UndirectedGraphNode*  cur =  qn.top();
            if(datanode.find(cur)== datanode.end())
            {
           	 	//复制新的结点
            	UndirectedGraphNode*  tmp = new UndirectedGraphNode(cur->label);
            	//并将新复制的结点放到newnode
            	newnode[cur->label] = tmp;
            	datanode.insert(cur);
            }
           	int len = cur->neighbors.size();
            int i =0;
            for( ;i < len;++i)
            {
                //表示当前的结点还没有被遍历过
                if(datanode.find(cur->neighbors[i]) == datanode.end())
                {
                   	 qn.push(cur->neighbors[i]);
                      break;
                }
            }
            if(i == len)
               qn.pop();
        }
   		//接下来  开始对于新结点的  邻居赋值
        unordered_set<UndirectedGraphNode*>::iterator it = datanode.begin();
        while(it != datanode.end())
        {
            int len = (*it)->neighbors.size();
            for(int i =0 ;i < len;++i)
            {
                newnode[(*it)->label]->neighbors.push_back((*it)->neighbors[i]);
            }
            ++it;
        }
        return  newnode[node->label];  
    }
};