2025年- G32-Lc106-133. 克隆图--java版（很抽象，没有很能理解）

1.题目描述

2.思路
思路一：

方法 1：BFS（广度优先搜索 + 队列）

方法 2：DFS（深度优先搜索 + 递归）



例子2：




例子3：

3.代码实现
方法一：深度优先队列+递归

class Solution {

        private Map<Node, Node> m = new HashMap<>();//用于存储节点到克隆节点的映射，避免重复创建节点

        public Node cloneGraph(Node node) 
        {
            if (node == null)
                return null;
            if (m.containsKey(node))
                return m.get(node);//如果已经克隆，则返回该点
            //克隆当前节点
            Node clone = new Node(node.val, new ArrayList<>());
            m.put(node, clone);

            //递归克隆所有邻居
            for (Node neighbor : node.neighbors) {
                clone.neighbors.add(cloneGraph(neighbor));
            }
            return clone;

        }
}

方法二：深度优先队列+递归（带测试方法）

import java.util.*;

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 Solution10 {


        private Map<Node, Node> m = new HashMap<>();//用于存储节点到克隆节点的映射，避免重复创建节点

        public Node cloneGraph(Node node) {
            if (node == null)
                return null;
            if (m.containsKey(node))
                return m.get(node);//如果已经克隆，则返回该点
            //克隆当前节点
            Node clone = new Node(node.val, new ArrayList<>());
            m.put(node, clone);

            //递归克隆所有邻居
            for (Node neighbor : node.neighbors) {
                clone.neighbors.add(cloneGraph(neighbor));
            }
            return clone;

        }

        // 测试方法
        public static void main(String[] args) {
            // 创建测试图
            Node node1 = new Node(1);
            Node node2 = new Node(2);
            Node node3 = new Node(3);
            Node node4 = new Node(4);

            node1.neighbors.add(node2);
            node1.neighbors.add(node3);
            node2.neighbors.add(node1);
            node2.neighbors.add(node4);
            node3.neighbors.add(node1);
            node3.neighbors.add(node4);
            node4.neighbors.add(node2);
            node4.neighbors.add(node3);

            Solution10 solution = new Solution10();
            Node clonedGraph = solution.cloneGraph(node1);

            // 打印克隆结果
            System.out.println("克隆图的邻接表:");
            printGraph(clonedGraph, new HashSet<>());
        }

        // 辅助方法：打印图的邻接表
        private static void printGraph(Node node, Set<Integer> visited) {
            if (node == null || visited.contains(node.val)) return;
            visited.add(node.val);
            System.out.print("Node " + node.val + ": [");
            for (Node neighbor : node.neighbors) {
                System.out.print(neighbor.val + " ");
            }
            System.out.println("]");
            for (Node neighbor : node.neighbors) {
                printGraph(neighbor, visited);
            }
        }

    }

方法三：广度优先遍历+队列

import java.util.*;

class Solution {
    public Node cloneGraph(Node node) {
        if (node == null) return null;

        Map<Node, Node> map = new HashMap<>();
        Queue<Node> queue = new LinkedList<>();

        // 克隆起始节点并入队
        Node clone = new Node(node.val, new ArrayList<>());
        map.put(node, clone);
        queue.offer(node);

        while (!queue.isEmpty()) {
            Node cur = queue.poll();  // 取出队首节点

            for (Node neighbor : cur.neighbors) {
                if (!map.containsKey(neighbor)) { // 还未克隆
                    map.put(neighbor, new Node(neighbor.val, new ArrayList<>()));
                    queue.offer(neighbor);
                }
                // 连接克隆的邻居
                map.get(cur).neighbors.add(map.get(neighbor));
            }
        }
        return clone;
    }
}