复制带随机指针的链表

最新推荐文章于 2022-03-24 15:04:59 发布

少喝烫水

最新推荐文章于 2022-03-24 15:04:59 发布

阅读量308

点赞数 1

分类专栏： leetcode 链表

本文链接：https://blog.csdn.net/tsunagxy/article/details/107557633

版权

leetcode 同时被 2 个专栏收录

35 篇文章 0 订阅

订阅专栏

链表

20 篇文章 0 订阅

订阅专栏

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

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

我们用一个由 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
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

在每个节点的后面插入一个值相等的新结点
为新结点拷贝random，让新结点的random指向null或原节点的random的next（即该节点拷贝的新结点
将原节点连接起来，将新结点连接起来，即深拷贝出的链表

/*
// 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 == nullptr) return head;
        
        Node* ptr = head;

        while(ptr != nullptr){

            Node* copy = new Node(ptr->val);

            copy->next = ptr->next;
            ptr->next = copy;
            ptr = copy->next;
        }

        ptr = head;

        while(ptr != nullptr ){

            Node* copy = ptr->next;

            if(ptr->random == nullptr) copy->random = nullptr;
            else{

                copy->random = ptr->random->next;

            }

            if(copy->next == nullptr) break;

            ptr = copy->next;
        }

        ptr = head;
        
        Node* newHead = head->next;
        Node* ptr1 = newHead;

        while(ptr1->next != nullptr){
            
            ptr->next = ptr1->next;
            ptr1->next = ptr1->next->next;
            
            ptr1 = ptr1->next;
            ptr = ptr->next;
        }

        ptr->next = nullptr;

        return newHead;

    }
};

官方题解：

1.回溯

首先，我们来看一下有向链表：
在这里插入图片描述

在上图中，对于一个节点，它的 next 指针指向链表中的下一个节点。 next 指针是通常有向链表中有的部分且将所有节点链接起来。图中有趣的一点，也是这题有趣的一点在于 random 指针，正如名字所示，它可以指向链表中的任一节点也可以为空。

思路

回溯算法的第一想法是将链表想象成一张图。链表中每个节点都有 2 个指针（图中的边）。因为随机指针给图结构添加了随机性，所以我们可能会访问相同的节点多次，这样就形成了环。
在这里插入图片描述
上图中，我们可以看到随机指针指向了前一个节点，因此成环。我们需要考虑这种环的实现。

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

算法

从头指针开始遍历整个图。

我们将链表看做一张图。下图对应的是上面的有向链表的例子，Head 是图的出发节点。
当我们遍历到某个点时，如果我们已经有了当前节点的一个拷贝，我们不需要重复进行拷贝。
如果我们还没拷贝过当前节点，我们创造一个新的节点，并把该节点放到已访问字典中，即：

visited_dictionary[current_node] = cloned_node_for_current_node.

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

cloned_node_for_current_node.next = copyRandomList(current_node.next);
cloned_node_for_current_node.random = copyRandomList(current_node.random);

/*
// Definition for a Node.
class Node {
    public int val;
    public Node next;
    public Node random;

    public Node() {}

    public Node(int _val,Node _next,Node _random) {
        val = _val;
        next = _next;
        random = _random;
    }
};
*/
public class Solution {
  // HashMap which holds old nodes as keys and new nodes as its values.
  HashMap<Node, Node> visitedHash = new HashMap<Node, Node>();

  public Node copyRandomList(Node head) {

    if (head == null) {
      return null;
    }

    // If we have already processed the current node, then we simply return the cloned version of
    // it.
    if (this.visitedHash.containsKey(head)) {
      return this.visitedHash.get(head);
    }

    // Create a new node with the value same as old node. (i.e. copy the node)
    Node node = new Node(head.val, null, null);

    // Save this value in the hash map. This is needed since there might be
    // loops during traversal due to randomness of random pointers and this would help us avoid
    // them.
    this.visitedHash.put(head, node);

    // Recursively copy the remaining linked list starting once from the next pointer and then from
    // the random pointer.
    // Thus we have two independent recursive calls.
    // Finally we update the next and random pointers for the new node created.
    node.next = this.copyRandomList(head.next);
    node.random = this.copyRandomList(head.random);

    return node;
  }
}

作者：LeetCode
链接：https://leetcode-cn.com/problems/copy-list-with-random-pointer/solution/fu-zhi-dai-sui-ji-zhi-zhen-de-lian-biao-by-leetcod/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

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

2.迭代（空间O(N)

思路

迭代算法不需要将链表视为一个图。当我们在迭代链表时，我们只需要为 random 指针和 next 指针指向的未访问过节点创造新的节点并赋值即可。

算法

从 head 节点开始遍历链表。下图中，我们首先创造新的 head 拷贝节点。拷贝的节点如下图虚线所示。实现中，我们将该新建节点的引用也放入已访问字典中。

在这里插入图片描述
2. random 指针

如果当前节点 i 的 random 指针指向一个节点 j 且节点 j 已经被拷贝过，我们将直接使用已访问字典中该节点的引用而不会新建节点。
如果当前节点 i 的 random 指针指向的节点 j 还没有被拷贝过，我们就对 j 节点创建对应的新节点，并把它放入已访问节点字典中。

下图中， A 的 random 指针指向的节点 C 。前图中可以看出，节点 C 还没有被访问过，所以我们创造一个拷贝的 C’ 节点与之对应，并将它添加到已访问字典中。

在这里插入图片描述

next 指针

如果当前节点 i 的 next 指针指向的节点 j 在已访问字典中已有拷贝，我们直接使用它的拷贝节点。
如果当前节点 i 的next 指针指向的节点 j 还没有被访问过，我们创建一个对应节点的拷贝，并放入已访问字典。

在这里插入图片描述

我们重复步骤 2 和步骤 3 ，直到我们到达链表的结尾。

在这里插入图片描述

/*
// Definition for a Node.
class Node {
    public int val;
    public Node next;
    public Node random;

    public Node() {}

    public Node(int _val,Node _next,Node _random) {
        val = _val;
        next = _next;
        random = _random;
    }
};
*/
public class Solution {
  // Visited dictionary to hold old node reference as "key" and new node reference as the "value"
  HashMap<Node, Node> visited = new HashMap<Node, Node>();

  public Node getClonedNode(Node node) {
    // If the node exists then
    if (node != null) {
      // Check if the node is in the visited dictionary
      if (this.visited.containsKey(node)) {
        // If its in the visited dictionary then return the new node reference from the dictionary
        return this.visited.get(node);
      } else {
        // Otherwise create a new node, add to the dictionary and return it
        this.visited.put(node, new Node(node.val, null, null));
        return this.visited.get(node);
      }
    }
    return null;
  }

  public Node copyRandomList(Node head) {

    if (head == null) {
      return null;
    }

    Node oldNode = head;

    // Creating the new head node.
    Node newNode = new Node(oldNode.val);
    this.visited.put(oldNode, newNode);

    // Iterate on the linked list until all nodes are cloned.
    while (oldNode != null) {
      // Get the clones of the nodes referenced by random and next pointers.
      newNode.random = this.getClonedNode(oldNode.random);
      newNode.next = this.getClonedNode(oldNode.next);

      // Move one step ahead in the linked list.
      oldNode = oldNode.next;
      newNode = newNode.next;
    }
    return this.visited.get(head);
  }
}

作者：LeetCode
链接：https://leetcode-cn.com/problems/copy-list-with-random-pointer/solution/fu-zhi-dai-sui-ji-zhi-zhen-de-lian-biao-by-leetcod/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

少喝烫水

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制带随机指针的链表

给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。要求返回这个链表的深拷贝。我们用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：val：一个表示 Node.val 的整数。random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。示例 1：输入：head = [[7,null],[13,0],[11,4],[10,2],[
复制链接

扫一扫