剑指 Offer 35. 复杂链表的复制

题目

请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。
示例 1：

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2：

输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]

示例 3：

输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]

示例 4：

输入：head = []
输出：[]
解释：给定的链表为空（空指针），因此返回 null。

代码

class Solution {
    public Node copyRandomList(Node head) {
        //边界判断，头节点是否为空
        if(head==null){
            return null;
        }
        
        //从链表头节点开始遍历
        Node cur=head;
        //使用一一对应的哈希表结构Map存放已经创建好的节点
        Map<Node,Node> map=new HashMap<Node,Node>();


        //遍历原链表,复制各节点，并建立 “原节点 -> 新节点” 的 Map 映射
        while(cur!=null){
            //以原链表的节点为 Key，构建一个Map,Map 的Value 为一个新链表中的节点
            //新节点的值val和原链表的值val一样
            //但原链表的每个节点都有 next和random指针，而 Map中的 Value没有next和random指针
            //map.put(Key , Value)
            Node newNode=new Node(cur.val);
            //查看下一个节点
            map.put(cur,newNode);
            cur=cur.next;
        }

        //再次从链表的头节点开始遍历
        cur=head;
        //遍历原链表
        while(cur!=null){
            //原链表节点—---新链表节点
            // key----- value
            // cur—---- map.get(cur)
            /*map.get(cur).next = map.get(cur.next);
            map.get(cur).random = map.get(cur.random);*/

            // 0、在字典中找到一个cur为key对应的那个value值
            Node valueCur=map.get(cur);
            //接下来，需要去寻找valuecur 的next节点和random节点

            //寻找valuecur 的next节点
            //1、获取当前节点cur在原链表中的next指针指向的节点
            Node keyNextNode=cur.next;
            //2、在字典中找到以keyNextNode 为 key对应的那个value值
            Node valueNextNode=map.get(keyNextNode);
            //3、那么新链表中的这个节点的next指针就是valueNextNode
            valueCur.next=valueNextNode;

            //寻找valuecur 的节点
            //1、获取当前节点cur在原链表中的random指针指向的节点
            Node keyRandomNode=cur.random;
            //2、在字典中找到以 valueRandomNode 为 key对应的那个value值
            Node valueRandomNode=map.get(keyRandomNode);
            // 4、那么新链表中的这个节点的next指针就是valueNextNode
            valueCur.random=valueRandomNode;
            // 遍历下去，查看下一个节点
            cur=cur.next;
        }
        //原链表节点—---新链表节点
        //key----- value
        //cur—---- map.get(cur)
        //head——--- map.get(head)
        //返回新链表的头节点
        return map.get(head);
    }
}

方法二：拼接 + 拆分

构建

原节点 1 -> 新节点 1 -> 原节点 2 -> 新节点 2 -> ……

的拼接链表，如此便可在访问原节点的 random 指向节点的同时找到新对应新节点的 random 指向节点。

class Solution {
    public Node copyRandomList(Node head) {
        if(head==null){
            return null;
        }
        //复制节点的值，放到原节点后面
        Node cur=head;
        while(cur!=null){
            Node copy=new Node(cur.val);
            copy.next=cur.next;//副本指向原节点后面的
            cur.next=copy;
            cur=copy.next;//cur移动到原链表后续节点
        }
        //构造random
        cur=head;
        while(cur!=null){
            if(cur.random!=null){
                //cur----a
                //cur.next----a复制
                //cur.random---b
                //cur.random.next---b复制
                /*复制的节点（a复制）的随机指针指向当前节点（b）的随机指针的后续节点(即后续复制的节点：b复制)*/
                cur.next.random=cur.random.next;  
            }
            //遍历原链表的节点
            cur=cur.next.next;
        }
        
        //链表拆分
        cur=head;
        Node newHead=head.next; //复制链表头节点
        while(cur.next!=null){
            Node temp=cur.next;
            cur.next=temp.next;//让它和它间隔的那个节点相连
            cur=temp;
        }
        return newHead;
    }
}

class Solution {
    public Node copyRandomList(Node head) {
        if(head == null) return null;
        Node cur = head;
        // 1. 复制各节点，并构建拼接链表
        while(cur != null) {
            Node tmp = new Node(cur.val);
            tmp.next = cur.next;
            cur.next = tmp;
            cur = tmp.next;
        }
        // 2. 构建各新节点的 random 指向
        cur = head;
        while(cur != null) {
            if(cur.random != null)
                cur.next.random = cur.random.next;
            cur = cur.next.next;
        }
        // 3. 拆分两链表
        cur = head.next;
        Node pre = head, res = head.next;
        while(cur.next != null) {
            pre.next = pre.next.next;
            cur.next = cur.next.next;
            pre = pre.next;
            cur = cur.next;
        }
        pre.next = null; // 单独处理原链表尾节点
        return res;      // 返回新链表头节点
    }
}