LeetCode-138. 复制带随机指针的链表

题目来源

138. 复制带随机指针的链表

题目详情

给你一个长度为 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]]

提示：

• 0 <= n <= 1000
• -104 <= Node.val <= 104
• Node.random 为 null 或指向链表中的节点。

题解分析

解法一：递归法

1. 本题一开始看没有特别清晰的思路，如果只有next指针那题目还简单，但是本题多了一个随机指针，那问题就变得复杂了，因为如果使用迭代法，有可能随机指针指向的节点还没有遍历到。
2. 考虑到使用迭代法无法拷贝还未遍历到的节点，所以这里可以借助递归的思想，递归拷贝next指针和random指针。
3. 此外，因为随机指针是随机指向任意节点的，为了防止出现递归过程中出现栈溢出以及重复遍历已经遍历的节点，这里还需要使用一个HashMap来存储对应节点的复制节点。

/*
// 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 {
    HashMap<Node, Node> map = new HashMap<>();
    public Node copyRandomList(Node head) {
        return copy(head);
    }

    private Node copy(Node now){
        if(now == null){
            return null;
        }
        // 已经访问过now节点了
        if(map.containsKey(now)){
            return map.get(now);
        }
        Node news = new Node(now.val);
        map.put(now, news);
        news.next = copy(now.next);
        news.random = copy(now.random);
        return news;
    }
}

解法二：迭代法

题目要求我们复制一个长度为 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 用来指向复制链表的头节点， 将两个链表拆分并复原原链表。

/*
// 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) {
        // 复制每个节点，包括next指针
        for(Node p = head; p != null; p=p.next.next){
            Node news = new Node(p.val);
            news.next = p.next;
            p.next = news;
        }

        // 复制random指针
        for(Node p = head; p != null; p=p.next.next){
            if(p.random != null){
                p.next.random = p.random.next;
            }
        }

        // 拆分链表
        Node dumy = new Node(-1), cur = dumy;
        for(Node p = head; p != null; p = p.next){// 这里的遍历方式与前两次的不同
            Node q = p.next;
            cur.next = q;
            cur = cur.next;
            p.next = q.next;
        }

        return dumy.next;
    }
}

解法三：迭代法-借助HashMap

1. 考虑到解法一中使用了一个HashMap来存储旧结点和新节点的对应关系，我们可以先遍历一次原链表，并将这种对应关系保存在map中。
2. 接着，我们继续遍历一次原链表，将旧结点的next和random节点各自对应的新节点也依次赋给新的节点，而怎么取到旧结点的next和random各自对应的新节点呢？这时候map的用处就凸显了，可以通过map获取到这种对应节点。

/*
// 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 {
    HashMap<Node, Node> map = new HashMap<>();
    public Node copyRandomList(Node head) {
        Node now = head;
        while(now != null){
            Node newNode = new Node(now.val);
            map.put(now, newNode);
            now = now.next;
        }
        now = head;
        while(now != null){
            map.get(now).next = map.get(now.next);
            map.get(now).random = map.get(now.random);
            now = now.next;
        }
        return map.get(head);
    }
}

结果展示