菜鸡的算法修炼——图（克隆图）

题目描述(引自LeetCode)

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

菜鸡与大佬的对话

菜鸡修炼坊

题目分析

一番修炼之后，菜鸡向题目发起了挑战，菜鸡发现，要想克隆一幅图，只要在遍历这幅图的过程中克隆每一个Node对象即可。根据修炼的内容，可以采用深度优先遍历(DFS)或者广度优先遍历(BFS)。菜鸡希望用两种方法来解决该题目。思路理顺之后，菜鸡决定使用Java代码实现自己的心路历程。

代码实现

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;
    }
}

// DFS
class Solution {
    private Map<Node, Node> record = new HashMap<>();
    public Node cloneGraph(Node node) {
        if (node == null) return node;
        if (record.containsKey(node)) return record.get(node);
        Node cloneNode = new Node(node.val, new ArrayList<Node>());
        record.put(node, cloneNode);
        node.neighbors.forEach(neighbor -> cloneNode.neighbors.add(cloneGraph(neighbor)));
        return cloneNode;
    }
}

// BFS
class Solution {
    public Node cloneGraph(Node node) {
        if (node == null) return node;
        Map<Node, Node> record = new HashMap<>();
        LinkedList<Node> queue = new LinkedList<>();
        queue.offer(node);
        record.put(node, new Node(node.val, new ArrayList<Node>()));
        while (!queue.isEmpty()) {
            Node tmp = queue.poll();
            tmp.neighbors.forEach(neighbor -> {
                if (!record.containsKey(neighbor)) {
                    record.put(neighbor, new Node(neighbor.val, new ArrayList<Node>()));
                    queue.offer(neighbor);
                }
                record.get(tmp).neighbors.add(record.get(neighbor));
            });
        }
        return record.get(node);
    }
}

经过此次修炼，菜鸡对图的基本概念有了一定的理解，经过对代码的一番分析，菜鸡发现，无论是DFS抑或是BFS，其时间复杂度与空间复杂度均为O(n)。菜鸡隐隐觉得，数据结构与算法的魅力就在于，千变万化之中似乎蕴含着某些恒久不变的东西，这便是求索的意义……