leetcode133（克隆图：图的搜索）

题目：给你无向连通图中一个节点的引用，请你返回该图的深拷贝（克隆）。

又是一道图的搜索问题。。。。。

题解（一）BFS：

class Solution {
    
    
    /*
    * newGraph:BFS算法中的队列
    * newGraphNode:存储新结点
    * nodeSearch：记录该结点的状态（是否搜索过）
    */
    public Node cloneGraph(Node node) {
    
    
             if(node==null)
                return null;
            Queue<Node>newGraph=new LinkedList<>();
            HashMap<Integer,Node>newGraNode=new HashMap<>();
            HashSet<Node>nodeSearch=new HashSet<>();
            newGraph.offer(node);
            Node newHead=new Node(node.val);
            newGraNode.put(node.val,newHead);
            nodeSearch.add(node);
            while(!newGraph.isEmpty()){
    
    
                 Node peek= newGraph.poll();
                for(Node x:peek.neighbors){
    
    
                    if(!nodeSearch.contains(x)) {
    
    
                        nodeSearch.add(x);
                        newGraph.add(x);
                    }
                    if(!newGraNode.containsKey(x.val))
                        newGraNode.put(x.val,new Node(x.val));
                    newGraNode.get(peek.val).neighbors.add(newGraNode.get(x.val));
                }
            }
            return newHead;
    }
}

题解（二）DFS：

//递归
class Solution {
    
    
    HashSet<Node>Search=new HashSet<>();
    HashMap<Integer,Node>newNode=new HashMap<>();
    public Node cloneGraph(Node node) {
    
    
           if(node==null)
               return null;
           newNode.put(node.val,new Node(node.val));
           Search.add(node);
           DFS(node);
           return newNode.get(node.val);
    }
    private void DFS(Node node){
    
    

        for(Node x: node.neighbors){
    
    
            if(!newNode.containsKey(x.val))
                newNode.put(x.val,new Node(x.val));
                newNode.get(node.val).neighbors.add(newNode.get(x.val));
                if(!Search.contains(x)) {
    
    
                    Search.add(x);
                    DFS(x);
                }
        }
    }
}

//非递归
class Solution {
    
    

    public Node cloneGraph(Node node) {
    
    
        if(node==null)
             return null;
        /*
        * DFS:DFS算法中所用到的栈
        * Search:记录结点的状态（是否被搜索过）
        * Val_Node:通过val映射新结点
        * Node_Neighbor：通过新结点映射neighbors
        */
        Stack<Node>DFS=new Stack<>();
        HashSet<Node>Search=new HashSet<>();
        HashMap<Integer,Node>Val_Node=new HashMap<>();
        HashMap<Node,Integer>Node_Neighbor=new HashMap<>();

        DFS.push(node);
        Search.add(node);
        Val_Node.put(node.val,new Node(node.val));
        Node_Neighbor.put(Val_Node.get(node.val),0);
        while(!DFS.isEmpty()){
    
    
            Node peek= DFS.peek();
            Node newNode=Val_Node.get(peek.val);
            int neighbor=Node_Neighbor.get(newNode);
            Node_Neighbor.put(newNode,neighbor+1);
            if(neighbor>= peek.neighbors.size()){
    
    
                DFS.pop();
                continue;
            }
            if(!Val_Node.containsKey(peek.neighbors.get(neighbor).val)){
    
    
                int key=peek.neighbors.get(neighbor).val;
                Val_Node.put(key,new Node(key));
                Node_Neighbor.put(Val_Node.get(key),0);
            }
            if(!Search.contains(peek.neighbors.get(neighbor))){
    
    
                Search.add(peek.neighbors.get(neighbor));
                DFS.push(peek.neighbors.get(neighbor));
            }
            newNode.neighbors.add(Val_Node.get(peek.neighbors.get(neighbor).val));
        }
        return Val_Node.get(node.val);
    }

}