剑指 Offer 35. 复杂链表的复制

一、题目

 

题目链接：力扣

请实现copyRandomList函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个next指针指向下一个节点，还有一个random指针指向链表中的任意节点或者null。

示例 1：

// [ ，]前面的数字代表结点的值，后面的数组代表random指针指向的结点位置（从0开始）
输入：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 。

二、题解

1、思路

因为随机指针的存在，当我们拷贝节点时，「当前节点的随机指针指向的节点」可能还没创建，因此我们需要变换思路。

🍅 回溯 + 哈希表

回溯和递归的区别 详见回溯和递归区别_繁拾简忆的博客-CSDN博客_回溯和递归有什么区别

递归就像一个人不断地把问题扔给他的朋友，直到有一个朋友知道如何解决问题。在程序中，就是不断的调用自己的函数，直到问题被解决。

回溯就像一个人在找宝藏，他一步一步往前走，如果发现不对，他就回到上一步，换个方向再试。在程序中，就是不断地做决策，如果决策不对，就回到上一步，换个决策继续试。直到找到正确的答案。

利用哈希表【源指针，新指针】判断是否已经复制过，如果没有复制，首先创建新节点，记录到哈希表，并递归创建next和random指向的结点，创建完成后将地址分别返回给next和random。

在next和random创建的过程中，肯定会遇到已经复制过的结点，此时只需要将已经复制的结点地址返回给next和random即可。

🍅 迭代 + 节点拆分

在每个结点后面插入一个结点（初始化为旧结点的值），新结点与两侧连接，新节点的next指针暂时连接；旧结点后的新节点random应指向，该旧结点的random指向的旧结点的后一个新节点，这样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 {
private:
    // 键是源节点
    // 值是新节点
    // 通过count函数，查找源节点是否被复制（建立）
    unordered_map<Node*, Node*> established;
public:
    Node* copyRandomList(Node* head) {
        if(head == NULL)return head;

        // 如果当前结点未被复制过
        // 如果一个结点已经存在，说明它的next和random已经被处理过或者将要处理，无需再次处理
        // 如果结点已经被复制，通过哈希表返回已经复制好的结点即可
        if(established.count(head) == 0)
        {
            // 新建一个结点（复制）
            Node* new_head = new Node(head->val);// 注意上方构造函数

            // 记录当前head结点已经复制
            // 虽然此时next和random还未完成，但head结点无需再次复制
            established[head] = new_head;
            
            // 递归复制next和random指向内容
            new_head->next = copyRandomList(head->next);
            new_head->random = copyRandomList(head->random);
        }

        return established[head];// new_head
    }
};

🍅 迭代 + 节点拆分

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

        // 新建一个结点插入到每一个结点后
        // 至于为什么使用node = node->next->next，
        // 是因为一次循环中node指向不变，我们添加了一个结点
        for(Node* node = head; node != NULL; node = node->next->next)
        {
            Node* new_node = new Node(node->val);
            new_node->next = node->next;
            node->next = new_node;
        }
        
        // 原来结点A（任一）中random所指向结点的 
        // 后一个结点为A后方新建结点B的random应指向的结点
        // 此处的next->next是为了仅访原结点
        for(Node* node = head; node != NULL; node = node->next->next)
        {
            Node* new_node = node->next;// 上面新建的结点
            // 新建结点的random指向new_node前原来节点，其random指向的结点的后一个结点
            // 但是NULL是特殊情况
            new_node->random = (node->random != NULL) ?  node->random->next : NULL;
        }

        // 经过上方两次循环，我们完成了新建结点并插入，利用巧妙的关系，完成了random指针赋值
        // 现在把新建的结点提取出来，并连接就可以了
        Node* res = head->next;// 存放提取的结果 
        for(Node* node = head; node != NULL; node = node->next)// node->next是因为删去了新节点
        {
            Node* new_node = node->next;// 暂存新的结点，需要更改新节点到下一个新节点
            node->next = new_node->next;// 去掉新的结点
            // 一定要注意最后一个旧结点的情况
            new_node->next = (new_node->next == NULL) ? NULL : new_node->next->next;// 暂存的新节点指向下一个新节点，new_node声明周期结束
        }

        return res;
    }
};

3、复杂度分析

🍅 回溯 + 哈希表

时间复杂度：O(n)；每个节点都有两个指针，那么均摊下来，每个结点可能被访问两次。

空间复杂度：O(n)。

🍅 迭代 + 节点拆分

时间复杂度：O(n)；

空间复杂度：O(1)。

4、运行结果

🍅 回溯 + 哈希表

🍅 迭代 + 节点拆分