剑指Offer-复制含有随机指针节点的链表-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_35646931/article/details/103658847

30.复制含有随机指针节点的链表

【题目】一种特殊的链表节点类描述如下：

public class Node

{ 
	public int value;
	public Node next;
	public Node rand;
	public Node(int data) { this.value = data; }

}

Node类中的value是节点值，next指针和正常单链表中next指针的意义一样，

都指向下一个节点，rand指针是Node类中新增的指针，

这个指针可能指向链表中的任意一个节点，也可能指向null。

给定一个由Node节点类型组成的无环单链表的头节点head，

请实现一个函数完成这个链表中所有结构的复制，并返回复制的新链表的头节点。

进阶：不使用额外的数据结构，只用有限几个变量，且在时间复杂度为 O(N) 内完成原问题要实现的函数。

错误思路

先来看一种错误的思路。即直接新建链表，遍历原来链表，然后利用尾插法，复制原来链表的各个节点以及对应节点的random节点。

class Solution {
    public ListNode copyRandomList(ListNode head) {
        if(head==null) return head;
        ListNode nHead=new ListNode(-1);
        ListNode nCur=nHead;
        cur=head;
        while(cur!=null)
        {
           //注意此句
           nCur.next=new ListNode(cur.val);
           nCur=nCur.next;
           if(cur.random!=null)
           {
               //注意此句
               nCur.random=new ListNode(cur.random.val);
           }
           cur=cur.next;
        }
        return nHead.next;
        
    }
}

注释的两句都直接新创建节点，然后直接将next或者random指针指向了这个新建的节点。这样的“复制”实际是不符合题意的！与原链表的形式根本不一样，因为random指针错乱，可能还会新创建几个对象成为多余的random节点！

同理，在利用HashMap的时候，key和value必须是ListNode类型！这是为了保证HashMap里对象的唯一性，**不要等到在连接next和random的时候再创建新的对象！**下面是正确思路。

思路一

遍历链表，用hashmap存储原链表的节点及其复制节点。
其中key是原链表节点，value是此节点的复制节点。
再次遍历原链表，根据key找value，创建新链表。
value的next是原链表节点的next的value。
它的rand是原链表节点的random的value。

 class Solution {
    public ListNode copyRandomList(ListNode head) {
        if(head==null) return head;
        
        ListNode cur=head;
        //key value 必须都是ListNode
        HashMap<ListNode,ListNode>map=new HashMap<>();
        while(cur!=null)
        {
            map.put(cur,new ListNode(cur.val));
            cur=cur.next;
        }
        ListNode nHead=new ListNode(-1);
        ListNode nCur=nHead;
        cur=head;
        while(cur!=null)
        {
           nCur.next=map.get(cur);
           nCur=nCur.next;
           if(cur.random!=null)
           {
               nCur.random=map.get(cur.random);
           }
           cur=cur.next;
        }
        return nHead.next;
        
    }
}

思路二：

第一遍遍历，在原链表的基础上,复制每一个节点（插入到其与其next中间）。
随后再次遍历，有两个指针，一个指向原链表节点，一个指向复制节点。
复制节点的random指向它原生节点的random的next。
此时，两条链在逻辑上已经分开了。我们再次遍历，将其物理上分开即可。
边界容易引发控股指针异常，需要扣扣。

class Solution {
    public ListNode copyRandomList(ListNode head) {
        
        if(head==null) return head;
        ListNode cur=head;
        //复制链表
        while(cur!=null)
        {
            ListNode p=new ListNode(cur.val);
            p.next=cur.next;
            cur.next=p;
            cur=cur.next.next;
        }
        //找到random
        cur=head;//指针复用,不容易乱
        while(cur.next!=null)
        {
            if(cur.random!=null)
            {
                cur.next.random=cur.random.next;
            }
            cur=cur.next.next;
            if(cur==null) break;//注意边界
        }
        //拆分链表
        cur=head;//指针复用,不容易乱
        ListNode nHead=new ListNode(-1);
        ListNode temp=nHead;
        while(cur.next!=null)
        {
         temp.next=cur.next;
         temp=temp.next;
         cur.next=cur.next.next;
         cur=cur.next;
         if(cur==null) break;//注意边界
        }
        return nHead.next;       
    }
}