CloneGraph

Clone an undirected graph. Each node in the graph contains a label and a list of itsneighbors.


OJ's undirected graph serialization:

Nodes are labeled from 0 to N - 1, where N is the total nodes in the graph.

We use # as a separator for each node, and , as a separator for each neighbor of the node.

As an example, consider the serialized graph {1,2#2#2}.

The graph has a total of three nodes, and therefore contains three parts as separated by#.

  1. Connect node 0 to both nodes 1 and2.
  2. Connect node 1 to node 2.
  3. Connect node 2 to node 2 (itself), thus forming a self-cycle.

Visually, the graph looks like the following:

       1
      / \
     /   \
    0 --- 2
         / \
         \_/


BFS solution. 通过hashtable来记录是否已经创建clone node

/**
 * Definition for undirected graph.
 * class UndirectedGraphNode {
 *     int label;
 *     ArrayList<UndirectedGraphNode> neighbors;
 *     UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
 * };
 */
import java.util.Hashtable;
public class Solution {
	public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
		// Note: The Solution object is instantiated only once and is reused by
		// each test case.
		if (node == null)
			return null;
		Queue<UndirectedGraphNode> queue = new LinkedList<UndirectedGraphNode>();
		queue.add(node);
		Hashtable<UndirectedGraphNode, UndirectedGraphNode> hashtable = new Hashtable<UndirectedGraphNode, UndirectedGraphNode>();
		UndirectedGraphNode node_copy = new UndirectedGraphNode(node.label);
		hashtable.put(node, node_copy);
		while (!queue.isEmpty()) {
			UndirectedGraphNode cur = queue.poll();
			for (UndirectedGraphNode neighbor : cur.neighbors) {
				if (!hashtable.containsKey(neighbor)) {
					UndirectedGraphNode neighbor_copy = new UndirectedGraphNode(
							neighbor.label);
					hashtable.get(cur).neighbors.add(neighbor_copy);
					hashtable.put(neighbor, neighbor_copy);
					queue.add(neighbor);
				} else {
					hashtable.get(cur).neighbors.add(hashtable.get(neighbor));
				}
			}
		}
		return node_copy;
	}

}


<think>好的,我现在需要详细解释用户提供的C++代码片段,关于图的深拷贝,涉及unordered_map的用法、递归调用过程DFS的应用。首先,我得仔细看一下代码的结构各个部分的作用。 代码的结构看起来是一个Solution类中的cloneGraph方法。参数是一个Node指针,返回也是一个Node指针。Node结构体有int类型的val一个保存Node指针的邻居vector。这可能是一个图的节点结构,每个节点有一个值相邻节点的列表。 首先,cloneGraph方法内部定义了一个unordered_map<Node*, Node*> visited,这个映射应该用来记录原节点克隆节点的对应关系,避免重复克隆循环引用。然后调用clone函数,传入原始节点这个visited映射。 在clone函数里,首先检查原节点是否为空,如果是,返回nullptr。接着,查找原节点是否已经在visited中存在。如果存在,直接返回对应的克隆节点。这一步应该就是避免重复克隆,同时也处理循环引用的问题。 如果不存在于visited中,就创建一个新的克隆节点,其val与原节点相同,然后将这对原节点克隆节点存入visited中。这时候,克隆节点的neighbors数组还是空的,需要填充。 接下来遍历原节点的neighbors数组,对每个邻居节点递归调用clone函数,并将返回的克隆后的邻居节点加入到克隆节点的neighbors中。这里递归调用clone函数,相当于对图进行深度优先遍历,每访问一个节点就创建其克隆,并处理所有邻居。 整个递归过程应该就是以DFS的方式遍历整个图,每个节点只克隆一次,并且通过visited映射来维护原节点克隆节点的对应关系。这样就能实现深拷贝,确保所有节点都是新创建的,而不是共享原图的节点。 接下来,我需要确认涉及的知识点。首先是unordered_map的使用,这里用来存储原节点到克隆节点的映射,确保每个节点只克隆一次。unordered_map的查找插入操作都是平均O(1)时间复杂度,这有助于提高效率。然后是递归调用,这里递归地处理每个节点的邻居,直到所有节点都被克隆。递归的终止条件应该是当所有节点都被访问过,或者原节点为空的时候。 另外,这里使用的是深度优先搜索(DFS),因为每次克隆一个节点后,立即处理其邻居,递归深入下去,直到没有未访问的邻居为止。这符合DFS的特点,而如果是广度优先搜索(BFS),可能会使用队列来辅助遍历。 需要注意的是,图的深拷贝必须处理循环引用的情况,比如节点A的邻居是节点B,节点B的邻居又是节点A。使用visited映射可以避免无限递归,因为当再次遇到已经克隆过的节点时,直接从map中取出克隆节点,而不会再次创建。 可能的错误点:在递归调用clone之前,必须先将原节点克隆节点存入visited,否则在邻居处理时可能会重复创建。比如,如果先处理邻居再存入map,那么在处理后续邻居时,可能还没保存当前节点到map中,导致重复克隆。不过,在代码中,创建克隆节点后立即存入map,即使此时neighbors还没处理完,这样后续的递归调用遇到同一个原节点时,就能直接返回已有的克隆节点,避免重复。 此外,代码中克隆节点的neighbors是在递归调用之后填充的,这可能导致克隆节点的neighbors数组在递归返回时被正确构建。因为每次递归调用都会返回已经克隆好的节点,所以当处理当前节点的邻居时,邻居的克隆节点可能已经被创建并存入map中,或者会被递归创建。 总结来说,这段代码通过DFS递归遍历图的每个节点,使用unordered_map来记录已经克隆的节点,从而避免循环重复克隆,实现了图的深拷贝。涉及的知识点包括哈希表(unordered_map)的应用、递归函数的设计、以及深度优先搜索算法在处理图结构时的应用。</think>### 代码解释:图的深拷贝实现原理 #### 1. 核心数据结构与初始化 代码使用`unordered_map<Node*, Node*> visited`存储原始节点与克隆节点的映射关系。这种设计确保每个节点**仅被克隆一次**,同时解决图的**循环引用问题**。例如当节点A的邻居包含节点B,而节点B的邻居又包含节点A时,映射表能直接返回已创建的克隆节点[^1]。 #### 2. 递归克隆过程解析 ```cpp Node* clone(Node* node, unordered_map<Node*, Node*>& visited) { if (!node) return nullptr; if (visited.find(node) != visited.end()) return visited[node]; Node* newNode = new Node(node->val); visited[node] = newNode; // 先注册后填充邻居 for (Node* neighbor : node->neighbors) { newNode->neighbors.push_back(clone(neighbor, visited)); } return newNode; } ``` - **递归终止条件**:空节点直接返回`nullptr`,已克隆节点直接查表返回 - **深度优先特征**:优先创建当前节点副本,再递归处理所有邻居节点 - **防循环关键**:在填充邻居前先将新节点注册到映射表,防止重复创建 #### 3. 时间复杂度分析 设节点数为$N$,边数为$E$: - **时间复杂度**:$O(N+E)$,每个节点边仅被访问一次 - **空间复杂度**:$O(N)$,存储$N$个克隆节点递归栈深度 #### 4. 相关知识点关联 | 知识点 | 应用场景 | 代码体现位置 | |---------------------|-----------------------------------|---------------------------| | 哈希表(unordered_map) | 节点映射关系维护 | visited存储原始与克隆节点 | | 深度优先搜索(DFS) | 图的遍历顺序控制 | 递归克隆邻居节点 | | 递归算法 | 实现隐式栈的深度优先遍历 | clone函数自我调用结构 |
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值