leetcode 138 复制带随机指针的链表

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

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

我们用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：

val：一个表示 Node.val 的整数。
random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 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。

提示：

-10000 <= Node.val <= 10000
Node.random 为空（null）或指向链表中的节点。
节点数目不超过 1000 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/copy-list-with-random-pointer
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路一：

1. 题目要求深拷贝，则通过两次遍历分别复制节点和使random指针指向正确的位置；
2. 关键在于random指针不能简单的复制原链表中的指针，因为要求深拷贝即指向拷贝后的相对应的位置；
3. 因此使用一个map来在每一次复制新的节点的时候保存对应关系，之后在第二次遍历的时候，可通过map来找到对应的位置。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
public:
    Node* copyRandomList(Node* head) {
        Node dummy(0);
        Node* newhead = &dummy;
        Node* p = newhead;
        Node* rhead = head;
        unordered_map<Node*,Node*> Nodemap;

        while(head)
        {
            Node* newnode = new Node(head->val);
            p->next = newnode;
            Nodemap.insert(pair<Node*,Node*>(head,newnode));
            p = p->next;
            head = head->next;
        }
        p = newhead;
        head = rhead;
        while(head)
        {
            unordered_map<Node*,Node*>::iterator iter = Nodemap.find(head->random);
            if(iter!=Nodemap.end())
            p->next->random = iter->second;
            else p->next->random = NULL;
            p = p->next;
            head = head->next;
        }

        return dummy.next;
    }
};

思路二：(空间复杂度o(1))
1. 复制每个节点，并将其链接在原链表相同节点之后，原链表长度变成原来的两倍，新旧节点交替链接，这样就可以将整个链表视作一个有hash功能的链表，可以找到节点之间的对应关系；
2. 第二次遍历更新每个复制节点的random指针，因为第一步中提到的方法，不需要额外空间就可以通过旧的节点找到新的节点；
3. 将新旧节点分离，链表长度一定为2的倍数，因此将next通过一个缓存指针指向正确的地方即可。
关键点在于：
1. 复制random指针的时候，注意判断空指针；
2. 链表分离的时候也要注意判断空指针；

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(!head)return nullptr;
        Node* nhead = head;
        while(head)
        {
            Node* temp = head->next;
            head->next = new Node(head->val);
            head->next->next = temp;
            head = temp;
        }
        head = nhead;
        Node* ret = head->next;
        while(head)
        {
            Node* orandom = head->random;
            if(orandom)
            head->next->random = orandom->next;
            else head->next->random = nullptr;
            head = head->next;
            head = head->next;
        }
        head = nhead;
        while(head)
        {
            Node* temp;
            temp = head->next;
            head->next = temp ->next;
            head = head->next;
            if(head)
            {
                temp->next = head->next;
                temp = temp->next;
            }
            else{
                temp->next = nullptr;
            }
            
        }
        return ret;

    }
};