54-Map和Set练习-LeetCode138复制带随机指针的链表

最新推荐文章于 2025-12-05 23:25:47 发布

原创最新推荐文章于 2025-12-05 23:25:47 发布 · 244 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #数据结构

Java数据结构专栏收录该内容

79 篇文章

订阅专栏

文章介绍了如何构建一个链表的深拷贝，特别是处理含有随机指针的情况。两种思路被提出：一是通过遍历计算原链表中random指针的偏移量，二是使用Map存储原链表和新链表节点的映射关系。最后给出了Java实现的代码示例。

题目

给你一个长度为 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
    -10^4 <= Node.val <= 10^4
    Node.random 为 null 或指向链表中的节点。

思路1

先不管random引用，遍历原链表，尾插新链表。
处理random，遍历原链表，计算原链表中每个节点random引用相对于第一个节点的偏移量（与左右方向无关）。
拿着每个节点的偏移量关系，就知道新的链表中random指向谁。

代码1

TODO

思路2

使用Map存储原链表节点和新链表节点的映射关系。

遍历旧链表节点的同时新建新节点，将值复制给新节点，建立原链表节点与新链表节点之间的映射关系：key = value：旧1 = 新1。
根据建立的映射关系，连接新链表的next和random指向：旧1 = 新1，旧2 = 新2，旧1.next = 旧2，新1.next = 新2 = 旧2 = 旧1.next，新1.random = 旧1.random。
返回新链表的头节点。

代码2

/*
// 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) {
        //1.边界条件的判断
        if(head == null) {
            return null;
        }
        
        //2.建立原链表节点和新链表节点之间的映射关系，key = value, 旧1 = 新1
        Map<Node, Node> nodeMap = new HashMap<>();
        //遍历原链表节点，新建链表节点，建立旧node = 新node的映射关系
        for (Node x = head; x != null; x = x.next) {
            //此时是x != null，而不是x.next != null
            //因为若x == null，则null.next会报错，且x.next就更没意义了，更不会存在，为null
            Node newX = new Node(x.val); //对于最上面的Node类
            nodeMap.put(x, newX);
        }
        
        //3.根据旧链表节点和新链表节点的映射关系，连接新链表的next和random指向
        for(Node x = head; x != null; x = x.next) {
            //旧1 = 新1
            //旧1.next = 旧2，新1.next = 新2
            //旧2 = 新2
            
            //取出新1
            Node newX = nodeMap.get(x);
            
            //取出新2
            Node newXNext = nodeMap.get(x.next);
            //连接新1.next = 新2
            newX.next = newXNext;
            
            //旧1.random = 新1.random
            Node newXRandom = nodeMap.get(x.random);
            newX.random = newXRandom;
        }
        
        //返回新链表头节点 旧head = 新head
        return nodeMap.get(head);
    }
}

优化：

/*
// 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) {
        //1.边界条件的判断
        if(head == null) {
            return null;
        }

        //2.建立原链表节点和新链表节点之间的映射关系，key = value, 旧1 = 新1
        Map<Node, Node> nodeMap = new HashMap<>();
        //遍历原链表节点，新建链表节点，建立旧node = 新node的映射关系
        for (Node x = head; x != null; x = x.next) {
            //此时是x != null，而不是x.next != null
            //因为若x == null，则null.next会报错，且x.next就更没意义了，更不会存在，为null
            Node newX = new Node(x.val); //对于最上面的Node类
            nodeMap.put(x, newX);
        }

        //3.根据旧链表节点和新链表节点的映射关系，连接新链表的next和random指向
        for(Node x = head; x != null; x = x.next) {
            nodeMap.get(x).next = nodeMap.get(x.next);
            nodeMap.get(x).random = nodeMap.get(x.random);
        }

        //返回新链表头节点 旧head = 新head
        return nodeMap.get(head);
    }
}