LeetCode-克隆图

输入：adjList = [[2,4],[1,3],[2,4],[1,3]]
输出：[[2,4],[1,3],[2,4],[1,3]]
解释：
图中有 4 个节点。
节点 1 的值是 1，它有两个邻居：节点 2 和 4 。
节点 2 的值是 2，它有两个邻居：节点 1 和 3 。
节点 3 的值是 3，它有两个邻居：节点 2 和 4 。
节点 4 的值是 4，它有两个邻居：节点 1 和 3 。

DFS:

HashMap<Node,Node> visited = new HashMap<Node, Node>();

    public Node cloneGraph(Node node) {

        if (node == null){
            return null;
        }

        if (visited.containsKey(node)){
            return visited.get(node);
        }

        List<Node> neighbors = node.neighbors;
        int val = node.val;

        Node finalNode = new Node(val);
        visited.put(node,finalNode);
        for (int i = 0; i < neighbors.size(); i++){
            Node node1 = neighbors.get(i);
            Node node2 = cloneGraph(node1);
            finalNode.neighbors.add(node2);
        }

        return finalNode;

    }

BFS:

从队列首部取出一个节点。
遍历该节点的所有邻接点。
如果某个邻接点已被访问，则该邻接点一定在 visited 中，那么从 visited 获得该邻接点。
否则，创建一个新的节点存储在 visited 中。
将克隆的邻接点添加到克隆图对应节点的邻接表中。

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> neighbors;
    
    public Node() {
        val = 0;
        neighbors = new ArrayList<Node>();
    }
    
    public Node(int _val) {
        val = _val;
        neighbors = new ArrayList<Node>();
    }
    
    public Node(int _val, ArrayList<Node> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
}
*/

class Solution {


    public Node cloneGraph(Node node) {

       if (node == null) {
            return node;
        }

        // Hash map to save the visited node and it's respective clone
        // as key and value respectively. This helps to avoid cycles.
        HashMap<Node, Node> visited = new HashMap();

        // Put the first node in the queue
        LinkedList<Node> queue = new LinkedList<Node> ();
        queue.add(node);
        // Clone the node and put it in the visited dictionary.
        visited.put(node, new Node(node.val, new ArrayList()));

        // Start BFS traversal
        while (!queue.isEmpty()) {
            // Pop a node say "n" from the from the front of the queue.
            Node n = queue.remove();
            // Iterate through all the neighbors of the node "n"
            for (Node neighbor: n.neighbors) {
                if (!visited.containsKey(neighbor)) {
                    // Clone the neighbor and put in the visited, if not present already
                    visited.put(neighbor, new Node(neighbor.val, new ArrayList()));
                    // Add the newly encountered node to the queue.
                    queue.add(neighbor);
                }
                // Add the clone of the neighbor to the neighbors of the clone node "n".
                visited.get(n).neighbors.add(visited.get(neighbor));
            }
        }

        // Return the clone of the node from visited.
        return visited.get(node);

    }
}