My code:

/**
 * 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 null;
        HashMap<RandomListNode, RandomListNode> tracker = new HashMap<RandomListNode, RandomListNode>();
        RandomListNode newHead = new RandomListNode(head.label);
        tracker.put(head, newHead);
        RandomListNode next = head.next;
        RandomListNode newNext = newHead;
        /** copy the whole linked list with next pointer */
        while (next != null) {
            newNext.next = new RandomListNode(next.label);
            newNext = newNext.next;
            tracker.put(next, newNext);
            next = next.next;
        }
        next = head;
        newNext = newHead;
        while (next != null) {
            newNext.random = tracker.get(next.random);
            next = next.next;
            newNext = newNext.next;
        }
        return newHead;
    }
}

最近比較忙。之前寫的題目一直沒有更新。現在正好有點時間，更新一下。
這道題木之前聽學長說過，他在面試微軟的時候被問到了。
我寫了下，其實不是很難。
最主要的問題是想清楚怎么copy 一個 linked list.
就是做一個新的指針，不斷地申請新的內存，value就是對應的原結點的value。
然后留一個指針指向前面的結點，然后不斷更新next。
這個是大多數人可以做到的。
那么，那個隨機指針，random， 怎么辦？
那就是在復制這個鏈表的時候，把原結點和現結點放進HashMap中。
key: origin pointer -> value: new created pointer
然后根據原指針的random指向的原鏈表的結點，找到現鏈表對應的該結點，更新 現random。
That's it.

又是好多天沒刷題了。
沒想到現在在國內了。刷題還是挺爽的，尤其在學校機房。可惜一直沒有大規模得刷題。
今年跨年。。。然后和女朋友在一塊兒，還得和她爸媽吃飯，就馬上。
人生真是有趣。

Anyway, Good luck, Richardo!

這道題目又是有三種做法。
我自己寫了兩種，第三種感覺很直接簡潔，看答案的。

iteration:
My code:

/**
 * 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 {
    HashMap<RandomListNode, RandomListNode> map = new HashMap<>();
    public RandomListNode copyRandomList(RandomListNode head) {
        if (head == null) {
            return null;
        }
        
        RandomListNode dummy = new RandomListNode(-1);
        RandomListNode dummym = new RandomListNode(-1);
        dummy.next = head;
        
        RandomListNode curr = dummy;
        RandomListNode currm = dummym;
        
        while (curr.next != null) {
            RandomListNode next = curr.next;
            RandomListNode nextm = null;
            if (map.containsKey(next)) {
                nextm = map.get(next);
            }
            else {
                nextm = clone(next);
                map.put(next, nextm);
            }
            
            if (next.random != null) {
                RandomListNode randomm = null;
                if (map.containsKey(next.random)) {
                    randomm = map.get(next.random);
                }
                else {
                    randomm = clone(next.random);
                    map.put(next.random, randomm);
                }
                nextm.random = randomm;
            }
            
            currm.next = nextm;
            currm = nextm;
            curr = curr.next;
        }
        
        return dummym.next;
    }
    
    private RandomListNode clone(RandomListNode node) {
        return new RandomListNode(node.label);
    }
}

AC,
思路也沒什么好說的。
這其實就是 clone graph, 所以一般都需要 一個 hashmap，避免重復拷貝。

recursion:
My code:

/**
 * 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 {
    HashMap<RandomListNode, RandomListNode> map = new HashMap<>();
    public RandomListNode copyRandomList(RandomListNode head) {
        if (head == null) {
            return null;
        }
        
        RandomListNode headm = null;
        if (map.containsKey(head)) {
            headm = map.get(head);
        }
        else {
            headm = clone(head);
            map.put(head, headm);
        }
        
        if (head.random != null) {
            RandomListNode random = null;
            if (map.containsKey(head.random)) {
                random = map.get(head.random);
            }
            else {
                random = clone(head.random);
                map.put(head.random, random);
            }
            headm.random = random;
        }
        
        headm.next = copyRandomList(head.next);
        return headm;
    }
    
    private RandomListNode clone(RandomListNode node) {
        return new RandomListNode(node.label);
    }
}

這個的話過不了。
stack over flow

的確，當輸入的鏈表很大的時候，就爆棧了。
所以 reverse linked list 的時候，用iteration做更好。

第三種方法，先把所有的結點拷貝下，放進map中，不考慮連接問題。
然后當所有拷貝結點也都生成好了，開始重新遍歷hashtable，把他們連接起來，很簡潔，很直接。

My code:

/**
 * 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 {
    HashMap<RandomListNode, RandomListNode> map = new HashMap<>();
    public RandomListNode copyRandomList(RandomListNode head) {
        if (head == null) {
            return null;
        }
        
        RandomListNode curr = head;
        while (curr != null) {
            map.put(curr, clone(curr));
            curr = curr.next;
        }
        
        for (Map.Entry<RandomListNode, RandomListNode> entry : map.entrySet()) {
            RandomListNode newNode = entry.getValue();
            newNode.next = map.get(entry.getKey().next);
            newNode.random = map.get(entry.getKey().random);
        }
        
        return map.get(head);
    }
    
    private RandomListNode clone(RandomListNode node) {
        return new RandomListNode(node.label);
    }
}

reference:
https://discuss.leetcode.com/topic/29358/very-short-java-solution-with-map

Anyway, Good luck, Richardo! -- 09/09/2016