数据结构习题--复制带随机指针的链表

数据结构习题–复制带随机指针的链表

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

力扣有链接：https://leetcode.cn/leetbook/read/linked-list/fdi26/

方法:(我的方法)(在原链表结点新建结点)

分析

代码里有分析，这里是大概思路
我们在进行拷贝的最大问题就是，我们是从头到尾是逐一拷贝的，但是原链表的结点的random指针是随机指向的，对于我们拷贝来说，它可能指向一个为创建的结点
解决:

1. 先完成值拷贝
2. 在进行值拷贝时，我们给原来链表的结点的random指向一个新结点，该结点的random是原结点的random指向，而next是指向我们拷贝的结点，这样可以通过原来链表的结点访问到我们拷贝的结点
3. 把原来链表的每个random结点复原

代码

package douobleneedle;

public class copyTheLinkListWithRandomNeedle {
// Definition for a Node.
static class Node {
    int val;
    Node next;
    Node random;

    public Node(int val) {
        this.val = val;
        this.next = null;
        this.random = null;
    }
}
            // 用来返回深拷贝的链表
        public Node copyRandomList(Node head) {
            Node copyHead = copyValAndLinkList(head);
            copyHead = copyRandomNeedle(copyHead,head);
            storeTheOrigin(head);
            return copyHead;
        }
        // 完成对原链表的val的拷贝，并且把原链表的结点的random更新，更新为一个新节点，来保存它原来指向的结点，和拷贝的和其等值的结点
        public Node copyValAndLinkList(Node head){
            // 用来存储拷贝的头结点
            Node saveCopyHead = null;
            // 完成拷贝链表的结点的遍历
            Node copyHead = null;
            // 完成原来链表的遍历
            Node temp = head;
            // 遍历原来链表
            while (temp != null){
                // 给拷贝链表的头一个结点单独处理(大概处理流程相同)
                if (copyHead == null){
                    copyHead = new Node(temp.val);
                    Node save = new Node(1);
                    save.random = temp.random;
                    save.next = copyHead;
                    temp.random = save;
                    saveCopyHead = copyHead;
                }else {
                    // 完成拷贝链表的每一个结点的值的拷贝，并且让原来链表的random指向一个新节点
                    // 这个新节点的random保存了原来链表的random，而next指向了拷贝了该结点的结点(copyHead)
                    // 为什么要新建这个结点？
                    // 因为原来的链表的结点的random指针可能指向其后面的结点，而我们在拷贝时，是逐一拷贝的，即
                    // 我们不能让其指向后面未创建的结点，所以我们创建这个新结点，它的random等于原来链表的结点的random
                    // 是为了维护以前的关系，而让其next指向当前拷贝的结点copyHead，这样把原来的链表和拷贝的链表暂时联系起来了
                    copyHead.next = new Node(temp.val);// 值拷贝
                    copyHead = copyHead.next;// 更新结点
                    // 更新原来链表结点的random指向
                    Node save = new Node(1);
                    save.random = temp.random;
                    save.next = copyHead;
                    temp.random = save;
                }
                // 循环遍量迭代
                temp = temp.next;
            }
            return saveCopyHead;
        }
        // 完成拷贝random(和原链表相同的random连接方式)
        public Node copyRandomNeedle(Node copyHead,Node head){
                // 用来完成对拷贝链表的遍历
                Node temp = copyHead;
                // 用来完成对原来链表的遍历
                Node headTail = head;
            while (headTail != null){
                // 如果原来链表的结点的random指针指向不为空
                if (headTail.random.random != null) {
                    // headTail.random 是我们在上面的方法更新的新建的结点
                    // headTail.random.random 是最开始的原来的链表的random的指向的结点
                    // headTail.random.random.random 是最开始的原来的链表的random的指向的结点,的我们创建的新节点
                    // headTail.random.random.random.next 是最开始的原来的链表的random的指向的结点,的我们创建的新节点的next，其保存的是和该结点对应拷贝结点
                    temp.random = headTail.random.random.random.next;
                }else {
                    // 为null的话，就让拷贝链表的结点的random为null
                    temp.random = null;
                }
                // 循环遍量的迭代
                temp = temp.next;
                headTail = headTail.next;
            }
            return copyHead;
        }
        // 把原来的链表的random复原
        public void storeTheOrigin(Node head){
            Node headTail = head;
            while (headTail != null){
                // 如果不为null，就让其random指向其random里存储的原来的random结点
                headTail.random = headTail.random.random;
                headTail = headTail.next;
            }
        }
}

方法：回溯+哈希

分析

本题要求我们对一个特殊的链表进行深拷贝。如果是普通链表，我们可以直接按照遍历的顺序创建链表节点。而本题中因为随机指针的存在，当我们拷贝节点时，「当前节点的随机指针指向的节点」可能还没创建，因此我们需要变换思路。一个可行方案是，我们利用回溯的方式，让每个节点的拷贝操作相互独立。对于当前节点，我们首先要进行拷贝，然后我们进行「当前节点的后继节点」和「当前节点的随机指针指向的节点」拷贝，拷贝完成后将创建的新节点的指针返回，即可完成当前节点的两指针的赋值。

具体地，我们用哈希表记录每一个节点对应新节点的创建情况。遍历该链表的过程中，我们检查「当前节点的后继节点」和「当前节点的随机指针指向的节点」的创建情况。如果这两个节点中的任何一个节点的新节点没有被创建，我们都立刻递归地进行创建。当我们拷贝完成，回溯到当前层时，我们即可完成当前节点的指针赋值。注意一个节点可能被多个其他节点指向，因此我们可能递归地多次尝试拷贝某个节点，为了防止重复拷贝，我们需要首先检查当前节点是否被拷贝过，如果已经拷贝过，我们可以直接从哈希表中取出拷贝后的节点的指针并返回即可。

在实际代码中，我们需要特别判断给定节点为空节点的情况。

总的流程就是通过把原来的结点作为key，我们拷贝的结点作为value，存入一个hash表中，然后对于next和random，如果我们需要连接，而不存在，就通过递归回溯来创建，创建完成后，再连接，对于random的创建，如果在hash表内，就不需要再创建，直接返回就行

代码

class Solution {
    Map<Node, Node> cachedNode = new HashMap<Node, Node>();

    public Node copyRandomList(Node head) {
        if (head == null) {
            return null;
        }
        if (!cachedNode.containsKey(head)) {
            Node headNew = new Node(head.val);
            cachedNode.put(head, headNew);
            headNew.next = copyRandomList(head.next);
            headNew.random = copyRandomList(head.random);
        }
        return cachedNode.get(head);
    }
}

复杂度

时间复杂度O(n),对于每个结点，我们至多访问其后继结点和其随机指针指向的结点，所以每个结点均摊至多访问两次
空间复杂度O(n),因为使用了hash，其存储大小，就是链表的大小

方法：迭代 + 结点拆分

分析

注意到方法一需要使用哈希表记录每一个节点对应新节点的创建情况，而我们可以使用一个小技巧来省去哈希表的空间。

我们首先将该链表中每一个节点拆分为两个相连的节点，例如对于链表
A→B→C，我们可以将其拆分为 A→A ′ →B→B ′ →C→C ′。对于任意一个原节点 S，其拷贝节点 𝑆′ 即为其后继节点。

这样，我们可以直接找到每一个拷贝节点 𝑆′ 的随机指针应当指向的节点，即为其原节点 S 的随机指针指向的节点 T 的后继节点 T ′。需要注意原节点的随机指针可能为空，我们需要特别判断这种情况。

当我们完成了拷贝节点的随机指针的赋值，我们只需要将这个链表按照原节点与拷贝节点的种类进行拆分即可，只需要遍历一次。同样需要注意最后一个拷贝节点的后继节点为空，我们需要特别判断这种情况。

代码

class Solution {
    public Node copyRandomList(Node head) {
        if (head == null) {
            return null;
        }
        // 相当于在原来的基础上进行插入
        for (Node node = head; node != null; node = node.next.next) {
            Node nodeNew = new Node(node.val);
            nodeNew.next = node.next;
            node.next = nodeNew;
        }
        // 因为我们创建的结点在原来结点之后，我们就可以先找到原来结点的random，再把其后一个结点赋给我们拷贝的结点
        for (Node node = head; node != null; node = node.next.next) {
            Node nodeNew = node.next;
            nodeNew.random = (node.random != null) ? node.random.next : null;
        }
        Node headNew = head.next;
        // 把结点拆分为两条链表
        for (Node node = head; node != null; node = node.next) {
            Node nodeNew = node.next;
            node.next = node.next.next;
            nodeNew.next = (nodeNew.next != null) ? nodeNew.next.next : null;
        }
        return headNew;
    }
}