LeetCode 138. 复制带随机指针的链表c++/java详细题解
Posted 林深时不见鹿
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了LeetCode 138. 复制带随机指针的链表c++/java详细题解相关的知识,希望对你有一定的参考价值。
1、题目
给你一个长度为n
的链表,每个节点包含一个额外增加的随机指针 random
,该指针可以指向链表中的任何节点或空节点。
构造这个链表的 深拷贝。 深拷贝应该正好由 n
个 全新 节点组成,其中每个新节点的值都设为其对应的原节点的值。新节点的 next
指针和 random
指针也都应指向复制链表中的新节点,并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。
例如,如果原链表中有 X
和 Y
两个节点,其中 X.random --> Y
。那么在复制链表中对应的两个节点x
和y
,同样有x.random --> y
。
返回复制链表的头节点。
用一个由 n
个节点组成的链表来表示输入/输出中的链表。每个节点用一个[val, random_index]
表示:
val
:一个表示Node.val
的整数。random_index
:随机指针指向的节点索引(范围从0
到n-1
);如果不指向任何节点,则为null
。
你的代码 只 接受原链表的头节点 head
作为传入参数。
示例 1:
输入:head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出:[[7,null],[13,0],[11,4],[10,2],[1,0]]
示例 2:
输入:head = [[1,1],[2,1]]
输出:[[1,1],[2,1]]
示例 3:
输入:head = [[3,null],[3,0],[3,null]]
输出:[[3,null],[3,0],[3,null]]
示例 4:
输入:head = []
输出:[]
解释:给定的链表为空(空指针),因此返回 null。
2、思路(1)
(迭代) O ( n ) O(n) O(n)
题目要求我们复制一个长度为n
的链表,该链表除了每个节点有一个指针指向下一个节点外,还有一个额外的指针指向链表中的任意节点或者null
,如下图所示:
如何去复制一个带随机指针的链表?
首先我们可以忽略random
指针,然后对原链表的每个节点进行复制,并追加到原节点的后面,而后复制random
指针。最后我们把原链表和复制链表拆分出来,并将原链表复原。
图示过程如下:
1、在每个节点的后面加上它的复制,并将原链表和复制链表连在一起。
2、 从前往后遍历每一个原链表节点,对于有random
指针的节点p
,我们让它的p->next->random = p->random->next
,这样我们就完成了对原链表random
指针的复刻。
3、最后我们把原链表和复制链表拆分出来,并将原链表复原。
具体过程如下:
- 1、定义一个
p
指针,遍历整个链表,复制每个节点,并将原链表和复制链表连在一起。 - 2、再次遍历整个链表,执行
p->next->random = p->random->next
,复制random
指针。 - 3、定义虚拟头节点
dummy
用来指向复制链表的头节点, 将两个链表拆分并复原原链表。
时间复杂度分析: O ( n ) O(n) O(n),其中 n n n 是链表的长度。
空间复杂度分析: O ( 1 ) O(1) O(1)。
3、c++代码
/*
// Definition for a Node.
class Node {
public:
int val;
Node* next;
Node* random;
Node(int _val) {
val = _val;
next = NULL;
random = NULL;
}
};
*/
class Solution {
public:
Node* copyRandomList(Node* head) {
for(auto p = head; p; p = p->next->next) //复制每个节点,并将原链表和复制链表连在一起。
{
auto q = new Node(p->val);
q->next = p->next;
p->next = q;
}
for(auto p = head; p; p = p->next->next) //复制random指针
{
if(p->random)
p->next->random = p->random->next;
}
//拆分两个链表,并复原原链表
auto dummy = new Node(-1), cur = dummy;
for(auto p = head; p; p = p->next)
{
auto q = p->next;
cur = cur->next = q;
p->next = q->next;
}
return dummy->next;
}
};
4、java代码
/*
// Definition for a Node.
class Node {
int val;
Node next;
Node random;
public Node(int val) {
this.val = val;
this.next = null;
this.random = null;
}
}
*/
class Solution {
public Node copyRandomList(Node head) {
for(Node p = head; p != null; p = p.next.next) //复制每个节点,并将原链表和复制链表连在一起。
{
Node q = new Node(p.val);
q.next = p.next;
p.next = q;
}
for(Node p = head; p != null; p = p.next.next) //复制random指针
{
if(p.random != null)
p.next.random = p.random.next;
}
//拆分两个链表,并复原原链表
Node dummy = new Node(-1), cur = dummy;
for(Node p = head; p != null; p = p.next)
{
Node q = p.next;
cur = cur.next = q;
p.next = q.next;
}
return dummy.next;
}
}
5、思路(2)
(哈希,回溯) O ( n ) O(n) O(n)
使用回溯的方式遍历整个链表,让每个节点的复制相互独立。对于当前节点node
,首先复制当前节点node
,而后对当前节点的后继节点和随机指针指向的节点进行复制,最后让复制节点的next
指针和random
指针指向这两个复制的节点,即可完成边的复制。
为了防止多次遍历同一个节点,我们需要建立一个哈希表, 来记录源节点到克隆节点之间的映射关系。在回溯搜索过程中,如果当前正在搜索的节点出现在了哈希表中,就说明我们已经遍历完了整个链表,此时就可以直接从哈希表中取出复制后的节点的指针并返回。
具体过程如下:
- 1、从
head
节点开始dfs
遍历整个图。 - 2、复制当前节点
node
,并使用哈希表hash
存贮源节点到复制节点之间的映射。 - 3、递归调用当前节点
node
的后继节点和随机指针指向的节点,并进行复制,然后让复制节点的next
指针和random
指针指向这两个复制的节点。 - 4、最后返回已经被访问过的节点的复制节点。
时间复杂度分析:
O
(
n
)
O(n)
O(n),其中
n
n
n 是链表的长度 。
空间复杂度分析:
O
(
n
)
O(n)
O(n),其中
n
n
n 是链表的长度 。
6、c++代码
class Solution {
public:
unordered_map<Node*, Node*> hash;
Node* copyRandomList(Node* head)
{
if (head == NULL) return NULL;
return dfs(head);
}
Node* dfs(Node* node)
{
if(node == NULL) return NULL;
//node节点已经被访问过了,直接从哈希表hash中取出对应的克隆节点返回。
if(hash.count(node)) return hash[node];
Node* clone = new Node(node->val); //复制节点
hash[node] = clone; //建立源节点到复制节点的映射
clone->next = dfs(node->next); //复制边
clone->random = dfs(node->random);
return clone;
}
};
7、java代码
/*
// Definition for a Node.
class Node {
int val;
Node next;
Node random;
public Node(int val) {
this.val = val;
this.next = null;
this.random = null;
}
}
*/
class Solution {
Map<Node,Node> hash = new HashMap<>();
public Node copyRandomList(Node head) {
if(head == null) return null;
return dfs(head);
}
Node dfs(Node node)
{
if(node == null) return null;
//node节点已经被访问过了,直接从哈希表hash中取出对应的复制节点返回。
if(hash.containsKey(node)) return hash.get(node);
Node clone = new Node(node.val); //复制节点
hash.put(node,clone); //建立源节点到复制节点的映射
clone.next = dfs(node.next); //复制边
clone.random = dfs(node.random);
return clone;
}
}
原题链接: 138. 复制带随机指针的链表
以上是关于LeetCode 138. 复制带随机指针的链表c++/java详细题解的主要内容,如果未能解决你的问题,请参考以下文章
LeetCode Algorithm 138. 复制带随机指针的链表