Copy List with Random Pointer

https://leetcode.com/problems/copy-list-with-random-pointer/

A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.

Return a deep copy of the list.

解题思路：

啥叫deep copy，啥叫shallow copy？Java里shallow copy的意思是，B拷贝于A，但B和A指向同一个对象。deep copy的意思是，B和A指向不同的对象，但这两个对象完全一样。

具体可以参考 http://stackoverflow.com/questions/869033/how-do-i-copy-an-object-in-java

那么这道题目的难度就在于多了一个random指针。当前节点和next很容易复制，遍历一遍，不断根据原来链表的值去new新节点，并将next指向下一节点即可。问题是，第二遍的时候，如何找到当前节点的random节点？

这里借用的是HashMap这个数据结构，第一遍遍历的时候，建立一个map，key是原链表的节点，value是当前链表的节点。我们知道，实际上map里存的是相应的地址。这样，第二遍寻找新链表当前节点node的random时，只要在map里找原链表对应节点的value就可以了。

代码如下：

/**

 * Definition for singly-linked list with a random pointer.

 * class RandomListNode {

 *     int label;

 *     RandomListNode next, random;

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

 * };

 */

public class Solution {

    public RandomListNode copyRandomList(RandomListNode head) {

        if (head == null) {

            return head;

        }

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

        RandomListNode copyHead = new RandomListNode(head.label);

        RandomListNode head1 = head;

        RandomListNode returnHead = copyHead;

        

        map.put(head1, copyHead);

        while(head1.next != null) {

            copyHead.next = new RandomListNode(head1.next.label);

            map.put(head1.next, copyHead.next);

            copyHead = copyHead.next;

            head1 = head1.next;

        }

        

        copyHead = returnHead;

        head1 = head;

        while(copyHead != null) {

            copyHead.random = map.get(head1.random);

            copyHead = copyHead.next;

            head1 = head1.next;

        }

        return returnHead;

    }

}

上面的解法应该是比较容易理解的。Google到网友还有另一种比较好的解法，可以只花额外的O(1)空间，使用同样O(n)的时间。

这么做：

1. 在原来链表的每个节点后，插入一个一模一样的复制节点。这样copy的next顺序就自然出来了。比如1-1'-2-2'-3-3'

2. 将每个复制的节点的random指向它前一个节点的random的下一个节点

3. 按next的顺序抽出所有复制的节点，形成新的链表并返回。

代码如下

/**

 * Definition for singly-linked list with a random pointer.

 * class RandomListNode {

 *     int label;

 *     RandomListNode next, random;

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

 * };

 */

public class Solution {

    public RandomListNode copyRandomList(RandomListNode head) {

        if (head == null) {

            return head;

        }

        RandomListNode returnHead = head;

        //在原链表的每个节点后都插入一个新节点

        while(head != null) {

            RandomListNode newNode = new RandomListNode(head.label);

            newNode.next = head.next;

            head.next = newNode;

            head = head.next.next;

        }

        

        //将每个复制的节点的random指向它前一个节点的random的next

        head = returnHead;

        while(head != null) {

            if(head.random != null) {

                head.next.random = head.random.next;

            }

            head = head.next.next;

        }

        

        //抽出每个复制的节点，返回

        head = returnHead;

        returnHead = returnHead.next;

        while(head != null) {

            RandomListNode newNode = head.next;

            head.next = head.next.next;

            //这个边界条件一定要注意，否则原链表只有一个节点的时候会越界

            if(newNode.next != null) {

                newNode.next = newNode.next.next;

            }

            head = head.next;

        }

        return returnHead;

    }

}

可以看出，上面的思想，同样是要用某种方法在新复制的链表里找到每个节点的random节点，方法依然是要依赖于原链表。但是思路非常巧妙，值得体会。