[前端]_一起刷leetcode 138. 复制带随机指针的链表「这是我参与11月更文挑战的第5天，活动详情查看：202

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

题目

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]]

示例 4：

输入： head = []
输出： []
解释： 给定的链表为空（空指针），因此返回 null。

提示：

0 <= n <= 1000
-10000 <= Node.val <= 10000
Node.random 为空（null）或指向链表中的节点。

思路

先通过一轮循环，挨个节点创建，通过next链接，复制好一条普通链表result；
在上一步的同时，每个节点都存进map对象中，key是旧节点的值，value是新节点的值；
再通过一轮循环，设置每个节点的random即可。

实现

/**
 * // Definition for a Node.
 * function Node(val, next, random) {
 *    this.val = val;
 *    this.next = next;
 *    this.random = random;
 * };
 */

/**
 * @param {Node} head
 * @return {Node}
 */
var copyRandomList = function(head) {
    // 常规开局 -- 为了每次简化操作直接指向末尾
    let result = new Node(0, null, null);
    let prev = result;

    //  一轮遍历。创建起新旧节点的对应关系，同时复制好一条普通链表
    let map = new Map();
    // 让别人替跑，不然head到终点就回不来了，下一轮还需要它
    let temp = head;
    while (temp) {
        // 我们只需要新建一个普通节点
        let node = new Node(temp.val, null, null);
        prev.next = node;
        // 能通过旧节点找到新节点就行了
        map.set(temp, node);
        // 相当于for循环中的i++
        temp = temp.next;
        prev = prev.next;
    }

    // 把我们的代理叫回来再跑一遍
    prev = result.next;
    // 没有下一轮了，让head直接跑即可
    while (head) {
        // 替换每个节点中的random。根据我们刚刚建立好的新旧节点关系映射
        prev.random = map.get(head.random);
        head = head.next;
        prev = prev.next;
    }

    return result.next;
};

优化

上面那个方法用到map直接存储整个节点作为键值，节点的信息也比较多，这样子链表长度太大的话容易造成内存空间溢出，所以我们可以对上述方法做个优化，不用map存储了，直接操作原链表。

对原链表进行一轮遍历，在原本链表的每个节点后面都插入一个复制节点，我们叫跟屁虫；
对链表进行第二轮的遍历，把原本链表的random赋值给它的跟屁虫random2；
对链表进行第三轮遍历，把奇数位的原生节点都删掉，只留下偶数位的跟屁虫节点；
在上述操作过程中注意控制next的指向。

优化代码

/**
 * // Definition for a Node.
 * function Node(val, next, random) {
 *    this.val = val;
 *    this.next = next;
 *    this.random = random;
 * };
 */

/**
 * @param {Node} head
 * @return {Node}
 */
var copyRandomList = function(head) {
    // 老规矩，找个代跑的
    let temp = head;
    // 第一次遍历，分身术
    while (temp) {
        // 不想取变量可以不用这一步，这里是为了方便理解
        const next = temp.next;
        const copy = new Node(temp.val, null, null);
        // 跟屁虫开启抱大腿模式
        temp.next = copy;
        copy.next = next;
        temp = next;
    }

    // 工具人就位
    temp = head;
    // 第二次遍历， 把跟屁虫的random指向random的跟屁虫
    while (temp) {
        const copy = temp.next;
        // 如果当前节点没有random就不用折腾了
        if (temp.random) {
            // 建立跟屁虫与跟屁虫之间的关系
            copy.random = temp.random.next;
        }
        temp = copy.next;
    }

    // 第三次遍历，删除原生节点， 头节点的跟屁虫正式上位
    let result = new Node(0, null, null);
    // 工具人再次就位
    temp = head;
    prev = result;

    while (temp) {
        // 这道题不能改原参数，不然通不过测试用例
        // 要不然直接prev.next = prev.next.next;即可
        const copy = temp.next;
        temp.next = copy.next;
        prev.next =  copy;
        temp = temp.next;
        prev = prev.next;
    }

    return result.next;
};

看懂了的小伙伴可以点个关注、咱们下道题目见。如无意外以后文章都会以这种形式，有好的建议欢迎评论区留言。