LeetCode Hot100 刷题笔记（3）—— 链表

原创 已于 2025-07-27 16:27:05 修改 · 1.1k 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#笔记 #leetcode #hot100

于 2025-04-06 13:34:48 首次发布

目录

前言

1. 相交链表

2. 反转链表

3. 回文链表

4. 环形链表

5. 环形链表 II

6. 合并两个有序链表

7. 两数相加

8. 删除链表的倒数第 N 个结点

9. 两两交换链表中的节点

10. K 个一组翻转链表

11. 随机链表的复制

12. 排序链表

13. 合并 K 个升序链表

14. LRU 缓存

前言

一、链表：相交链表，反转链表，回文链表，环形链表，环形链表 II，合并两个有序链表，两数相加，删除链表的倒数第 N 个结点，两两交换链表中的节点，K 个一组翻转链表，随机链表的复制，排序链表，合并 K 个升序链表，LRU 缓存。

*** Trick：本质将链表转为list，再在list上进行操作，最后转回链表。

*** Trick 通用模版：

class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution(object):
    def Operation(self, head):
        if not head:
            return None
        lst = []
        while head:
            lst.append(head.val)
            head = head.next
        """
        系列操作
        """
        head_new = ListNode(int(lst[0]))
        curr = head_new
        for v in lst[1:]:
            curr.next = ListNode(int(v))
            curr = curr.next
        return head_new

1. 相交链表

原题链接：160. 相交链表 - 力扣（LeetCode）

"""
# 相交链表构造
listA, listB = [4,1,8,4,5], [5,6,1,8,4,5]
skipA, skipB = 2, 3

common_tail = ListNode(listA[skipA])
curr_tail = common_tail
for v in listA[skipA:]:
    curr_tail.next = ListNode(v)
    curr_tail = curr_tail.next

headA = ListNode(listA[0])
curra = headA
for v in listA[1:skipA]:
    curra.next = ListNode(v)
    curra = curra.next
curra.next = common_tail

headB = ListNode(listB[0])
currb = headB
for v in listB[1:skipB]:
    currb.next = ListNode(v)
    currb = currb.next
currb.next = common_tail
"""
def getIntersectionNode(headA, headB):
    set1 = set()
    while headA:
        set1.add(headA)
        headA = headA.next
    while headB:
        if headB in set1:
            return headB
        headB = headB.next
    return None

2. 反转链表

原题链接：206. 反转链表 - 力扣（LeetCode）

class Solution(object):
    def reverseList(self, head):
        if not head:
            return None
        lst = []
        while head:
            lst.append(head.val)
            head = head.next
        lst.reverse()

        head_new = ListNode(int(lst[0]))
        curr = head_new
        for v in lst[1:]:
            curr.next = ListNode(int(v))
            curr = curr.next
        return head_new

3. 回文链表

原题链接：234. 回文链表 - 力扣（LeetCode）

class Solution(object):
    def isPalindrome(self, head):
        if not head:
            return None
        lst = []
        while head:
            lst.append(head.val)
            head = head.next
        if lst == lst[::-1]:
            return True
        return False

4. 环形链表

原题链接：141. 环形链表 - 力扣（LeetCode）

"""
# 环形链表构造
lst, pos = [3,2,0,-4], 1
headn = ListNode(lst[0])
curr, nodes= headn, [headn]
for v in lst[1:]:
    curr.next = ListNode(v)
    curr= curr.next
    nodes.append(curr)
if pos >= 0:
    curr.next = nodes[pos]
"""
class Solution(object):
    def hasCycle(self, head):
        if not head:
            return False
        set1 = set()
        while head:
            set1.add(head)
            head = head.next
            if head in set1:
                return True
        return False

5. 环形链表 II

原题链接：142. 环形链表 II - 力扣（LeetCode）

"""
# 环形链表构造
lst, pos = [3,2,0,-4], 1
headn = ListNode(lst[0])
curr, nodes= headn, [headn]
for v in lst[1:]:
    curr.next = ListNode(v)
    curr= curr.next
    nodes.append(curr)
if pos >= 0:
    curr.next = nodes[pos]
"""
class Solution(object):
    def detectCycle(self, head):
        if not head:
            return None
        set1 = set()
        while head:
            set1.add(head)
            head = head.next
            if head in set1:
                return head
        return None

6. 合并两个有序链表

原题链接：21. 合并两个有序链表 - 力扣（LeetCode）

class Solution(object):
    def mergeTwoLists(self, list1, list2):
        if not list1 and not list2:
            return None
        elif not list1:
            return list2
        elif not list2:
            return list1
        else:
            lst1, lst2 = [], []
            while list1:
                lst1.append(list1.val)
                list1 = list1.next
            while list2:
                lst2.append(list2.val)
                list2 = list2.next
            lst = lst1 + lst2
            lst.sort()

            head = ListNode(int(lst[0]))
            curr = head
            for v in lst[1:]:
                curr.next = ListNode(int(v))
                curr = curr.next
            return head

7. 两数相加

原题链接：2. 两数相加 - 力扣（LeetCode）

class Solution(object):
    def addTwoNumbers(self, l1, l2):
        lst1, lst2 = [], []
        while l1:
            lst1.append(l1.val)
            l1 = l1.next
        while l2:
            lst2.append(l2.val)
            l2 = l2.next
        # s1 = ''.join(l1)
        # s2 = ''.join(l2)
        lst1.reverse()
        lst2.reverse()
        s1 = ''.join([str(i) for i in lst1])
        s2 = ''.join([str(i) for i in lst2])
        s3 = int(s1) + int(s2)
        lst3 = list(str(s3))
        lst3.reverse()

        head = ListNode(int(lst3[0]))
        curr = head
        for v in lst3[1:]:
            curr.next = ListNode(int(v))
            curr = curr.next
        return head

8. 删除链表的倒数第 N 个结点

原题链接：19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

class Solution(object):
    def removeNthFromEnd(self, head, n):
        lst = []
        while head:
            lst.append(head.val)
            head = head.next
        del lst[-n]
        if not lst:
            return None
        else:
            head_new = ListNode(lst[0])
            curr = head_new
            for v in lst[1:]:
                curr.next = ListNode(v)
                curr = curr.next
            return head_new

9. 两两交换链表中的节点

原题链接：24. 两两交换链表中的节点 - 力扣（LeetCode）

class Solution(object):
    def swapPairs(self, head):
        if not head:
            return None
        lst = []
        while head:
            lst.append(head.val)
            head = head.next
        for i in range(0, len(lst)-1, 2):
            lst[i], lst[i+1] = lst[i+1], lst[i]
        head_new = ListNode(lst[0])
        curr = head_new
        for value in lst[1:]:
            curr.next = ListNode(value)
            curr = curr.next
        return head_new

10. K 个一组翻转链表

原题链接：25. K 个一组翻转链表 - 力扣（LeetCode）

class Solution(object):
    def reverseKGroup(self, head, k):
        lst = []
        while head:
            lst.append(head.val)
            head = head.next
        for i in range(0, len(lst)-k+1, k):
            lst[i:i+k] = lst[i:i+k][::-1]

        head_new = ListNode(lst[0])
        curr = head_new
        for v in lst[1:]:
            curr.next = ListNode(v)
            curr = curr.next
        return head_new

11. 随机链表的复制

原题链接：138. 随机链表的复制 - 力扣（LeetCode）

class Node:
    def __init__(self, x, next=None, random=None):
        self.val = int(x)
        self.next = next
        self.random = random


class Solution(object):
    def copyRandomList(self, head):
        return copy.deepcopy(head)

12. 排序链表

原题链接：148. 排序链表 - 力扣（LeetCode）

class Solution(object):
    def sortList(self, head):
        if not head:
            return None
        lst = []
        while head:
            lst.append(head.val)
            head = head.next
        lst.sort()
         
        head_new = ListNode(int(lst[0]))
        curr = head_new
        for v in lst[1:]:
            curr.next = ListNode(int(v))
            curr = curr.next
        return head_new

13. 合并 K 个升序链表

原题链接：23. 合并 K 个升序链表 - 力扣（LeetCode）

class Solution(object):
    def mergeKLists(self, lists):
        if not lists:
            return None
        lst1 = []
        for head in lists:
            lst2 = []
            while head:
                lst2.append(head.val)
                head = head.next
            lst1.append(lst2)
        lst1 = sum(lst1, [])  
        if not lst1:
            return None      # lst1 = [[]]

        lst1.sort()
        head_new = ListNode(lst1[0])
        curr = head_new
        for v in lst1[1:]:
            curr.next = ListNode(v)
            curr = curr.next
        return head_new

14. LRU 缓存

原题链接：146. LRU 缓存 - 力扣（LeetCode）

class LRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.record = {}

    def get(self, key: int) -> int:
        val = self.record.get(key, -1)
        if val != -1:
            self.record.pop(key)
            self.record[key] = val
        return val

    def put(self, key: int, value: int) -> None:
        if key in self.record:
            self.record.pop(key)
        self.record[key] = value
        if len(self.record) > self.capacity:
            self.record.pop(next(iter(self.record)))

leetcode hot100与经典150刷题笔记
xiaomu_347的博客
07-10 192
对于当前节点，我们首先要进行拷贝，然后我们进行「当前节点的后继节点」和「当前节点的随机指针指向的节点」拷贝，拷贝完成后将创建的新节点的指针返回，即可完成当前节点的两指针的赋值。每次拓展下一层的时候，不同于广度优先搜索的每次只从队列里拿出一个节点，我们需要将队列里的所有节点都拿出来进行拓展，这样能保证每次拓展完的时候队列里存放的是当前层的所有节点，即我们是一层一层地进行拓展，最后我们用一个变量 ans来维护拓展的次数，该二叉树的最大深度即为 ans。整数数组的下一个排列是指其整数的下一个字典序更大的排列。
LeetCodeHot100(链表篇)
PersonJJ的博客
02-19 1925
帮助大家快速应对大厂算法面试
leetcode——刷题笔记——热门100题
weixin_46934960的博客
03-03 295
2. Add Two Numbers You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list. You may as
LeetCode刷题指南：用C语言征服50道经典算法题
最新发布
星辰夜语的博客
06-27 1144
LeetCode 作为全球知名的算法练习平台，提供了大量经典的算法题目。使用 C 语言刷题，不仅可以加深对算法的理解，还能提升对底层编程的掌握。本指南将带领你用 C 语言征服 50 道经典算法题，为你的技术能力提升助力。
力扣HOT100合集
qq_61504864的博客
10-09 2813
对于当前考虑的元素 nums[i]，如果 dp[ j - nums[ i ] ] 为 true，说明可以用前面的元素构成和为 j -nums[ i ] 的子集，那么在加上当前元素 nums[ i ] 的情况下，就可以构成和为 j 的子集，因此 dp[ j ] 更新为 true。这样left往回走会导致错误的结果。最终得到的结果为[[1, 2, 3], [2, 1, 3], [3, 1, 2], [1, 3, 2], [2, 3, 1], [3, 2, 1]]，即给定数组[1, 2, 3]的全排列结果。
LeetCode刷题总结 - 面试经典 150 题 -持续更新
qq_45464560的博客
07-29 8337
LeetCode刷题总结 - 面试经典 150 题 - 持续更新其他系列数组 / 字符串88. 合并两个有序数组27. 移除元素26. 删除有序数组中的重复项80. 删除有序数组中的重复项 II169. 多数元素189. 轮转数组121. 买卖股票的最佳时机122. 买卖股票的最佳时机 II55. 跳跃游戏274. H 指数380. O(1) 时间插入、删除和获取随机元素238. 除自身以外数组的乘积739. 每日温度42. 接雨水双指针125. 验证回文串392. 判断子序列167. 两数之和 II -
leetcode刷题
qq_53811210的博客
07-05 2921
如果 nums[first] + nums[n-2] + nums[n-1] < 0，由于数组已经排序，nums[first] 加上后面任意两个数都是小于 0 的，所以下面的双指针就不需要跑了。在窗口 X 内因为生气而被赶走的顾客数：使用大小为 X 的滑动窗口，计算滑动窗口内的grumpy[i]==1grumpy[i] == 1grumpy[i]==1时的customers[i]customers[i]customers[i]，得到在滑动窗口内老板生气时对应的顾客数。当我们遇到「目录名」时，就把它放入栈。
leetcode hot100刷题技巧
03-25
### LeetCode Hot100 刷题技巧与策略 LeetCode 的 Hot100 是许多程序员提升算法能力的重要资源之一。以下是针对该部分刷题的一些技巧和策略： #### 1. **制定合理的刷题计划** - 推荐按照一定的顺序进行刷题，...
LeetCode Hot100刷题指南(第3期)
寸铁的博客
07-12 353
LeetCode Hot100刷题指南(第3期)
Leetcode刷题技巧，看这一篇就够了
weixin_41930359的博客
08-01 1747
1.常看Discussion。我相信很多同学为了刷题量，解开一道题后会迫不及待地点开下一道题。更为甚者，很多同学把刷题的数量作为衡量水平的绝对标准，比如“老师，我在Leetcode刷了500题，您看去面Google有希望吗？”，结果该挂还是挂了。但是，你有没有试过思考其他过解决方案? 这里并不只是说在自己的代码上继续优化，而是点开Discussion, 看看其他人有没有其他的思路，并思考他们的解法和你的有什么不同。也就是说，Discussion也是刷题的一部分。同学们往后可以注意这点，注意分析别人的思路，.
LeetCode 热题 HOT 100笔记（简单篇）
qq_39493185的博客
12-15 2367
LeetCode 热题 HOT 100笔记（简单篇）
【LeetCode刷题日记】常用算法基础和理解及运用
qq_41854911的博客
09-09 2825
在我们LeetCode刷题过程中，如果我们只是了解数据结构（数组，链表，数）的使用方法，那我们在面对复杂的题目时，是很难很好的解决问题的，因此我们要了解一些常用算法来帮助我们更好的解题。 递归和迭代 递归 在高级语言中，调用自己和其它函数没有本质的不同。我们把一个直接用自己或通过一系列的调用语句间接地调用自己的函数，称作递归函数。每个递归函数必须至少有一个条件，满足时递归不再执行，即不再引用自身而是返回值退出。 ​ 简单地说，就是如果在函数中存在着调用函数本身的情况，这种现象就叫递归。 递归的两个必要
【LeetCode】刷题技巧
人类所有真实的快乐，一定是恒久的努力
02-28 1300
leetcode 刷题技巧
Leetcode刷题指南
shuaikai的博客
11-18 1458
leetcode刷题过程中总结
LeetCode刷题顺序（新手入门）
falldeep的算法世界
11-06 5020
移动零给定一个数组nums，编写一个函数将所有0移动到数组的末尾，同时保持非零元素的相对顺序。请注意，必须在不复制数组的情况下原地对数组进行操作。难点就是不复制原数组要原地修改，解法为设置一个res，记录前面的0的个数，每次插入时只要插入到nums[i - res]中即可移除元素给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
力扣（LeetCode）怎么刷题，以排序算法为例
热门推荐
Allenzyg的博客
08-06 1万+
掌握 LeetCode 刷题方法再开始刷题，属于磨刀不误砍柴工。掌握正确方法是非常重要的。 如果你在刷题的时候发现怎么也写不出来，别担心，这是正常的。如果你还发现，之前明明刷过的题，过段时间再做的时候，自己还是不会。别担心，这也是正常的。 在这我分享一下我的刷题经验，希望对你有帮助。如果你时间比较紧迫，为了找工作而刷题，我建议你先刷热门推荐，一共两百多道题。 在 LeetCode中文版 页面的右侧。先刷热题 HOT 100，再刷精选 TOP 面试题，之后刷其他的题。 如果你时间比较充裕，那我建议
LeetCode刷题笔记
qq_40088655的博客
10-14 2223
LeetCode刷题笔记！
LeetCode 热题 HOT 100 题解（仅记录解题思路）
a131529的博客
09-17 6178
由于数组中只有一个元素出现一次，其余元素都出现两次，因此用集合中的元素之和的两倍减去数组中的元素之和，剩下的数就是数组中只出现一次的数字。遍历数组中的每个数字，如果集合中没有该数字，则将该数字加入集合，如果集合中已经有该数字，则将该数字从集合中删除，最后剩下的数字就是只出现一次的数字。指针p1在头结点处，指针p2在头结点的next处，然后p1每次移动1格，p2则走2步，若在其中一个进入null之前两者指向同一结点，则代表有环。使用双指针，左指针指向当前已经处理好的序列的尾部，右指针指向待处理序列的头部。
【刷题】LeetCode刷题汇总
full courage的博客
06-17 1225
记录LeetCode力扣刷题，持续更新中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值