Leetcode:138、复制带随机指针的链表

138、复制带随机指针的链表
方法一：回溯法
详解见LC题解：记录下代码

"""
# Definition for a Node.
class Node:
    def __init__(self, val, next, random):
        self.val = val
        self.next = next
        self.random = random
"""
class Solution:
    def __init__(self):
        self.visitedHash = {}
    def copyRandomList(self, head: 'Node') -> 'Node':
        if head == None:
            return None
        if head in self.visitedHash:
            return self.visitedHash[head]
        node = Node(head.val,None,None)
        self.visitedHash[head] = node
        node.next = self.copyRandomList(head.next)
        node.random = self.copyRandomList(head.random)
        return node
        

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

时间复杂度：O(N)O(N) 。
空间复杂度：O(N)O(N) 。

"""
# Definition for a Node.
class Node:
    def __init__(self, val, next, random):
        self.val = val
        self.next = next
        self.random = random
"""
class Solution:
    def __init__(self):
        self.visited = {}
        
    def getCloneNode(self,node):
        if node:
            if node in self.visited:
                return self.visited[node]
            else:
                self.visited[node] = Node(node.val,None,None)
                return self.visited[node]
        return None
        
    def copyRandomList(self, head: 'Node') -> 'Node':
        if not head:
            return head
        old_node = head
        new_node = Node(old_node.val,None,None)
        self.visited[old_node] = new_node
        while old_node != None:
            new_node.random = self.getCloneNode(old_node.random)
            new_node.next = self.getCloneNode(old_node.next)
            old_node = old_node.next
            new_node = new_node.next
        return self.visited[head]
        

方法三：
时间复杂度：O(N)O(N)
空间复杂度：O(1)O(1)

"""
# Definition for a Node.
class Node:
    def __init__(self, val, next, random):
        self.val = val
        self.next = next
        self.random = random
"""
class Solution:
        
    def copyRandomList(self, head: 'Node') -> 'Node':
        if not head:
            return head
        ptr = head
        while ptr:
            new_node = Node(ptr.val,None,None)
            new_node.next = ptr.next
            ptr.next = new_node
            ptr = new_node.next
        ptr = head
        while ptr:
            ptr.next.random = ptr.random.next if ptr.random else None
            ptr = ptr.next.next
        ptr_old_list = head
        ptr_new_list = head.next
        head_old = head.next
        while ptr_old_list:
            ptr_old_list.next = ptr_old_list.next.next
            ptr_new_list.next = ptr_new_list.next.next if ptr_new_list.next else None
            ptr_old_list = ptr_old_list.next
            ptr_new_list = ptr_new_list.next
        return head_old
        

极致之处有神明