Leetcode 138. Copy List with Random Pointer

最新推荐文章于 2022-10-08 18:23:20 发布

再见小小ronnie

最新推荐文章于 2022-10-08 18:23:20 发布

阅读量192

点赞数

CC 4.0 BY-SA版权

分类专栏： Leetcode Hashtable

本文链接：https://blog.youkuaiyun.com/u011094114/article/details/60846821

Leetcode 同时被 2 个专栏收录

199 篇文章

订阅专栏

Hashtable

21 篇文章

订阅专栏

本文介绍了一种在O(n)时间复杂度和O(1)空间复杂度下复制带随机指针的链表的方法。通过三个步骤：复制节点并链接到原节点之后、设置随机指针、拆分原始链表与复制链表，实现高效复制。此外，还提供了一种使用哈希表的方法，在O(n)时间和空间复杂度内完成复制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

O(n) time and O(1) space.

Three steps.

Copy all new nodes and link them next to the old one;

Copy all random links for new nodes;

Restore both old list and new list.

Example.

1->2->3->null

1->1`->2->2`->3->3`->null

Restore to,

1->2->3->null

1`->2`->3`->null

public class Solution {
    public RandomListNode copyRandomList(RandomListNode head) {
        if (head == null)
            return null;
        
        // Link all new nodes next to the old nodes
        RandomListNode temp = head;
        while (temp != null) {
            RandomListNode newNode = new RandomListNode(temp.label);
            RandomListNode next = temp.next;
            temp.next = newNode;
            newNode.next = next;
            temp = temp.next.next;
        }
        
        // Copy random links for new nodes
        temp = head;
        while (temp != null) {
            RandomListNode newNode = temp.next;
            if (temp.random != null)            // if random link in the origin list is null, iterate to the next
                newNode.random = temp.random.next;
            temp = temp.next.next;
        }
        
        // Set all next links in new nodes to new nodes
        RandomListNode newHead = head.next;     // save the head of new list, we will modify the next link of head (origin list)
        temp = head;
        while (temp != null) {
            RandomListNode next = temp.next.next;
            RandomListNode newNode = temp.next;
            if (next != null)           // take care of the end of the list
                newNode.next = next.next;
            temp.next = next;           // need to restore the origin list
            temp = next;
        }
        
        return newHead;
    }
}

Using a hashmap to save the <old, new> pairs,

then set next and random link for new created nodes.

O(n) time and space complexity.

public class Solution {
    public RandomListNode copyRandomList(RandomListNode head) {
        // a hashmap to save <oldNode, newNode> pairs
        HashMap<RandomListNode, RandomListNode> map = new HashMap<RandomListNode, RandomListNode>();
        
        // create mapping between new nodes and old nodes
        RandomListNode temp = head;
        while (temp != null) {
            map.put(temp, new RandomListNode(temp.label));
            temp = temp.next;
        }
        
        // link next and random links for new nodes
        // iterate the hashmap 
        for (Map.Entry<RandomListNode, RandomListNode> entry : map.entrySet()) {
            // link next
            entry.getValue().next = map.get(entry.getKey().next);
            // link random
            entry.getValue().random = map.get(entry.getKey().random);
        }
        
        return map.get(head);
    }
}