copy list with random pointer

最新推荐文章于 2026-01-08 21:36:59 发布

转载最新推荐文章于 2026-01-08 21:36:59 发布 · 519 阅读

文章标签：

#leetcode

数据结构与算法专栏收录该内容

14 篇文章

订阅专栏

本文详细介绍了如何深拷贝一个包含随机指针的链表，通过巧妙的算法，实现时间复杂度为O(N)且空间复杂度为O(1)的高效解决方案。具体步骤分为构建新节点的随机指针和恢复原始链表及构建新链表两部分。

A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.

Return a deep copy of the list.

解法：

算法很巧妙，不用保存原始链表的映射关系，构建新节点时，指针做如下变化，即把新节点插入到相应的旧节点后面：

同理分两步

1、构建新节点random指针：new1->random = old1->random->next, new2-random = NULL, new3-random = NULL, new4->random = old4->random->next

2、恢复原始链表以及构建新链表：例如old1->next = old1->next->next, new1->next = new1->next->next

该算法时间复杂度O(N)，空间复杂度O(1)

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

晨曦寒水

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

Leetcode 每日一题：Copy List with Random Pointer

2401_85421495的博客

09-06

1300

Google 高频面试题：Leetcode 139：Copy List with random Pointer 题目详解

8.13 哈希表中等 128 Longest Consecutive Sequence 138 Copy List with Random Pointer

emmm_Yeah的博客

08-13

523

128 最长连续序列 unordered_map和unordered_set的选取 138 随即链表的复制难点在于对深复制的理解 hash表用于新旧节点的映射

参与评论您还未登录，请先登录后发表或查看评论

138. Copy List with Random Pointer

weixin_41554427的博客

05-21

600

问题的关键是，random指针指向的是原链表的结点，这个原链表的结点对应哪一个新链表的结点呢？有两种办法。一是用哈希表。另一种是复制原链表的每一个结点，并将新结点接在原结点的后面组成一个长度加倍的链表，这样原结点的直接后继就是该原结点对应的新结点。

Copy List with Random Pointer

梧桐客栈

01-23

246

题目链接：https://leetcode.com/problems/copy-list-with-random-pointer/ 这道题目比较经典，头条等多个大厂都考过，《剑指offer》中也有。基础解法创建新链表，先拷贝基础信息，再拷贝random指针。 func copyRandomList(head *Node) *Node { p := head var dummyHead Node pHead := &dummyHead // 存储新旧节点的映射 mp := make

#138. Copy List with Random Pointer

YY_Tina的博客

09-14

202

Description A linked list of length n is given such that each node contains an additional random pointer, which could point to any node in the list, or null. Construct a deep copy of the list. The deep copy should consist of exactly n brand new nodes, wher

leetcode_138 Copy List with Random Pointer

没有最好，只有更好！

05-28

1190

题目分析：给定一个特殊的单链表，链表的每一个节点多了一个随机指针域，随机指向链表中的某一个节点。要求复制这个链表解题思路：1）复制节点，并将拷贝后的节点插入到原节点的后面；2）更新所有复制的节点的random节点，即：h.next.random = h.random.next；3）将原链表与复制的链表断开。补充：也可以利用map来保存random节点之间的关系，通过递归或非递归来实现。实现程序C

leetcode138. Copy List with Random Pointer

欲买桂花同载酒

01-16

322

题目：题目链接思路：深度拷贝。有递归和迭代两种方式方法一递归参考：官方题解 class Solution { public: unordered_map<Node*, Node*> cachedNode; Node* copyRandomList(Node* head) { if (head == nullptr) { return nullptr; } if (!cachedNode.count(head)) {//不重复创建结点 Node* headNe

leetcode——138. Copy List with Random Pointer

errly_liu2828的博客

08-28

154

描述 A linked list of length n is given such that each node contains an additional random pointer, which could point to any node in the list, or null. Construct a deep copy of the list. The deep copy should consist of exactly n brand new nodes, where each ne

[leetcode] 138. Copy List with Random Pointer @ python

闲庭信步

03-03

320

原题 https://leetcode.com/problems/copy-list-with-random-pointer/ 解法字典. 使用字典d, d的键是原节点, 值是复制的节点, 遍历链表两次, 第一次遍历是构造字典的键值对, 第二次遍历时, 将原节点的next和random复制到新节点中. Time: O(2*n) Space: O(n) 代码 """ # Definition fo...

138_Copy List with Random Pointer

Kevin__Mei的博客

07-23

195

题目 A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null. Return a deep copy of the list. Example 1: Input: {“KaTeX parse ...

105. Copy List with Random Pointer

Zahb44856的博客

01-21

210

35. Reverse Linked List Description: A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null. Return a deep copy of the list....

python-leetcode题解之138-Copy-List-with-Random-Pointer

09-06

其中，138号题目“Copy List with Random Pointer”是一个关于链表操作的经典问题。该问题要求实现一个函数，用来复制一个包含随机指针的链表。随机指针是除了每个节点都有的next指针指向下一个节点外，还有一个额外...

LeetCode——138. 复制带随机指针的链表(Copy List with Random Pointer)[中等]——分析及代码（Java）

江南土豆的博客

07-22

335

LeetCode——138. 复制带随机指针的链表[Copy List with Random Pointer][中等]——分析及代码[Java]一、题目二、分析及代码1. 递归 + 哈希表（1）思路（2）代码（3）结果2. 节点拆分（1）思路（2）代码（3）结果三、其他一、题目给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。构造这个链表的深拷贝。深拷贝应该正好由 n 个全新节点组成，其中每个新节点的值

【LeetCode 面试经典150题】138. Copy List with Random Pointer 随机链表的复制

qq_43513394的博客

01-12

960

val。

#leetcode#

wnaan的博客

01-04

804

/ k=1 → 边长k+1=2；// 例如 num=4，i=2 → num/i=2，i与num/i相等，仅算1个因数。// 原理：因数成对出现 → 若i是num的因数，则num/i一定也是num的因数。// ✅ 内层循环：逐列填充当前行的元素，列号j从0到i（第i行有i+1个元素）// ✅ 核心返回：当前节点的最小深度 = 子树最小深度 + 当前节点（+1）// 新增行：i+k行，j~j+k-1列；// ✅ 核心枚举：遍历1到√num，找num的所有正因数（平方根枚举法）

leetcode算法（144.二叉树的前序遍历）

m0_61706299的博客

01-05

456

leetcode算法（144.二叉树的前序遍历）

【剑斩OFFER】算法的暴力美学——力扣 844 题：比较含退格的字符串

最新发布

就业知识博客

01-08

105

力扣 844 题：比较含退格的字符串

leetCode-热题100-贪心合集（JavaScript)

qq_50694225的博客

01-08

我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是。返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回。设计一个算法来计算你所能获取的最大利润。数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个下标，如果可以，返回。向后跳转的最大长度。换句话说，如果你在索引。返回一个表示每个字符串片段的长度的列表。处，你可以跳转到任意。给你一个非负整数数组。初始位置在下标 0。

Leetcode—77. 组合【中等】

Atticus的博客

01-08

本文介绍了LeetCode第77题"组合"的Go语言解法。通过回溯算法实现从1到n的数字中选择k个数的所有组合，使用深度优先搜索(DFS)递归遍历所有可能情况。当路径长度等于k时保存当前组合结果，通过剪枝避免重复计算。代码简洁高效，运行结果正确展示了所有可能的组合情况。文章还包含题目图示和运行结果截图，作者表示将持续更新算法题解内容。

Next pointer of node with label 13 from the original list was modified.

05-09

<think>好的，用户的问题是关于链表节点标签13的next指针在原始链表中被修改的解决方案。首先，我需要理解用户提到的具体问题。根据引用[4]中的描述，处理链表复制时，原链表尾节点的next指针需要单独设置为null，否则会报错。用户现在遇到类似的问题，但节点标签是13，可能是在处理链表复制或其他操作时，原链表的节点13的next指针被意外修改了。接下来，我需要参考用户提供的引用内容。引用[4]中的解决方案分为三步：复制节点、设置random指针、拆分链表。在拆分过程中，原链表的节点next指针被修改，但最终需要恢复原链表的next指针，或者确保新链表正确分离。例如，在拆分时，原链表的每个节点的next应该指向原来的下一个节点，而新链表的节点则指向复制的节点。如果在这个过程中没有正确处理，可能导致原链表的节点next指针错误，比如标签13的节点的next被修改了。可能的错误原因有几个方面：首先，在拆分链表时，可能没有正确恢复原链表的next指针，尤其是在处理到最后一个节点时，如引用[4]提到的需要将pre.next设为null。其次，可能在循环拆分过程中，某个步骤处理不当，导致原链表节点的next指向了新链表的节点，而非原链表的下一个节点。例如，当处理到标签13的节点时，如果在拆分时没有正确跳过复制的节点，就会导致原链表的结构被破坏。解决方案方面，引用[4]中的代码在拆分后，将原链表的尾节点的next设置为null，这可能是为了确保原链表的结构正确。但用户的问题可能出现在中间节点，比如标签13的节点，因此需要检查拆分过程中的循环逻辑是否正确处理了所有节点，尤其是当原链表的节点后面跟着复制节点时，必须正确地将原节点的next指向原链表的下一个节点，而不是复制节点。例如，在拆分循环中，原链表节点pre的next应该指向pre.next.next（即原链表的下一个节点），而新链表节点cur的next指向cur.next.next。如果在处理到标签13的节点时，循环没有正确执行这一步，就会导致next指针错误。另外，可能还需要考虑边界情况，比如链表只有一个节点，或者要处理的节点是头节点或尾节点。例如，如果标签13的节点是原链表的尾节点，那么在拆分时可能需要像引用[4]那样单独处理，将pre.next设为null。但如果是中间节点，则需要在循环中正确更新pre和cur的next指针。总结可能的解决步骤：1. 确保在拆分链表时，每一步都正确恢复原链表节点的next指针。2. 检查循环逻辑，尤其是处理到标签13的节点时，是否正确地跳过了复制的节点。3. 处理尾节点时，单独将原链表尾节点的next设为null，如引用[4]中的做法。4. 验证原链表在操作后的完整性，确保每个节点的next指针没有被错误修改。此外，用户可能需要具体的代码示例来展示如何正确拆分链表，同时保持原链表的结构。根据引用[4]的代码，拆分部分的循环应该正确地将原链表和新链表分离，通过pre和cur指针分别处理原链表和新链表的next指针。如果在处理到标签13的节点时出现错误，可能需要检查循环条件是否正确，例如cur.next是否为null，或者在更新指针时是否遗漏了某个步骤。最后，生成相关问题需要考虑用户可能进一步的问题，比如如何验证链表结构、其他常见错误或优化方法等。</think>### 链表节点标签13的next指针被修改的解决方案当链表操作中遇到“Next pointer of node with label 13 modified in original list”报错时，通常是因为**在复制或修改链表时未正确恢复原链表的节点指针**，导致原链表结构被破坏。以下是具体原因和解决方案： --- #### 1. 问题原因分析 - **指针未恢复**：在带有复制的操作中（如复制带随机指针的链表），拆分新旧链表时，原链表的`next`指针可能被错误地指向新链表的节点。例如，标签13的原节点`next`可能未指向原链表的下一个节点，而是指向了复制节点。 - **尾节点未处理**：若标签13是原链表的尾节点，拆分后未显式设置其`next`为`null`，可能导致原链表尾指针残留引用[^4]。 --- #### 2. 解决方案 ##### 方法1：严格拆分新旧链表（参考引用[4]）在复制链表后，通过三次遍历确保原链表和新链表完全分离： 1. **复制节点**：将新节点插入原节点之后，形成`原节点 -> 新节点 -> 原下一节点`的结构。 2. **设置随机指针**：根据原节点的`random`指针，更新新节点的`random`。 3. **拆分链表**：遍历链表，恢复原链表指针并提取新链表。 ```java // 以Java示例（基于引用[4]） public Node copyRandomList(Node head) { if (head == null) return null; Node cur = head; // 1. 复制节点 while (cur != null) { Node copy = new Node(cur.val); copy.next = cur.next; cur.next = copy; cur = copy.next; } // 2. 设置random指针 cur = head; while (cur != null) { if (cur.random != null) { cur.next.random = cur.random.next; } cur = cur.next.next; } // 3. 拆分链表 cur = head.next; Node pre = head, res = head.next; while (cur.next != null) { pre.next = pre.next.next; // 恢复原链表指针 cur.next = cur.next.next; // 构建新链表指针 pre = pre.next; cur = cur.next; } pre.next = null; // 单独处理原链表尾节点 return res; } ``` **关键点**： - **拆分时恢复原链表**：在第三步循环中，`pre`指针始终指向原链表的节点，通过`pre.next = pre.next.next`跳过复制节点，恢复原链表的`next`指针[^4]。 - **尾节点处理**：显式设置原链表尾节点的`next`为`null`，避免残留引用。 --- ##### 方法2：哈希表辅助（空间换时间）若允许使用额外空间，可通过哈希表记录原节点到复制节点的映射，避免修改原链表： ```java public Node copyRandomList(Node head) { Map<Node, Node> map = new HashMap<>(); Node cur = head; while (cur != null) { map.put(cur, new Node(cur.val)); cur = cur.next; } cur = head; while (cur != null) { Node copy = map.get(cur); copy.next = map.get(cur.next); copy.random = map.get(cur.random); cur = cur.next; } return map.get(head); } ``` **优点**：无需修改原链表，彻底避免指针错误。 --- #### 3. 验证原链表完整性操作后，遍历原链表并检查每个节点的`next`指针是否指向正确的原链表节点。例如，标签13的节点应满足： ```java // 假设原链表为1 -> 2 -> ... -> 13 -> 14 -> null Node node13 = head; for (int i = 1; i < 13; i++) node13 = node13.next; assert node13.next.val == 14; // 确保未被修改为复制节点 ``` ---