133. 克隆图

https://leetcode.cn/problems/clone-graph/description/?envType=study-plan-v2&envId=top-interview-150思路：题目要求我们使用深拷贝，我们首先要知道深拷贝是什么。深拷贝就是再拷贝对象时开辟一块新的空间存放对象，两个对象不共享内存。这题就是让我们遍历所有节点再new新的出来。遍历的方式有很多我这里选择的是bfs。

class Solution {
    static 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;
        }
    }

    public Node cloneGraph(Node node) {
        if(node == null) return null;
        if(node.neighbors.isEmpty()) return new Node(1);
        // 创建一个队列用来存放节点
        Queue<Node> nodes = new LinkedList<>();
        nodes.add(node);
        Node newNode = new Node(node.val);
        // 创建一个list用来存放节点是否被访问过, 我们也可以通过val值来找到对应的node节点
        HashMap<Integer, Node> visited = new HashMap<>();
        visited.put(node.val, newNode);
        // 创建一个待复制的等待队列
        Queue<Node> queue = new LinkedList<>();
        queue.add(newNode);
        while(!nodes.isEmpty()) {
            Node cur = nodes.remove();
            Node curNew = queue.remove();
            for(Node neighbor : cur.neighbors) {
                if(!visited.containsKey(neighbor.val)) { // 保证每个节点只复制一次
                    Node newNeighbor = new Node(neighbor.val);
                    curNew.neighbors.add(newNeighbor);
                    nodes.add(neighbor);
                    queue.add(newNeighbor);
                    visited.put(neighbor.val, newNeighbor);
                } else {// 节点复制过了，我们去visited中找到对应的节点
                    curNew.neighbors.add(visited.get(neighbor.val));
                }
            }

        }

        check(node, newNode);
        return newNode;
    }

    /**
     * 检查两个图是否相同
     * @param node
     * @param newNode
     */
    private static void check(Node node, Node newNode) {
        ArrayList<Node> l1 = new ArrayList<>();
        ArrayList<Node> l2 = new ArrayList<>();
        HashSet<Node> set1 = new HashSet<>();
        HashSet<Node> set2 = new HashSet<>();
        l1.add(node);
        l2.add(newNode);
        set1.add(node);
        set2.add(newNode);
        while(!l1.isEmpty() && !l2.isEmpty()) {
            Node cur1 = l1.remove(0);
            Node cur2 = l2.remove(0);
            if(cur1.val == cur2.val && cur1 != cur2) {
                System.out.println("ture");
            }
            for(int i = 0; i < cur1.neighbors.size(); i++) {
                Node neighbor1 = cur1.neighbors.get(i);
                Node neighbor2 = cur2.neighbors.get(i);
                if(!set1.contains(neighbor1)) {
                    l1.add(neighbor1);
                    set1.add(neighbor1);
                }
                if (!set2.contains(neighbor2)) {
                    l2.add(neighbor2);
                    set2.add(neighbor2);
                }
            }

        }
    }

    public static void main(String[] args) {
        ArrayList<Node> list = new ArrayList<>();
        list.add(new Node(1));
        list.add(new Node(2));
        list.add(new Node(3));
        list.add(new Node(4));
        list.get(0).neighbors.add(list.get(1));
        list.get(0).neighbors.add(list.get(3));
        list.get(1).neighbors.add(list.get(0));
        list.get(1).neighbors.add(list.get(2));
        list.get(2).neighbors.add(list.get(1));
        list.get(2).neighbors.add(list.get(3));
        list.get(3).neighbors.add(list.get(0));
        list.get(3).neighbors.add(list.get(2));
        new Solution().cloneGraph(list.get(0));
    }
}