LeetCode 138 复制带随机指针的链表【c++/j

发表于

「这是我参与11月更文挑战的第14天，活动详情查看：2021最后一次更文挑战」

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：

在这里插入图片描述

1
2
css复制代码输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2：

在这里插入图片描述

1
2
lua复制代码输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]

示例 3：

在这里插入图片描述

1
2
lua复制代码输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]

示例 4：

1
2
3
ini复制代码输入：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)，其中 nnn 是链表的长度。

空间复杂度分析： O(1)O(1)O(1)。

3、c++代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
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代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
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)，其中 nnn 是链表的长度 。
空间复杂度分析： O(n)O(n)O(n)，其中 nnn 是链表的长度 。

6、c++代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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. 复制带随机指针的链表
在这里插入图片描述

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%