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

题目来源

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

题目描述

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) {
        
    }
};

题目解析

迭代：

初始化一个map，第一次遍历原始链表，使用这些链表的值拷贝，并且map[旧节点] = 新节点

第二次遍历链表，给新节点之间连上线

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head == NULL){
            return NULL;
        }

        Node *origin = head;
        std::unordered_map<Node *, Node *> map;
        while (origin){
            Node *clone = new Node(origin->val);
            map[origin] = clone;
            origin = origin->next;
        }

        origin = head;
        while (origin){    // 当前节点不为空
            if(origin->next){  // 当前节点的下一个节点不为空
                map[origin]->next = map[origin->next];
            }

            if(origin->random){
                map[origin]->random = map[origin->random];
            }
            origin = origin->next;
        }

        return map[head];
    }
};

回溯

回溯算法的第一想法是将链表想象成一张图。链表中每个节点都有2个指针(图中的边)。因为随机指针给图结构添加了随机性，所以我们可能会访问相同的节点多次，这样就形成了环

上图中，我们可以看到随机指针指向了前一个节点，因此形成了环。我们需要考虑这种环的实现。

此方法中，我们只需要遍历整个图并且拷贝它。拷贝的意思是每当遇到一个新的没有访问过的节点，你都要创造一个新的节点。遍历按照深度优先进行。我们需要在回溯的过程中记录已经访问过的节点，否则因为随机指针的存在进入死循环。

算法：

• 从头指针开始遍历整张图
  我们将链表看做一张图。下图对应的是上面的有向链表的例子，head是图的出发节点。
  、

• 当我们遍历到某个点时，如果我们已经有了当前节点的一个拷贝，我们不需要重复进行拷贝。
  如果我们还没拷贝过当前节点，我们创造一个新的节点，并把该节点放到已访问字典中

• 我们针对两种情况进行回溯调用：一个顺着 random 指针调用，另一个沿着 next 指针调用。步骤 1 中将 random 和 next 指针分别红红色和蓝色标注。然后我们分别对两个指针进行函数递归调用：

class Solution {
    std::unordered_map<Node *, Node *> map;
public:
    Node* copyRandomList(Node* head) {
        if (head == nullptr){
            return nullptr;
        }

        if(map.count(head)){
            return map[head];
        }
        
        Node *node = new Node(head->val);
        node->next = nullptr;
        node->random = nullptr;
        
        map[head] = node;
        
        node->next = copyRandomList(head->next);
        node->random = copyRandomList(head->random);
        
        return node;
    }
};

时间复杂度：O(N) ，其中 NN 是链表中节点的数目。

空间复杂度：O(N)。如果我们仔细分析，我们需要维护一个回溯的栈，同时也需要记录已经被深拷贝过的节点，也就是维护一个已访问字典。渐进时间复杂度为 O(N)。

O(N)空间的迭代

• 维护一个旧节点和新节点的map

class Solution {
    std::unordered_map<Node *, Node *> map;
    Node *getCloneNode(Node *node){
        if(node == nullptr){
            return nullptr;
        }
        
        if(map.count(node)){
            return map[node];
        }else{
            Node *newNode = new Node(node->val);
            map.insert(node, newNode);
            return map[node];
        }
    }
public:
    Node* copyRandomList(Node* head) {
        if (head == nullptr){
            return nullptr;
        }
        
        Node *oldNode = head;
        Node *newNode = new Node(head->val);
        map.insert(head, newNode);
        
        while (oldNode != nullptr){
            newNode->next = getCloneNode(oldNode->next);
            newNode->random = getCloneNode(oldNode->random);
            newNode = newNode->next ;
            oldNode = oldNode->next;
        }
         
        return map[head];
    }
};

时间复杂度：O(N)。因为我们需要将原链表逐一遍历。
空间复杂度：O(N)。 我们需要维护一个字典，保存旧的节点和新的节点的对应。因此总共需要 N 个节点，需要 O(N)的空间复杂度。

O(1)空间的迭代

• 从左到右，对每个节点都复制一个副本节点copy，将拷贝节点放在原来节点的旁边，创造出一个旧节点和新节点交错的链表（比如原来1-2->null，变成1->1’->2->2’->null）

cloned_node.next = original.next
original.next = cloned_node

• 迭代这个新旧交替的链表，并用旧节点的random指针去更新对应新节点的random指针。比方说， B 的 random 指针指向 A ，意味着 B’ 的 random 指针指向 A’
  
• 现在 random 指针已经被赋值给正确的节点， 此时所有的节点和副本节点都串在了一（1->1’->2->2’->null），将其分离出来即可(1->2->null；1’->2’->null)。
  

class Solution {

public:
    Node* copyRandomList(Node* head) {
        if (head == nullptr){
            return nullptr;
        }
        
        Node *origial = head;
        while (origial != nullptr){
            Node *node = new Node(origial->val);
            node->next = origial->next;
            origial->next = node;
            origial = origial->next->next;
        }

        // 跳出循环之后：origial = null
        origial = head;
        while (origial != nullptr){
            if (origial->random != nullptr){
                origial->next->random = origial->random->next;
            }
            origial = origial->next->next;
        }


       //拆分
        origial = head;
        Node *clone = head->next;
        Node *cur_clone = clone;
        while (origial!= nullptr && cur_clone != nullptr){
            // 原始链表
            origial->next = origial->next == clone ? clone : origial->next->next;
            origial = origial->next;

            cur_clone->next = cur_clone->next == clone ? clone : cur_clone->next->next;
            cur_clone = cur_clone->next;
        }

        return clone;
    }
};

类似题目

题目	思路
leetcode：133. 克隆图 Clone Graph
leetcode：138. 复制带随机指针的链表 Copy List with Random Pointer