**Leetcode_copy-list-with-random-pointer (c++ and python version)

地址：http://oj.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.

这是一道好题目，也是我被面过的一道题。

四个月前程老板用这道题面我的时候，我刚开始还是云里雾里，后来跟程老板交流了一下，磕磕碰碰用了三四个map搞出来，让自己多说两遍自己都会被自己绕晕。程老板说他用这道题面过很多人，其中不乏牛逼的人。

总之祝程老板创业成功。

这道题如果可以画一张图就能一目了然了。

在遍历原始链表的时候，创建一个新的链表，建立原始链表每一个结点与新建结点的关系（这里用了一个map）。这一次遍历解决了next指针。

接下来第二次遍历，某一个节点的random指针，比如p1的random指向px，px与copy链表里新创建的节点通过map找到的是px^, p1与copy里新创节点通过map找到的是p1^，那么p1^的random指向的就是px^。

第17行map插入的时候开始写的是dm.insert(make_pair<p, pnew>). 给报了两次compile error

后来改成了强制转化的形式，但是忘记了加pair。

这样三次compile error了后一次AC了，汗。这样的题应该多做，打上两颗*。

参考代码：

/**
 * Definition for singly-linked list with a random pointer.
 * struct RandomListNode {
 *     int label;
 *     RandomListNode *next, *random;
 *     RandomListNode(int x) : label(x), next(NULL), random(NULL) {}
 * };
 */
class Solution {
public:
    RandomListNode *copyRandomList(RandomListNode *head) {
        map<RandomListNode*, RandomListNode*> dm;
        RandomListNode* p = head, *lastp = NULL, *newhead = NULL;
        while(p)
        {
            RandomListNode* pnew = new RandomListNode(p->label);
            dm.insert(pair<RandomListNode*, RandomListNode*>(p, pnew));
            if(p!=head)
            {
                lastp->next=pnew;
                lastp = lastp->next;
            }
            else
            {
                newhead = lastp = pnew;
            }
            p = p->next;
        }
        p = head;
        while(p)
        {
            dm[p]->random = dm[p->random];
            p = p->next;
        }
        return newhead;
    }
};

 
 

  
  class 
  
  Solution 
  
  {
 
 
 
 

  
  public
  
  :
 
 
 
 

  
      
  
  RandomListNode 
  
  *
  
  copyRandomList
  
  (
  
  RandomListNode 
  
  *
  
  head
  
  ) 
  
  {
 
 
 
 

  
          
  
  if
  
  (
  
  !
  
  head
  
  )
 
 
 
 

  
              
  
  return 
  
  head
  
  ;
 
 
 
 

  
          
  
  unordered_map
  
  <
  
  RandomListNode
  
  *
  
  , 
  
  RandomListNode
  
  *>
  
  mp
  
  ;
 
 
 
 

  
          
  
  RandomListNode 
  
  *
  
  p 
  
  = 
  
  head
  
  , 
  
  *
  
  q 
  
  = 
  
  NULL
  
  , 
  
  *
  
  pre 
  
  = 
  
  NULL
  
  ;
 
 
 
 

  
          
  
  while
  
  (
  
  p
  
  )
 
 
 
 

  
          
  
  {
 
 
 
 

  
              
  
  q 
  
  = 
  
  new 
  
  RandomListNode
  
  (
  
  p
  
  ->
  
  label
  
  );
 
 
 
 

  
              
  
  mp
  
  [
  
  p
  
  ] 
  
  = 
  
  q
  
  ;
 
 
 
 

  
              
  
  p 
  
  = 
  
  p
  
  ->
  
  next
  
  ;
 
 
 
 

  
              
  
  if
  
  (
  
  pre
  
  )
 
 
 
 

  
                  
  
  pre
  
  ->
  
  next 
  
  = 
  
  q
  
  ;
 
 
 
 

  
              
  
  pre 
  
  = 
  
  q
  
  ;
 
 
 
 

  
          
  
  }
 
 
 
 

  
          
  
  p 
  
  = 
  
  head
  
  ;
 
 
 
 

  
          
  
  while
  
  (
  
  p
  
  )
 
 
 
 

  
          
  
  {
 
 
 
 

  
              
  
  mp
  
  [
  
  p
  
  ]
  
  ->
  
  random 
  
  = 
  
  mp
  
  [
  
  p
  
  ->
  
  random
  
  ];
 
 
 
 

  
              
  
  p 
  
  = 
  
  p
  
  ->
  
  next
  
  ;
 
 
 
 

  
          
  
  }
 
 
 
 

  
          
  
  return 
  
  mp
  
  [
  
  head
  
  ];
 
 
 
 

  
      
  
  }
 
 
 
 

  
  };
 
 

python:

 
 

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

  
  # class RandomListNode:
 
 
 
 

  
  #     def __init__(self, x):
 
 
 
 

  
  #         self.label = x
 
 
 
 

  
  #         self.next = None
 
 
 
 

  
  #         self.random = None
 
 
 
 

  
  

 
 
 
 

  
  class 
  
  Solution
  
  :
 
 
 
 

  
      
  
  # @param head, a RandomListNode
 
 
 
 

  
      
  
  # @return a RandomListNode
 
 
 
 

  
      
  
  def 
  
  copyRandomList
  
  (
  
  self
  
  , 
  
  head
  
  ):
 
 
 
 

  
          
  
  if 
  
  not 
  
  head
  
  :
 
 
 
 

  
              
  
  return 
  
  head
  
  ;
 
 
 
 

  
          
  
  mp 
  
  = 
  
  {}
 
 
 
 

  
          
  
  p 
  
  = 
  
  head
 
 
 
 

  
          
  
  pre 
  
  = 
  
  None
 
 
 
 

  
          
  
  while 
  
  p
  
  :
 
 
 
 

  
              
  
  q 
  
  = 
  
  RandomListNode
  
  (
  
  p
  
  .
  
  label
  
  )
 
 
 
 

  
              
  
  mp
  
  [
  
  p
  
  ] 
  
  = 
  
  q
 
 
 
 

  
              
  
  if 
  
  pre
  
  :
 
 
 
 

  
                  
  
  pre
  
  .
  
  next 
  
  = 
  
  q
 
 
 
 

  
              
  
  pre 
  
  = 
  
  q
 
 
 
 

  
              
  
  p 
  
  = 
  
  p
  
  .
  
  next
 
 
 
 

  
          
  
  p 
  
  = 
  
  head
 
 
 
 

  
          
  
  while 
  
  p
  
  :
 
 
 
 

  
              
  
  if 
  
  p
  
  .
  
  random
  
  :
 
 
 
 

  
                  
  
  mp
  
  [
  
  p
  
  ]
  
  .
  
  random 
  
  = 
  
  mp
  
  [
  
  p
  
  .
  
  random
  
  ]
 
 
 
 

  
              
  
  else
  
  :
 
 
 
 

  
                  
  
  mp
  
  [
  
  p
  
  ]
  
  .
  
  random 
  
  = 
  
  None
 
 
 
 

  
              
  
  p 
  
  = 
  
  p
  
  .
  
  next
 
 
 
 

  
          
  
  return 
  
  mp
  
  [
  
  head
  
  ]