剑指offer-复杂链表的复制-Python

题目描述：

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

题目描述：

在不用辅助空间的情况下实现 O(n) 的时间效率。

1. 复制原始链表的每个节点N，创建N’ , 然后把这些创建出来节点连接在 N 的后面

2. 设置复制出来的节点的 self.random
   假设原始链表的N的 self.random 指向节点S，那么对应复制出来的 N’ 是 N 的 self.next 节点，同样 S’ 也是 S 的 self.next 指向的节点。

3. 把这个长链表 拆分成 两个链表。奇数位置连接起来就是原始链表，偶数位置连接就是复制链表。

实现：

# -*- coding:utf-8 -*-
# class RandomListNode:
#     def __init__(self, x):
#         self.label = x
#         self.next = None
#         self.random = None
class Solution:
    # 返回 RandomListNode
    def Clone(self, pHead):
        # write code here
        if pHead == None:
            return None
        self.CloneNodes(pHead)    #复制链表的每个结点，将复制的节点链接在原始节点的后面
        self.ConnectRandomNodes(pHead)
        return self.ReconnectNodes(pHead)
    
    def CloneNodes(self, pHead):
        pNode = pHead
        while pNode:
            pCloned = RandomListNode(0)
            pCloned.label = pNode.label
            pCloned.next = pNode.next
            pCloned.random = pNode.random
            
            pNode.next = pCloned
            pNode = pCloned.next
    
    def ConnectRandomNodes(self, pHead):
        pNode = pHead
        while pNode:
            pCloned = pNode.next
            if pNode.random != None:
                pCloned.random = pNode.random.next
            pNode = pCloned.next

    def ReconnectNodes(self, pHead):
        pNode = pHead
        pClonedHead = pClonedNode = pNode.next
        pNode.next = pClonedHead.next
        pNode = pNode.next
        
        while pNode:
            pClonedNode.next = pNode.next
            pClonedNode = pClonedNode.next
            
            pNode.next = pClonedNode.next
            pNode = pNode.next
        return pClonedHead

node1 = RandomListNode(1)
node2 = RandomListNode(3)
node3 = RandomListNode(5)
node1.next = node2
node2.next = node3
node1.random = node3

S = Solution()
clonedNode = S.Clone(node1)
print(clonedNode.random.label)