复杂链表的复制（剑指offer）

原题来自牛客网剑指offer系列：链接

题目描述

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

思路

（1）只扫一遍，投机取巧法：

这道题判题系统是根据值来判断结果是否正确的，所以可以投机取巧，直接一次循环搞定，但是random指向的节点只是值正确了，地址可能不正确。

class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        if(!pHead)   
            return NULL;
        RandomListNode *p=pHead->next,*ans=new RandomListNode(pHead->label),*p1=ans;
        if(pHead->random)
            ans->random=new RandomListNode(pHead->random->label);
        while(p!=NULL){
            RandomListNode *tmp=new RandomListNode(p->label);
           	//random的值是对的，但是地址不对
            if(p->random)
                tmp->random=new RandomListNode(p->random->label);
            p1->next=tmp;
            p1=tmp;
            p=p->next;
        }
        return ans;
    }
};

（2）扫两遍法：

按照题目的要求，新链表中所有结点都是自己new的，因此难点在于random会指向随机节点，而这个节点有可能我们还没创建好。

因此要利用next顺序扫描两遍链表，第一遍要创建新结点并且把所有新结点按照next关系连接好，第二遍要把random关系处理好。

要保证random地址正确，需要扫两遍，而且需要使用一对一映射的数据结构记录信息，如下：

class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        if(!pHead)   
            return NULL;
        map<RandomListNode*,RandomListNode* > node_map;
        RandomListNode *p=pHead->next,*ans=new RandomListNode(pHead->label),*p1=ans;
        node_map[pHead]=ans;
        while(p!=NULL){
            RandomListNode *tmp=new RandomListNode(p->label);
            node_map[p]=tmp;
            p1->next=tmp;
            p1=tmp;
            p=p->next;
        }
        p=pHead;
        p1=ans;
        while(p!=NULL){
            if(p->random!=NULL&&node_map.find(p->random)!=node_map.end()&&node_map[p->random]!=NULL)
                p1->random=node_map[p->random];
            else if(p->random!=NULL&&node_map.find(p->random)==node_map.end())
                p1->random=new RandomListNode(p->random->label);
            p1=p1->next;
            p=p->next;
        }
        return ans;
    }
};

（3）考虑周全的递归法

上面的方法不但看起来很麻烦，而且还有漏洞（虽然后台数据不涉及），因为random指向的结点有可能后续是一个完全独立的新分支，按前面两种方法都无法解决这种问题。

因此可以采用dfs递归搜索的方法来实现，同样使用map结构来记录下旧结节点和新节点的对应关系（保证结点地址是正确的，而不仅仅值正确），如下：

class Solution {
public:
    map<RandomListNode*,RandomListNode* > node_map;
    RandomListNode* Clone(RandomListNode* pHead)
    {
        if(!pHead)   
            return NULL;
        RandomListNode* ans;
        getans(pHead,ans);
        return ans;
    }
    void getans(RandomListNode* pHead,RandomListNode *&p){
        if(pHead==NULL)
            p=NULL;
        else{
            if(node_map.find(pHead)!=node_map.end())
                p=node_map[pHead];
            else{
                p=new RandomListNode(pHead->label);
                node_map[pHead]=p;
                getans(pHead->next,p->next);
                getans(pHead->random,p->random);
            }
        }
    }
};

---

2021.1.25二刷：

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(!head)
            return NULL;
        Node *p=head;
        unordered_map<Node *,Node *> map;
        Node *p1=new Node(0),*ans=p1;
        while(p){
            p1->next=new Node(p->val);
            p1=p1->next;
            map[p]=p1;
            p=p->next;
        }
        p1->next=NULL;
        p=head;
        p1=ans->next;
        while(p){
            p1->random=map[p->random];
            p=p->next;
            p1=p1->next;
        }
        return ans->next;
    }
};