LeetCode.克隆图

深度优先之克隆图

原理理解

深度优先中有递归，再加上多了个 无向连通图，着实难以理解，整理思路如下。

    map<node,node> hashmap = new HashMap<>();//每次进入克隆函数先把要克隆的node放到hashmap中
        1.clone node_1: neighbors =	node_2	//未在hashmap中，clone node_2,进入2步骤
	                                node_4	//深度优先，所以node_2 执行完所有的层级后开始克隆node_4,发现已经在node_2的分支遍历中添加到hashmap中了，所以直接add(node_4)
		                            return node_1;//           至此结束深度拷贝

        2.clone node_2: neighbors =	node_1	//已经在hashmap中，直接add（node_1的引用）
	                                node_3	//未在hashmap中，clone node_3,进入3步骤
		                            return node_2//返回1步骤

        3.clone node_3: neighbors =	node_2	//同上，add(node_2的引用）
	                                node_4	//未添加到hashmap中，clone node_4，进入4步骤
		                            return node_3//返回2步骤

        4.clone node_4: neighbors =	node_1	//同上，add(node_1的引用)
	                                node_3	//同上，add(node_3的引用)
		                            return node_4//返回3步骤

具体代码实现

class Node {
    public int val;
    public List<Node> neighbors;

    public Node() {}

    @Override
    public String toString() {
        return "Node{" +
                "val=" + val +
                ", neighbors=" + neighbors +
                '}';
    }

    public Node(int _val, List<Node> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
};
public class CloneGraph {
    Map<Node,Node> map = new HashMap<>();


    public Node cloneGraph(Node node) {
        if(null == node)
            return node;
        map.put(node,new Node(node.val, new ArrayList<>()));
        for(Node n : node.neighbors)
        {
            if(map.containsKey(n))
            {
                map.get(node).neighbors.add(n);
            }
            else
            {
                map.get(node).neighbors.add(cloneGraph(n));
            }
        }
        return map.get(node);
    }
   
}