题目描述（中等难度）

138. Copy List with Random Pointer - 图1

给一个链表，返回复制后的链表。链表节点相对于普通的多了一个 random 指针，会随机指向链表内的任意节点或者指向 null。

思路分析

这道题其实和 133 题 复制一个图很类似，这里的话就是要解决的问题就是，当更新当前节点的 random 指针的时候，如果 random 指向的是很后边的节点，但此时后边的节点还没有生成，那么我们该如何处理。

和 133 题 一样，我们可以利用 HashMap 将节点提前生成并且保存起来，第二次遍历到他的时候直接从 HashMap 里边拿即可。

这里的话就有两种思路，一种需要遍历两边链表，一种只需要遍历一遍。

2020.3.3 更新，leetcode 增加了样例，之前没有重复的数字所以 key 存的 val ，现在有了重复数字，将 key 修改为 Node。此外 Node 的无参的构造函数也被去掉了，也需要修改。

解法一

首先利用 HashMap 来一个不用思考的代码。

遍历第一遍链表，我们不考虑链表之间的相互关系，仅仅生成所有节点，然后把它存到 HashMap 中，val 作为 key，Node 作为 value。

遍历第二遍链表，将之前生成的节点取出来，更新它们的 next 和 random 指针。

  1. public Node copyRandomList(Node head) {
  2.     if (head == null) {
  3.         return null;
  4.     }
  5.     HashMap<Node, Node> map = new HashMap<>();
  6.     Node h = head;
  7.     while (h != null) {
  8.         Node t = new Node(h.val); 
  9.         map.put(h, t);
  10.         h = h.next;
  11.     }
  12.     h = head;
  13.     while (h != null) {
  14.         if (h.next != null) {
  15.             map.get(h).next = map.get(h.next);
  16.         }
  17.         if (h.random != null) {
  18.             map.get(h).random = map.get(h.random);
  19.         }
  20.         h = h.next;
  21.     }
  22.     return map.get(head);
  23. }

解法二

解法一虽然简单易懂，但还是有可以优化的地方的。我们可以只遍历一次链表。

核心思想就是延迟更新它的 next。

  1. 1 -> 2 -> 3
  3. 用 cur 指向已经生成的节点的末尾
  4. 1 -> 2   
  5.      ^
  6.      c
  8. 然后将 3 构造完成
  10. 最后将 2 的 next 指向 3
  11. 1 -> 2 -> 3  
  12.      ^
  13.      c
  15. 期间已经生成的节点存到 HashMap 中，第二次遇到的时候直接从 HashMap 中拿

看下代码理解一下含义吧

  1. public Node copyRandomList(Node head) {
  2.     if (head == null) {
  3.         return null;
  4.     }
  5.     HashMap<Node, Node> map = new HashMap<>();
  6.     Node h = head;
  7.     Node cur = new Node(-1); //空结点，dummy 节点，为了方便头结点计算
  8.     while (h != null) {
  9.         //判断当前节点是否已经产生过
  10.         if (!map.containsKey(h)) {
  11.             Node t = new Node(h.val);
  12.             map.put(h, t);
  13.         }
  14.         //得到当前节点去更新它的 random 指针
  15.         Node next = map.get(h);
  16.         if (h.random != null) {
  17.             //判断当前节点是否已经产生过
  18.             if (!map.containsKey(h.random)) {
  19.                 next.random = new Node(h.random.val);
  20.                 map.put(h.random, next.random);
  21.             } else {
  22.                 next.random = map.get(h.random);
  23.             }
  25.         }
  26.         //将当前生成的节点接到 cur 的后边
  27.         cur.next = next;
  28.         cur = cur.next;
  29.         h = h.next;
  30.     }
  31.     return map.get(head);
  32. }

解法三

上边的两种解法都用到了 HashMap ，所以额外需要 O(n) 的空间复杂度。现在考虑不需要额外空间的方法。

主要参考了这里-and-linear-time-complexity-O(N))。主要解决的问题就是我们生成节点以后，当更新它的 random 的时候，怎么找到之前生成的节点，前两种解法用了 HashMap 全部存起来，这里的话可以利用原来的链表的指针域。

主要需要三步。

  1. 生成所有的节点，并且分别插入到原有节点的后边
  2. 更新插入节点的 random
  3. 将新旧节点分离开来

一图胜千言，大家看一下下边的图吧。

138. Copy List with Random Pointer - 图2

代码对应如下。

  1. public Node copyRandomList(Node head) {
  2.     if (head == null) {
  3.         return null;
  4.     }
  5.     Node l1 = head;
  6.     Node l2 = null;
  7.     //生成所有的节点，并且分别插入到原有节点的后边
  8.     while (l1 != null) {
  9.         l2 = new Node(l1.val);
  10.         l2.next = l1.next;
  11.         l1.next = l2;
  12.         l1 = l1.next.next;
  13.     }
  14.     //更新插入节点的 random
  15.     l1 = head;
  16.     while (l1 != null) {
  17.         if (l1.random != null) {
  18.             l1.next.random = l1.random.next;
  19.         }
  20.         l1 = l1.next.next;
  21.     }
  23.     l1 = head;
  24.     Node l2_head = l1.next;
  25.     //将新旧节点分离开来
  26.     while (l1 != null) {
  27.         l2 = l1.next;
  28.         l1.next = l2.next;
  29.         if (l2.next != null) {
  30.             l2.next = l2.next.next;
  31.         }
  32.         l1 = l1.next;
  33.     }
  34.     return l2_head;
  35. }

解法四

不利用额外的空间复杂度还有一种思路，参考 这里。

解法三利用原链表的 next 域把新生成的节点保存了起来。类似的，我们还可以利用原链表的 random 域把新生成的节点保存起来。

主要还是三个步骤。

  1. 生成所有的节点，将它们保存到原链表的 random 域，同时利用新生成的节点的 next 域保存原链表的 random。
  2. 更新新生成节点的 random 指针。
  3. 恢复原链表的 random 指针，同时更新新生成节点的 next 指针。

一图胜千言。

138. Copy List with Random Pointer - 图3

相应的代码如下。

  1. public Node copyRandomList(Node head) {
  2.     if (head == null) {
  3.         return null;
  4.     }
  5.     Node l1 = head;
  6.     Node l2 = null;
  7.     //生成所有的节点，讲它们保存到原链表的 random 域，
  8.     //同时利用新生成的节点的 next 域保存原链表的 random。
  9.     while (l1 != null) {
  10.         l2 = new Node(l1.val);
  11.         l2.next = l1.random;
  12.         l1.random = l2;
  13.         l1 = l1.next;
  14.     }
  15.     l1 = head;
  16.     //更新新生成节点的 random 指针。
  17.     while (l1 != null) {
  18.         l2 = l1.random;
  19.         l2.random = l2.next != null ? l2.next.random : null;
  20.         l1 = l1.next;
  21.     }
  23.     l1 = head;
  24.     Node l2_head = l1.random;
  25.     //恢复原链表的 random 指针，同时更新新生成节点的 next 指针。
  26.     while (l1 != null) {
  27.         l2 = l1.random;
  28.         l1.random = l2.next;
  29.         l2.next = l1.next != null ? l1.next.random : null;
  30.         l1 = l1.next;
  31.     }
  32.     return l2_head;
  33. }

总

解法一、解法二是比较直接的想法，直接利用 HashMap 存储之前的节点。解法三、解法四利用原有链表的指针，通过指来指去完成了赋值。链表操作的核心思想就是，在改变某一个节点的指针域的时候，一定要把该节点的指针指向的节点用另一个指针保存起来，以免造成丢失。

windliang wechat

添加好友一起进步~

如果觉得有帮助的话，可以点击 这里 给一个 star 哦 ^^

如果想系统的学习数据结构和算法，强烈推荐一个我之前学过的课程，可以点击 这里 查看详情