Leetcode刷题记录 on On My Way https://tuanzi-wow.cn/leetcode%E5%88%B7%E9%A2%98%E8%AE%B0%E5%BD%95/ Recent content in Leetcode刷题记录 on On My Way Hugo zh-CN Sun, 06 Sep 2026 00:00:00 +0800 HOT100 · 普通数组 https://tuanzi-wow.cn/leetcode%E5%88%B7%E9%A2%98%E8%AE%B0%E5%BD%95/hot100/hot100-array/ Sun, 06 Sep 2026 00:00:00 +0800 https://tuanzi-wow.cn/leetcode%E5%88%B7%E9%A2%98%E8%AE%B0%E5%BD%95/hot100/hot100-array/ HOT100 普通数组专题：合并区间、轮转数组、除自身以外数组的乘积与缺失的第一个正数。 1.合并区间

题目描述：

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：

1
2
3

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2：

1
2
3

输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

示例 3：

1
2
3

输入：intervals = [[4,7],[1,4]]
输出：[[1,7]]
解释：区间 [1,4] 和 [4,7] 可被视为重叠区间。

提示：

  • 1 <= intervals.length <= 104
  • intervals[i].length == 2
  • 0 <= starti <= endi <= 104

解1.排序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        intervals.sort(key=lambda x:x[0])

        if len(intervals)==1:
            return intervals
        ans=[]
        ans.append(intervals[0])
        cur=0
        for i in range(1,len(intervals)):
            if intervals[i][0]<=ans[-1][1]:
                ans[-1][1] = max(ans[-1][1], intervals[i][1])
            else:
                ans.append(intervals[i])

        return ans

解2.

通过一个cnt数组记录落位，cnt[i]>1的连续区间即为最终的区间 方法：对于一个区间[start,end]，从cnt[start],cnt[start+1],…,cnt[end]全部加1 缺陷：[1,2],[3,4]本无法合并，按上述方法却可以合并，解决：*2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        mx = max(p[1] for p in intervals)

        diff = [0] * (mx * 2 + 2)
        for start, end in intervals:
            # 把区间 [start*2, end*2] 增加 1
            diff[start * 2] += 1
            diff[end * 2 + 1] -= 1

        ans = []
        sum_d = 0
        start = -1  # -1 表示尚未遇到合并后的区间左端点
        for i, d in enumerate(diff):
            sum_d += d  # 计算 diff 的前缀和
            if sum_d > 0:
                if start < 0:
                    start = i  # 合并后的区间左端点
            elif start >= 0:
                # i-1 是合并后的区间右端点
                # 由于乘 2 操作，区间左右端点都是偶数，所以 i-1 是偶数，i 是奇数，(i-1)/2 == floor(i/2)
                ans.append([start // 2, i // 2])
                start = -1
        # 注：最后一轮循环 sum_d == 0，我们不会漏掉最后一个区间
        return ans

轮转数组

题目描述:

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

示例 1:

1
2
3
4
5
6

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]

示例 2:

1
2
3
4
5

输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释: 
向右轮转 1 步: [99,-1,-100,3]
向右轮转 2 步: [3,99,-1,-100]

提示：

  • 1 <= nums.length <= 105
  • -231 <= nums[i] <= 231 - 1
  • 0 <= k <= 105

题解：自己看，很简单

1
2
3
4
5
6
7
8
9

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        k=k%len(nums)
        p=nums[-k:]
        del nums[-k:]
        nums[0:0]=p

3.除了自身以数组的乘积

题目描述

给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除了 nums[i] 之外其余各元素的乘积 。

题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。

请 **不要使用除法，**且在 O(n) 时间复杂度内完成此题。

示例 1:

1
2

输入: nums = [1,2,3,4]
输出: [24,12,8,6]

示例 2:

1
2

输入: nums = [-1,1,0,-3,3]
输出: [0,0,9,0,0]

题解：

计算前乘积和后乘积，两者相乘即可

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        m = len(nums)
        suf = [1]*m
        for i in range(m-2, -1, -1):
            suf[i] = suf[i+1]*nums[i+1]
        
        per = 1
        for i, num in enumerate(nums):
            suf[i] *= per
            per *= num
        return suf
        #time O(m)
        #space O(1)

4.Hard 缺失的第一个正数

题目描述：

给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。

请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。

示例 1：

1
2
3

输入：nums = [1,2,0]
输出：3
解释：范围 [1,2] 中的数字都在数组中。

示例 2：

1
2
3

输入：nums = [3,4,-1,1]
输出：2
解释：1 在数组中，但 2 没有。

示例 3：

1
2
3

输入：nums = [7,8,9,11,12]
输出：1
解释：最小的正数 1 没有出现。

题解

意识到ans <= len(nums)，然后依次判断i是否in nums即可

1
2
3
4
5
6

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        a=set(nums)
        for i in range(1,len(nums)+2):
            if i not in a:
                return i

还有一个题解我看着很有思路，虽然执行时间更长，但是包含了本地标记的思想，通过hashsize进行本地标记，挺有意思的，我把代码贴上去

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        n = len(nums)
        hash_size = n + 1
        # 可能的答案为1, 2, ..., n + 1
        # 处理掉取值范围外的数
        for i in range(n):
            if nums[i] <= 0 or nums[i] >= hash_size:
                nums[i] = 0
        for i in range(n):
            if nums[i] % hash_size != 0:
                pos = (nums[i] % hash_size) - 1
                # 先取余再加，防止数字过大
                nums[pos] = (nums[pos] % hash_size) + hash_size
        for i in range(n):
            if nums[i] < hash_size:
                return i + 1
        return hash_size
]]> HOT100 · 矩阵 https://tuanzi-wow.cn/leetcode%E5%88%B7%E9%A2%98%E8%AE%B0%E5%BD%95/hot100/hot100-matrix/ Sun, 06 Sep 2026 00:00:00 +0800 https://tuanzi-wow.cn/leetcode%E5%88%B7%E9%A2%98%E8%AE%B0%E5%BD%95/hot100/hot100-matrix/ HOT100 矩阵专题：矩阵置零、螺旋矩阵、旋转图像与搜索二维矩阵。 1.矩阵置零

题目描述

给定一个 *m* x *n* 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法**。**

示例 1：

img

1
2

输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]
输出：[[1,0,1],[0,0,0],[1,0,1]]

示例 2：

img

1
2

输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]

题解：

O(MN):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class Solution:
    def setZeroes(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        m = len(matrix)
        n = len(matrix[0])
        ans = []
        for x in range(m):
            for y in range(n):
                if matrix[x][y] == 0:
                    ans.append((x,y))
        for ele in ans:
            for y in range(n):
                matrix[ele[0]][y] = 0
            for x in range(m):
                matrix[x][ele[1]] = 0

方法二：第一行和列作为标记位：挺简单的，自己看

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

class Solution:
    def setZeroes(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        row = len(matrix)
        col = len(matrix[0])
        row0_flag = False
        col0_flag = False
        # 找第一行是否有0
        for j in range(col):
            if matrix[0][j] == 0:
                row0_flag = True
                break
        # 第一列是否有0
        for i in range(row):
            if matrix[i][0] == 0:
                col0_flag = True
                break

        # 把第一行或者第一列作为 标志位
        for i in range(1, row):
            for j in range(1, col):
                if matrix[i][j] == 0:
                    matrix[i][0] = matrix[0][j] = 0
        #print(matrix)
        # 置0
        for i in range(1, row):
            for j in range(1, col):
                if matrix[i][0] == 0 or matrix[0][j] == 0:
                    matrix[i][j] = 0

        if row0_flag:
            for j in range(col):
                matrix[0][j] = 0
        if col0_flag:
            for i in range(row):
                matrix[i][0] = 0

2.螺旋矩阵

题目描述

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

示例 1：

img

1
2

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]

示例 2：

img

1
2

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

提示：

  • m == matrix.length
  • n == matrix[i].length
  • 1 <= m, n <= 10
  • -100 <= matrix[i][j] <= 100

题解：

我说实话，这道题是目前见过最有意思的了 方向数组，取余转向，m,n = n,m-1这几个都挺有意思的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

DIRS = (0, 1), (1, 0), (0, -1), (-1, 0)  # 右下左上

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        m, n = len(matrix), len(matrix[0])
        size = m * n
        ans = []
        i, j, di = 0, -1, 0  # 从 (0, -1) 开始
        while len(ans) < size:
            dx, dy = DIRS[di]
            for _ in range(n):  # 走 n 步（注意 n 会减少）
                i += dx
                j += dy  # 先走一步
                ans.append(matrix[i][j])  # 再加入答案
            di = (di + 1) % 4  # 右转 90°
            m, n = n, m - 1  # 减少后面的循环次数（步数）
        return ans

3.旋转图像

题目描述：给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

你必须在** 原地** 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。

示例 1：

img

1
2

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[7,4,1],[8,5,2],[9,6,3]]

示例 2：

img

1
2

输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]

题解：

IM SO FUCKING SMART！！！！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        n  = len(matrix)
        ans = [[0] * n for _ in range(n)]
        for i in range(n):
            for j in range(i+1,n):注意这个i+1啊，只交换一半，不然就交换回去了
                matrix[i][j],matrix[j][i] = matrix[j][i],matrix[i][j]
        for row in matrix:
            row.reverse()

4.搜索二维矩阵：

题目描述：

编写一个高效的算法来搜索 *m* x *n* 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：

  • 每行的元素从左到右升序排列。
  • 每列的元素从上到下升序排列。

题解

直接暴力了啊

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        m = len(matrix)
        n = len(matrix[0])
        for x in range(m):
            for y in range(n):
                if matrix[x][y] == target:
                    return True

        return False

或者改进逻辑：从右上角(左下角也可以）开始寻找，小的在左，大的在下，保持单一方向单一逻辑

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        m,n = len(matrix),len(matrix[0])
        row,col = 0,n-1

        while row < m and col >= 0:
            if matrix[row][col] == target:
                return True
            elif matrix[row][col] > target:
                col -= 1
            else:
                row += 1
        return False
]]> HOT100 · 链表 https://tuanzi-wow.cn/leetcode%E5%88%B7%E9%A2%98%E8%AE%B0%E5%BD%95/hot100/hot100-linked-list/ Sun, 06 Sep 2026 00:00:00 +0800 https://tuanzi-wow.cn/leetcode%E5%88%B7%E9%A2%98%E8%AE%B0%E5%BD%95/hot100/hot100-linked-list/ HOT100 链表专题：相交、反转、回文、环形链表等常见题型与解法。 1.相交链表

题目描述：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

图示两个链表在节点 c1 开始相交**：**

img

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

自定义评测：

评测系统 的输入如下（你设计的程序 不适用 此输入）：

  • intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
  • listA - 第一个链表
  • listB - 第二个链表
  • skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
  • skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数

评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。

示例 1：

img

1
2
3
4
5
6

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例 2：

img

1
2
3
4
5

输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

img

1
2
3
4
5

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：No intersection
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

题解：挺有意思的，这样不停循环总有一次会交汇的

1
2
3
4
5
6
7
8

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        pa = headA
        pb = headB
        while pa != pb:
            pa = pa.next if pa else headB
            pb = pb.next if pb else headA
        return pa

2.反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

1
2

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

1
2

输入：head = [1,2]
输出：[2,1]

示例 3：

1
2

输入：head = []
输出：[]

题解:可以说是经典解法了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        pre=None
        cur = head
        
        while cur:
            next_node = cur.next

            cur.next = pre
            pre = cur
            cur = next_node
        return pre

3.回文链表

题目描述

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false

题解：方法都是转化成value判断，看谁写的效率高罢了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        values = []
        cur = head
        cnt = 0
        while cur:
            values.append(cur.val)
            cur = cur.next
            cnt += 1
        for i in range((int)(cnt/2)):
            if values[i] != values[cnt-i-1]:
                return False
        return True

4.环形链表

题目描述

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

题解

1.快慢指针法：顾名思义，我懒得解释

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        slow = head
        fast = head

        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next

            if slow == fast:
                return True
        
        return False

2.嗨嗨嗨，我用集合想不到吧set来了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        cur = head
        visit =set()
        while cur:
            if cur in visit:
                return True
            visit.add(cur)
            cur = cur.next
        return False

5.环形链表2

题目描述

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

题解：还是上面两种

set

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class Solution:
    def detectCycle(self, head):
        visited = set()

        while head:
            if head in visited:
                return head

            visited.add(head)
            head = head.next

        return None

快慢指针：懒得找了，比较经典吧

6.合并两个有序列表

题目描述

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的

题解：虚拟头节点：挺有思想的，值得学习；我当时忘记处理剩下的剩余链表了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class Solution:
    def mergeTwoLists(
        self,
        list1: Optional[ListNode],
        list2: Optional[ListNode]
    ) -> Optional[ListNode]:

        dummy = ListNode()
        cur = dummy

        while list1 and list2:

            if list1.val <= list2.val:
                cur.next = list1
                list1 = list1.next
            else:
                cur.next = list2
                list2 = list2.next

            cur = cur.next

        if list1:
            cur.next = list1
        else:
            cur.next = list2

        return dummy.next

7.again 两数相加

题目描述：

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

题解：

模拟竖式加法，逐位计算两个链表节点的值，加上进位，然后用尾插法把每一位结果连接成新的链表。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        dummy = ListNode()
        cur = dummy
        carry = 0

        while l1 or l2 or carry:
            val1 = l1.val if l1 else 0
            val2 = l2.val if l2 else 0

            total = val1 + val2 + carry

            carry = total // 10
            digit = total % 10

            cur.next = ListNode(digit)
            cur = cur.next

            if l1:
                l1 = l1.next

            if l2:
                l2 = l2.next

        return dummy.next

8.删除链表倒数第n个节点

题目描述：

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

题解：

依旧快慢指针这一块

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummy  = ListNode(0,head)
        slow,fast = dummy,dummy
        for i in range(n):
            fast = fast.next

        while fast.next:
            fast = fast.next
            slow = slow.next

        slow.next = slow.next.next

        return dummy.next

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

题目描述：

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

题解：

使用虚拟头节点 dummy 和一个前驱指针 pre，每次找到相邻的两个节点进行交换，然后把 pre 移动到交换后的第一个节点（原来的第一个节点），继续处理下一对

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy = ListNode(0, head)
        pre = dummy

        while pre.next and pre.next.next:
            first = pre.next
            second = first.next

            # 交换两个节点
            first.next = second.next
            second.next = first
            pre.next = second

            # 移动到下一组
            pre = first

        return dummy.next

10.K个一组翻转链表

题目描述：

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

题解：

啊，真是一场酣畅淋漓的战斗啊

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

class Solution:
    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:

        dummy = ListNode()
        dummy.next = head

        groupprv = dummy

        while True:

            kth = groupprv

            # 找第 k 个节点
            for _ in range(k):
                kth = kth.next

                if not kth:
                    return dummy.next

            groupnext = kth.next

            # 翻转当前组
            cur = groupprv.next
            tail = groupnext

            while cur != groupnext:
                nxt = cur.next
                cur.next = tail
                tail = cur
                cur = nxt

            # 更新连接关系
            tmp = groupprv.next
            groupprv.next = kth
            groupprv = tmp

11.排序列表

题目描述：

给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。

题解

1.我要暴力了啊：冒泡排序 class Solution: def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]: if not head or not head.next: return head

class Solution:
    def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:
            return head

        # 计算链表长度
        cnt = 0
        cur = head
        while cur:
            cnt += 1
            cur = cur.next

        # 冒泡排序
        for i in range(cnt - 1):
            cur = head

            for j in range(cnt - 1 - i):
                if cur.val > cur.next.val:
                    cur.val, cur.next.val = cur.next.val, cur.val

                cur = cur.next

        return head

2.归并排序 不断把链表从中间拆成两半，直到每个链表只剩一个节点；然后再将两个有序链表不断合并，最终得到完整的有序链表。 递归；归并排序 思路很重要，代码挺简单的，自己看

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

class Solution:
    def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:

        # 只有 0 个或 1 个节点，不需要排序
        if not head or not head.next:
            return head

        # ====================
        # 1. 快慢指针找中点
        # ====================
        slow = head
        fast = head.next

        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next

        # ====================
        # 2. 从中间断开
        # ====================
        mid = slow.next
        slow.next = None

        # ====================
        # 3. 分别排序左右两部分
        # ====================
        left = self.sortList(head)
        right = self.sortList(mid)

        # ====================
        # 4. 合并两个有序链表
        # ====================
        return self.merge(left, right)


    def merge(self, l1, l2):
        dummy = ListNode()
        cur = dummy

        while l1 and l2:

            if l1.val < l2.val:
                cur.next = l1
                l1 = l1.next
            else:
                cur.next = l2
                l2 = l2.next

            cur = cur.next

        # 剩下的直接接上
        if l1:
            cur.next = l1
        else:
            cur.next = l2

        return dummy.next

3.一个为了解题的简单方法，挺没意思的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

class Solution:
    def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:
           return head
        seen = []
        cur = head
        while cur:
            seen.append(cur.val)
            cur = cur.next
        seen.sort()
        cur = head
        for i in seen:
            cur.val = i
            cur = cur.next
        return head

12.合并k个升序列表

题目描述：

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

题解：

不道德的解法1：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        values=[]
        for head in lists:
            while head:
                values.append(head.val)
                head=head.next
        values.sort()
        ptr = ListNode()
        dummy = ListNode()
        dummy.next = ptr
        for x in range(len(values)):
            cur = ListNode(values[x])
            ptr.next = cur
            ptr=cur
        return dummy.next.next

13.LRU缓存

题目描述：

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。

实现 LRUCache 类：

  • LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
  • int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
  • void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

解法：哈希表加双向链表或者你熟悉LinkedHashmap也好做

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

class Node:

    def __init__(self, key=0, value=0):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None


class LRUCache:

    def __init__(self, capacity: int):

        self.capacity = capacity

        # 哈希表
        self.cache = {}

        # 双向链表虚拟头尾
        self.head = Node()
        self.tail = Node()

        self.head.next = self.tail
        self.tail.prev = self.head


    def get(self, key: int) -> int:

        if key not in self.cache:
            return -1

        node = self.cache[key]

        # 最近使用，移动到头部
        self._remove(node)
        self._add_to_head(node)

        return node.value


    def put(self, key: int, value: int) -> None:

        # key 已经存在
        if key in self.cache:

            node = self.cache[key]

            node.value = value

            # 更新后也是最近使用
            self._remove(node)
            self._add_to_head(node)

        else:

            # 创建新节点
            node = Node(key, value)

            self.cache[key] = node

            # 放到头部
            self._add_to_head(node)

            # 超过容量
            if len(self.cache) > self.capacity:

                # 删除尾部节点
                last = self.tail.prev

                self._remove(last)

                del self.cache[last.key]


    def _remove(self, node):

        prev_node = node.prev
        next_node = node.next

        prev_node.next = next_node
        next_node.prev = prev_node


    def _add_to_head(self, node):

        node.prev = self.head
        node.next = self.head.next

        self.head.next.prev = node
        self.head.next = node
]]> HOT100 · 二叉树 https://tuanzi-wow.cn/leetcode%E5%88%B7%E9%A2%98%E8%AE%B0%E5%BD%95/hot100/hot100-binary-tree/ Sun, 06 Sep 2026 00:00:00 +0800 https://tuanzi-wow.cn/leetcode%E5%88%B7%E9%A2%98%E8%AE%B0%E5%BD%95/hot100/hot100-binary-tree/ HOT100 二叉树专题：遍历、深度、翻转、最近公共祖先等常见题型与解法。 1.二叉树的中序遍历： 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    global ans = []
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
            if not root:
                return []
            
            self.inorderTraversal(root.left)
            ans.append(root.val)
            self.inorderTraversal(root.right)
            return ans

2.二叉树的最大深度：

递递的归

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if root == None:
            return 0
        l= self.maxDepth(root.left)
        r = self.maxDepth(root.right)
        return max(l,r)+1

3.翻转二叉树：

依旧递递的归：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
            def invert(node):
                if not node:
                    return
                node.left,node.right = node.right,node.left
                invert(node.left)
                invert(node.right)
            invert(root)
            return root

4.对称二叉树

依旧递递的归

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
      
        def isduichen(lnode,rnode)->bool:
            if not lnode and not rnode:
                return True
            if not (lnode and rnode):
                return False
            if lnode.val != rnode.val or lnode.val != rnode.val:
                return False
            return isduichen(lnode.left,rnode.right) and isduichen(lnode.right,rnode.left)
        if not root:
            return True
        return isduichen(root.left,root.right)

5.树的直径

算各个结点的左右深度之和并维持一个最大值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def diameterOfBinaryTree(self, root: TreeNode) -> int:
        self.ans = 1
        def depth(root):
            if not root: return 0
            L = depth(root.left)
            R = depth(root.right)
            self.ans = max(self.ans, L + R + 1)
            return max(L, R) + 1
        depth(root)
        return self.ans - 1

6.二叉树的层序遍历

题目描述：

给你二叉树的根节点 root ，返回其节点值的 层序遍历

题解：

使用队列辅助

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

from collections import deque


class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        ans = []
        queue = deque([root])
        while queue:
            level = []
            # 当前层有多少个节点
            size = len(queue)
            # 只处理当前层的节点
            for _ in range(size):
                node = queue.popleft()
                level.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            ans.append(level)
        return ans

7.将有序数组转换为二叉搜索树

题目描述：

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 平衡 二叉搜索树

题解：

还是递归,我没招了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        def build(left, right):
            if left > right:
                return None

            mid = (left + right) // 2

            root = TreeNode(nums[mid])

            root.left = build(left, mid - 1)
            root.right = build(mid + 1, right)

            return root

        return build(0, len(nums) - 1)

8.验证二叉搜索树:

题目描述:

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

  • 节点的左子树只包含 严格小于 当前节点的数。
  • 节点的右子树只包含 严格大于 当前节点的数。
  • 所有左子树和右子树自身必须也是二叉搜索树。

题解:

依旧递递的归 要注意的是:不能只比较父节点和直接子节点,要为每个节点设置一个范围(我第一遍就错在这了)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isValidBST(self, root: Optional[TreeNode],left = -inf,right = inf) -> bool:
        if not root:
            return True
        return left < root.val < right and self.isValidBST(root.left,left,root.val) and self.isValidBST(root.right,root.val,right)

9.二叉搜索树中第K小的元素:

题目描述:

给定一个二叉搜索树的根节点 root ，和一个整数 k ，请你设计一个算法查找其中第 k 小的元素（k 从 1 开始计数）。

题解: 我的第一想法:遍历并排序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
        values = []
        def visit(node):
            if not node:
                return
            values.append(node.val)
            visit(node.left)
            visit(node.right)
        visit(root)
        values.sort()
        return values[k-1]

经典解法:中序遍历加技术: BST的中序遍历是从小到大排序的,这个是迭代版本的,实质就是写中序遍历的过程,挺简单的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class Solution:
    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
        stack = []
        cur = root

        while True:
            while cur:
                stack.append(cur)
                cur = cur.left

            cur = stack.pop()

            k -= 1
            if k == 0:
                return cur.val

            cur = cur.right

10.二叉树的右视图:

题目描述:

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

题解:

超绝队列配合层序遍历:结果就是层序遍历的每一层的最后一个值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        quene = deque([root])
        ans = []
        while quene:
            level = []
            for _ in range(len(quene)):
                node = quene.popleft()
                if node.left:
                    quene.append(node.left)
                if node.right:
                    quene.append(node.right)
                level.append(node.val)
            ans.append(level[-1])
        return ans

11.二叉树展开为链表:

题目描述:

给你二叉树的根结点 root ，请你将它展开为一个单链表：

  • 展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。
  • 展开后的单链表应该与二叉树 先序遍历 顺序相同。

题解:

找左子树的最右节点,并把原本的右子树接到那里

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

class Solution:
    def flatten(self, root: Optional[TreeNode]) -> None:
        cur = root

        while cur:
            if cur.left:
                # 找左子树最右边的节点
                pre = cur.left
                while pre.right:
                    pre = pre.right

                # 原来的右子树接到这里
                pre.right = cur.right

                # 左子树搬到右边
                cur.right = cur.left
                cur.left = None

            cur = cur.right

12.从前序与中序遍历构造二叉树(考408的来了,你们聊)

题目描述:

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

题解:

思路:从先序遍历里面找到根节点,然后在中序遍历里面找到该节点,然后左边为其左子树,右边是其右子树,迭代或者递归进行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:

        if not preorder:
            return None

        # 1. preorder 第一个节点是根
        root_val = preorder[0]
        root = TreeNode(root_val)

        # 2. 在 inorder 中找到根的位置
        index = inorder.index(root_val)

        # 3. 划分左右子树
        left_inorder = inorder[:index]
        right_inorder = inorder[index + 1:]

        # 左子树节点数量
        left_size = len(left_inorder)

        # 4. 递归构建左右子树
        root.left = self.buildTree(
            preorder[1:left_size + 1],
            left_inorder
        )

        root.right = self.buildTree(
            preorder[left_size + 1:],
            right_inorder
        )

        return root

13.路径总和:

题目描述:

给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的 路径 的数目。

路径 不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

题解:

暂留:

14.二叉树的最近公共祖先

题目描述:

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

题解:

]]>