LeetCode（138）：复制带随机指针的链表 Copy List with Random Pointer（Java）_leetcode 138. 随机链表的复制 详细解释 java

2019.8.16 #程序员笔试必备# LeetCode 从零单刷个人笔记整理（持续更新）

这道题难在对random指针的深拷贝上，如果能够建立每一个旧结点和新结点之间的关系，就可以在o(n)的时间复杂度上解决这道题。那么可以有两个思路：

1.利用哈希表将旧结点作为key，新结点作为value，建立两者关系，空间复杂度o（n）。

2.利用原链表的位置建立关系，将新结点建立在旧结点之后，行程一个两倍长度的新旧结点交替的链表，以此能够用旧结点的next指针来获得新结点。拷贝完random指针之后再分离链表即可。

---

传送门：复制带随机指针的链表

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.

给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。

要求返回这个链表的深拷贝。

示例：
输入：
{"$id":"1","next":{"$id":"2","next":null,"random":{"$ref":"2"},"val":2},"random":{"$ref":"2"},"val":1}

解释：
节点 1 的值是 1，它的下一个指针和随机指针都指向节点 2 。
节点 2 的值是 2，它的下一个指针指向 null，随机指针指向它自己。

提示：你必须返回给定头的拷贝作为对克隆列表的引用。
1
2
3
4
5
6
7
8
9

---

import java.util.HashMap;

/**
 *
 * 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.
 * 给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。
 * 要求返回这个链表的深拷贝。
 *
 */

public class CopyListWithRandomPointer {
    class Node {
        public int val;
        public Node next;
        public Node random;

        public Node() {}

        public Node(int _val,Node _next,Node _random) {
            val = _val;
            next = _next;
            random = _random;
        }
    }

    public Node copyRandomList(Node head) {
        HashMap<Node, Node> map = new HashMap<>();
        Node newHead = new Node();
        Node pNew = newHead;
        Node pOld = head;
        while(pOld != null){
            pNew.next = new Node(pOld.val, null, null);
            pNew = pNew.next;
            map.put(pOld, pNew);
            pOld = pOld.next;
        }
        pNew = newHead.next;
        pOld = head;
        while(pOld != null){
            pNew.random = map.get(pOld.random);
            pNew = pNew.next;
            pOld = pOld.next;
        }
        return newHead.next;
    }

    //O(1)空间的迭代
    public Node copyRandomList2(Node head){
        if(head == null){
            return null;
        }
        Node p = head;
        //遍历原来的链表并拷贝每一个节点，将拷贝节点放在原来节点的旁边，创造出一个旧节点和新节点交错的链表。
        while(p != null){
            Node newNode = new Node(p.val, null, null);
            newNode.next = p.next;
            p.next = newNode;
            p = newNode.next;
        }

        //迭代这个新旧节点交错的链表，并用旧节点的 random 指针去更新对应新节点的 random 指针。
        p = head;
        while(p != null){
            p.next.random = (p.random != null) ? p.random.next : null;
            p = p.next.next;
        }

        //拆分还原两个链表。
        Node pOld = head;
        Node pNew = head.next;
        Node newHead = head.next;
        while (pOld != null) {
            pOld.next = pOld.next.next;
            pNew.next = (pNew.next != null) ? pNew.next.next : null;
            pOld = pOld.next;
            pNew = pNew.next;
        }
        return newHead;
    }
}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

---

#Coding一小时，Copying一秒钟。留个言点个赞呗，谢谢你#