复杂链表的复制

题目如下:

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

两种方法，在代码中已标识清楚，在牛客网上均通过

关于第一种方法详细请看https://blog.csdn.net/wszy1301/article/details/80910626#5%E3%80%81%E5%A4%8D%E6%9D%82%E9%93%BE%E8%A1%A8%E7%9A%84%E5%A4%8D%E5%88%B6

关于第二种方法详细请看:https://www.cnblogs.com/edisonchou/p/4790090.html

/**
 * @ClassName:Num25
 * @Description:输入一个复杂链表 。
 * （每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点）
 * 返回结果为复制后复杂链表的head。
 * （注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
 * @Author songwenjing6
 * @Date 2019/7/18
 **/
public class Num25 {
    /**
     * 两种方法，实现时间复杂度和空间复杂度均为o(n)
     * 第一种借助HashMap,
     * 第二种，链表先复制，然后连接，然后拆分
     *
     * @return
     */
    public static void main(String[] args) {
        RandomListNode randomListNode1 = new RandomListNode(1);
        RandomListNode randomListNode2 = new RandomListNode(2);
        RandomListNode randomListNode3 = new RandomListNode(3);
        RandomListNode randomListNode4 = new RandomListNode(4);
        RandomListNode randomListNode5 = new RandomListNode(5);
        RandomListNode randomListNode6 = new RandomListNode(3);
        randomListNode1.next = randomListNode2;
        randomListNode2.next = randomListNode3;
        randomListNode3.next = randomListNode4;
        randomListNode4.next = randomListNode5;
        randomListNode5.next = randomListNode6;
        randomListNode6 = null;
        print(Clone(randomListNode1));
    }

    public static RandomListNode Clone0(RandomListNode pHead) {
        HashMap<RandomListNode, RandomListNode> hashMap = new HashMap<>();

        for (RandomListNode p = pHead; p != null; p = p.next) {
            hashMap.put(p, new RandomListNode(p.label));
        }
        for (RandomListNode p = pHead; p != null; p = p.next) {
            hashMap.get(p).next = hashMap.get(p.next);
            hashMap.get(p).random = hashMap.get(p.random);
        }
        return hashMap.get(pHead);
    }

    public static RandomListNode Clone(RandomListNode pHead) {
        if (pHead == null) {
            return null;
        }
        for (RandomListNode p = pHead; p != null; p = p.next.next) {
            RandomListNode randomListNode = new RandomListNode(p.label);
            randomListNode.next = p.next;
            p.next = randomListNode;
        }
        for (RandomListNode p = pHead; p != null; p = p.next.next) {
            if (p.random != null) {
                p.next.random = p.random.next;
            } else {
                p.next.random = null;
            }
        }

        //拆分链表
        RandomListNode p = pHead, q = pHead.next, result = pHead.next;
        for (; p.next != null && q.next != null; p = p.next, q = q.next) {
            p.next = p.next.next;
            q.next = q.next.next;
        }
        p.next = null;
        return result;
    }

    public static void print(RandomListNode pHead) {
        for (RandomListNode p = pHead; p != null; p = p.next) {
            System.out.println(p.label);
        }
    }


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

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

对比，第一种方法，借助了o(n)的空间，两种方法的时间复杂度都是o(n)