牛客网 剑指Offer编程题------复杂链表的复制

题目描述：

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

题目链接

---

链表的节点声明：

public class RandomListNode {
    int label;
    RandomListNode next = null;
    RandomListNode random = null;

    RandomListNode(int label) {
        this.label = label;
    }
}

    这道题和普通的链表复制主要区别就是其中的 random 可能指向任何一个节点，可能是其前面或后面的，所以当你按顺序从头结点往后遍历复制时，有些节点是还没生成的，所以你一定要再遍历一遍链表才能确定好 random 节点，但这样的时间复杂度就是O(n^2)了，所以这里不做介绍。

   首先我想到的就是用 HashMap 来存放这些节点信息，用空间换时间，这样就可做到在O(n)的时间复杂度下完成 random 节点的赋予，代码如下：

import java.util.HashMap;
import java.util.Map;
public class Solution {
    public RandomListNode Clone(RandomListNode pHead)
    {
        //错误输入校验
        if (pHead == null) return null;

        Map<RandomListNode, RandomListNode> nodeMap = new HashMap<>();

        RandomListNode pTmp = pHead;

        RandomListNode resHead = null, preNode = null;

        while (pTmp != null) {
            RandomListNode copyNode = null;
            RandomListNode copySonNode = null;

            if (!nodeMap.containsKey(pTmp)) {         //还没有这个节点，得新建
                copyNode = new RandomListNode(pTmp.label);

                if (resHead == null) resHead = copyNode;    //复制后链表的头结点

                nodeMap.put(pTmp, copyNode);              //新建完放入nodeMap
            } else {
                copyNode = nodeMap.get(pTmp);
            }

            if (pTmp.random != null && !nodeMap.containsKey(pTmp.random)) {      //还没有这个子节点
                copySonNode = new RandomListNode(pTmp.random.label);
                nodeMap.put(pTmp.random, copySonNode);
            } else {
                copySonNode = nodeMap.get(pTmp.random);
            }
            copyNode.random = copySonNode;


            if (preNode != null) {                  //将链表连起来
                preNode.next = copyNode;
            }
            preNode = copyNode;
            pTmp = pTmp.next;
        }

        return resHead;
    }
}

    但其实还有一种更好的方法，在不浪费空间的情况下也能做到时间复杂度为O(n)的，这种复杂节点的复制难点主要就是在 random 节点的赋值，因为它们是随机不确定的，在我们按顺序生成时可能会在前面已复制生成的节点，也有可能是后面还没有复制到的节点，但是复制完后再弄 random 节点的话，对于每个 random 都要很浪费时间的遍历一次链表，但本来的链表就是有序的，所以我们可以利用这一点来弄：

    这样的话在我们设置 random 节点时，可以通过原本的链表的 next 获取到，时间复杂度也就变为 O(n)了。

    代码如下：

public RandomListNode Clone3(RandomListNode pHead) {
        //错误输入判断
        if (pHead == null) return null;

        RandomListNode pCurrent = pHead;

        //1.在每个节点后面复制一遍它的节点
        while (pCurrent != null) {
            RandomListNode pNext = pCurrent.next;
            pCurrent.next = new RandomListNode(pCurrent.label);
            pCurrent.next.next = pNext;
            pCurrent = pNext;
        }

        pCurrent = pHead;

        //2.设置节点的random指针
        while (pCurrent != null) {
            RandomListNode pCopyNode = pCurrent.next;
            pCopyNode.random = pCurrent.random == null ? null : pCurrent.random.next;
            pCurrent = pCurrent.next.next;
        }

        pCurrent = pHead;

        RandomListNode pCopyListHead = pHead.next;

        RandomListNode pCopyCurrent = pCopyListHead;

        //3.将两个链表分离开来
        while (pCurrent != null) {
            pCurrent.next = pCopyCurrent.next;
            pCurrent = pCurrent.next;
            pCopyCurrent.next = pCurrent == null ? null : pCurrent.next;
            pCopyCurrent = pCopyCurrent.next;
        }

        return pCopyListHead;

    }