leetcode hot100 138. 随机链表的复制 medium

普通的链表拷贝只需要处理 next 指针，顺着头往后走就行了。

但这道题多了一个 random 指针，它可能指向链表中的任何一个节点（可以是它自己，或者它前面的节点）。

普通指针 (next)：像是一条直线，复印完第一个点，再复印第二个点。
随机指针 (random)：复印节点 A，指向节点 Z。但此时，还没复印到节点 Z ，A 不知道往哪儿指。

拼接与拆分法（空间复杂度 O ( 1 ) O(1) O(1)）

第一步：复制并插入节点
遍历原链表，把每个新创建的节点 copy 插入到原节点 curr 和 curr.next 之间
变化：A -> B -> C 变成 A -> A' -> B -> B' -> C -> C'。
第二步：复制随机指针 (random)
此时 A'.random 应该指向 A.random.next（也就是 random 指向的那个节点的复本）。
逻辑：curr.next.random = curr.random.next
即：原件的分身 (curr.next) 的传送门 (random)，应该指向原件传送门 (curr.random) 所通往的那个人的分身 (.next)
即：新链表节点的传送门，指向原件传送门的分身（新链表）
第三步：拆分链表
把这个交织在一起的长链表拆分成两个独立的链表：恢复原链表，并提取出克隆链表。

python 复制代码

A -> A' -> B -> B' -> C -> C'

假设原件 A 的 random 指向了 C

我们的目标是让复本 A' 的 random 指向 C 的复本 C'。

python 复制代码

[[7,null],[13,0]...]

7 是值
null 表示它的 random 指针指向空。
0 表示它的 random 指针指向索引为 0 的节点（即头节点）

python 复制代码

# 如果原件的 random 指向 None，那就不用管了（新件默认也是 
if curr.random:  None）
    curr.next.random = curr.random.next

原链表每个节点有两个指针，next 和 random

复制的节点建立 next 和 random 后

拆分长链表时，用next重组旧链表和新链表

python 复制代码

"""
# Definition for a Node.
class Node:
    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
        self.val = int(x)
        self.next = next
        self.random = random
"""

class Solution:
    def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
        if not head:
            return None

        # --- 第一步：复制节点并插入 ---
        cur = head
        while cur:
            newcur = Node(cur.val)
            newcur.next = cur.next
            cur.next = newcur
            #移动cur
            cur = cur.next.next

        # --- 第二步：设置复制节点的 random 指针 ---
        cur = head
        while cur:
            if cur.random:   # 非空random指针
                cur.next.random = cur.random.next
            #移动cur
            cur = cur.next.next
        
        # --- 第三步：拆分链表 ---
        cur = head
        copy_head = head.next
        while cur:

            # cur已确认非空
            copy_cur = cur.next

            # 恢复原链表的 next 关系
            cur.next = cur.next.next

            # 原链表 cur.next 已恢复
            # 建立新链表的 next 关系
            if cur.next :  # next 非空
                copy_cur.next = copy_cur.next.next

            #移动cur
            cur = cur.next

        return copy_head

时间复杂度： O ( n ) O(n) O(n)

对链表进行了三次完整的遍历，总时间与节点数成正比。
空间复杂度： O ( 1 ) O(1) O(1)

创建了 n n n 个新节点，但这些是题目要求的返回结果，不计入算法的"额外空间复杂度"。在整个过程中，没有使用哈希表等数据结构，仅使用了几个指针变量