137. 克隆图

137. 克隆图
 

克隆一张无向图. 无向图的每个节点包含一个 label 和一个列表 neighbors. 保证每个节点的 label 互不相同.

你的程序需要返回一个经过深度拷贝的新图. 新图和原图具有同样的结构, 并且对新图的任何改动不会对原图造成任何影响.
样例

样例1

输入:
{1,2,4#2,1,4#4,1,2}
输出:
{1,2,4#2,1,4#4,1,2}
解释:
1------2  
 \     |  
  \    |  
   \   |  
    \  |  
      4   

struct UndirectedGraphNode
{
     int label;
     vector<UndirectedGraphNode *> neighbors;
     UndirectedGraphNode(int x) : label(x) {};
 };

UndirectedGraphNode* cloneGraph(UndirectedGraphNode* node)
{
    if (node == nullptr)
    {
        return nullptr;
    }

    vector<UndirectedGraphNode*>newNodeVec;
    vector<UndirectedGraphNode*>visitedNodeVec;
    queue<UndirectedGraphNode*>queNodeQue;
    UndirectedGraphNode* head = new UndirectedGraphNode(node->label);
    newNodeVec.push_back(head);//存储新的
    queNodeQue.push(node);//存储原来的
    visitedNodeVec.push_back(node);

    while (true)
    {
        UndirectedGraphNode* tmpNode = nullptr;
        UndirectedGraphNode* newNode = nullptr;
        if (queNodeQue.empty())
            break;
        tmpNode = queNodeQue.front();
        queNodeQue.pop();//出队

        for (int i = 0; i < newNodeVec.size(); i++)
        {
            if (newNodeVec[i]->label == tmpNode->label)
            {
                newNode = newNodeVec[i];
                break;
            }
        }
        if (nullptr == newNode)
        {
            break;
        }

        for (int i = 0; i < tmpNode->neighbors.size(); i++)
        {
            UndirectedGraphNode*  neighNode = tmpNode->neighbors[i];    
            bool bFindVisited = false;
            for (int i = 0; i < visitedNodeVec.size(); i++)
            {
                if (visitedNodeVec[i]->label == neighNode->label)
                {
                    bFindVisited = true;
                    break;
                }
            }    
            if (false == bFindVisited)//没有访问过
            {
                visitedNodeVec.push_back(neighNode);
                queNodeQue.push(neighNode);    //存储节点的邻节点
                UndirectedGraphNode*tmp = new UndirectedGraphNode(neighNode->label); //创建新的节点
                newNodeVec.push_back(tmp);//存储新的
                newNode->neighbors.push_back(tmp);
            }
            else
            {
                UndirectedGraphNode*  findNode = nullptr;
                for (int i = 0; i < newNodeVec.size(); i++)
                {
                    if (newNodeVec[i]->label == neighNode->label)
                    {
                        findNode = newNodeVec[i];
                        break;
                    }
                }
                newNode->neighbors.push_back(findNode);
            }

            
    
    
    
        }
    }

    return head;
}

void test()
{
    //{1, 2, 4#2, 1, 4#4, 1, 2}

    UndirectedGraphNode *node1 = new UndirectedGraphNode(1);
    UndirectedGraphNode *node2 = new UndirectedGraphNode(2);
    UndirectedGraphNode *node3 = new UndirectedGraphNode(4);
    node1->neighbors.push_back(node2);
    node1->neighbors.push_back(node3);

    node2->neighbors.push_back(node1);
    node2->neighbors.push_back(node3);

    node3->neighbors.push_back(node2);
    node3->neighbors.push_back(node1);

    UndirectedGraphNode* ret = cloneGraph(node1);
}

int main()
{
    test();
    getchar();
    return 0;
}