剑指Offer：[第2天 链表(简单)]---＞复杂链表的复制

---

一、题目描述

请实现 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。

提示：

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

二、思路分析

注：思路分析中的一些内容和图片参考自力扣各位前辈的题解，感谢他们的无私奉献

分析

复制普通链表：给定链表的头结点head，复制普通链表很简单，只需遍历链表，每轮需要：建立新结点 + 让前驱结点的next指向当前这个新结点 + 让当前这个新结点的next指向空
复制复杂链表：本题链表的结点新增了 random 指针，指向链表中的任意结点或者null。这个 random 指针意味着在复制过程中，除了构建前驱结点的next指针，还要构建前驱结点的ramdom指针。因此，每轮需要：建立2个新结点 + 让前驱结点的next指向第1个新结点 + 让前驱结点的random指向第2个新结点。但是这有一个问题：并不是每次都需要建立2个新结点。有时候前驱结点的random指向的是已经存在的结点，但是如何判断出来呢？如果把所有结点遍历一遍，那就太麻烦了。

思路1：使用哈希表

利用哈希表的查询特点，考虑构建原链表结点和新链表对应结点的键值对映射关系，再遍历构建新链表各结点的next和random引用指向即可。
算法流程：
①若头节点head为空结点，直接返回NULL ；
②初始化：声明一个哈希表dic，定义一个结点cur指向头结点，这个cur控制后面的循环
③建立哈希映射：遍历这个链表，每个链表结点对应建立一个新结点，并向dic添加键值对(原cur结点, 新cur结点)
④构建新链表的引用指向：构建新结点的next和random引用指向
⑤返回值： 返回新链表的头结点，即dic[cur]












复杂度分析
时间复杂度O(N)：两轮遍历链表，使用O(N)时间。
空间复杂度O(N)：哈希表dic使用线性大小的额外空间。

思路2：链表拼接

考虑构建原节点1->新节点1->原节点2->新节点2->……的拼接链表，如此便可在访问原节点的 random 指向节点的同时找到新对应新节点的 random 指向节点。
算法流程
①复制各节点，构建拼接链表：
设原链表为$node1\to node2\to ...$，构建的拼接链表为$node1\to node{1}_{new}\to node2\to node{2}_{new}\to ...$
②构建新链表各节点的random指向：
当访问原节点cur的随机指向节点cur.random时，对应新节点cur.next的随机指向节点为cur.random.next。
③拆分原 / 新链表：
设置pre/cur分别指向原/新链表头节点，遍历执行pre.next=pre.next.next和cur.next=cur.next.next将两链表拆分开。返回新链表的头节点res即可。







复杂度分析：
时间复杂度O(N)：三轮遍历链表，使用O(N)时间。
空间复杂度O(1)：节点引用变量使用常数大小的额外空间。

三、整体代码

思路1对应代码如下：

/*
// 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) {
        //若是空链表，则返回NULL
        if(head == NULL) return NULL;
        //创建一个结点，指向这个链表的头结点。这个结点用来控制后面的循环
        Node* cur = head; 
        //创建一个哈希表
        unordered_map<Node*, Node*> map;
        while(cur != NULL){
            //为链表每个结点创建一个对应的新结点，并建立原结点和新结点的Map映射
            map[cur] = new Node(cur->val);
            cur = cur->next;
        }
        cur = head;
        //为新链表每个结点的next和random设置对应的指向
        while(cur != NULL){
            map[cur]->next = map[cur->next];
            map[cur]->random = map[cur->random];
            cur = cur->next;
        }
        //返回新链表的头结点
        return map[head];
    }
};

思路2对应代码如下：

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;          //新结点的next就是当前结点的next
            cur->next = tmp;                //将新结点插在当前结点后
            cur = tmp->next;                //移动到下一个结点
        }

        //2、为各个新结点构建对应的random
        cur = head; 
        while(cur != NULL){
            if(cur->random != NULL){
                //新结点的random指向原来结点cur->random->next
                //因为cur->random->next是新结点，对应老节点为cur->random，所以要指向cue->random->next
                cur->next->random = cur->random->next;
            }
            cur = cur->next->next;
        }

        //3、拆分两个链表
        cur = head->next; //使用cur对新链表进行处理
        Node* pre = head; //原来链表
        Node* res = head->next; //新链表的头结点
        while(cur->next != nullptr){
            pre->next = pre->next->next; 
            cur->next = cur->next->next;
            pre = pre->next;
            cur = cur->next;
        }
        pre->next = NULL;  //原链表尾节点必须指向空，否则会出错
        return res;        //返回新链表的头结点
    }
};

运行，测试通过