leetcode所需python相关api整理

Python 刷 LeetCode时常用的 list 方法

---

1. 列表创建与访问

• 创建：nums = [1, 2, 3]
• 访问单个元素：nums[0]，nums[-1]
• 切片：nums[1:3]，nums[:]，nums[::-1]（逆序）

---

2. 增加元素

• 尾部添加：nums.append(x)
• 任意位置插入：nums.insert(i, x)
• 合并另一个列表：nums.extend([4,5])

---

3. 删除元素

• 删除末尾并返回：nums.pop()
• 删除指定位置：nums.pop(i)
• 删除指定值（第一个出现的）：nums.remove(x)

---

4. 查找与统计

• 查找值下标：nums.index(x)
• 统计某值出现次数：nums.count(x)

---

5. 排序与反转

• 原地排序：nums.sort()
• 返回新排序列表：sorted(nums)
• 原地反转：nums.reverse()
• 返回逆序新列表：nums[::-1]

---

6. 长度和遍历

• 长度：len(nums)
• 遍历：

  for x in nums:
      # do something

---

7. 列表推导式（高频）

• 过滤和变换：[x*x for x in nums if x > 0]

---

8. 常见技巧

• 判断元素是否存在：x in nums
• 列表拼接：nums1 + nums2
• 拷贝列表：nums[:] 或 nums.copy()
• 清空列表：nums.clear()
• 多维列表：matrix = [[0]*n for _ in range(m)] （二维矩阵常用）

---

这些方法覆盖了绝大多数 LeetCode 刷题中的 list 场景，如数组遍历、搜索、排序、滑动窗口、双指针等题型。

Python 刷 LeetCode时常用的元组（tuple）用法

---

1. 创建元组

• 多个元素：t = (a, b)
• 单元素：t = (a,) # 注意逗号

---

2. 常见场景

1）坐标/区间表示

• 用元组表示二维坐标或区间：

  point = (x, y)
  interval = (start, end)

2）哈希表/集合的键

• 元组不可变，可作为字典或集合的键（常用于 visited 集合）：

  visited = set()
  visited.add((x, y))    # 二维坐标去重

3）函数一次返回多个值

def min_max(nums):
    return (min(nums), max(nums))
mi, ma = min_max(arr)

4）遍历时解包

for x, y in points:
    # x, y为元组元素

5）与 enumerate 配合

for i, num in enumerate(nums):
    # i是索引，num是值

---

3. 基本操作

• 访问元素：t[0]
• 解包：a, b = t
• 长度：len(t)
• 遍历：for x in t: ...

---

4. 其他

• 元组不可变，不能增删改
• 可嵌套元组，如 ((x1, y1), (x2, y2))

---

这些用法覆盖了 LeetCode 刷题最常见的元组场景，
如坐标去重、状态记录、批量返回等。

Python 刷 LeetCode时常用的哈希表（dict）API

---

1. 创建哈希表（字典）

• 直接创建：d = {} 或 d = {'a': 1, 'b': 2}
• 用推导式：d = {x: x*x for x in nums}

---

2. 访问和赋值

• 查找键值：d[key]
• 新增或更新：d[key] = value
• 安全查找（不存在返回默认值）：d.get(key, default)
  • 如：d.get('c', 0)，如果’c’不存在则返回0

---

3. 删除操作

• 删除键：del d[key]
• 弹出并返回键值：d.pop(key, default)
  • 如：d.pop('a', 0)，不存在则返回0

---

4. 遍历哈希表

• 遍历所有键：for k in d:
• 遍历所有值：for v in d.values():
• 遍历所有键值对：for k, v in d.items():

---

5. 统计计数（高频）

• 用 collections.Counter 统计元素频次：

  from collections import Counter
  freq = Counter(nums)
  # freq[x] 即 x 的出现次数

---

6. 默认值哈希表（高频）

• 用 collections.defaultdict 自动初始化：

  from collections import defaultdict
  d = defaultdict(int)        # 默认值为0
  d2 = defaultdict(list)      # 默认值为[]
  d[key] += 1                 # 可直接累加计数

---

7. 判断键是否存在

• if key in d:

---

8. 其他常用API

• 键集合：d.keys()
• 值集合：d.values()
• 键值对集合：d.items()
• 获取长度：len(d)

---

9. LeetCode常见题型应用

• 计数统计：如“多数元素”“异位词”等
• 哈希去重：如“存在重复元素”
• 记录索引：如“两数之和”
• 滑动窗口：窗口内元素频次统计
• 状态记录：如“动态规划”状态压缩

---

以上API和技巧覆盖了 LeetCode 刷题哈希表的绝大多数场景，

Python 刷 LeetCode时常用的字符串API

---

1. 创建和访问

• 创建：s = "hello"
• 访问：s[0]，s[-1]，s[1:4]（切片）

---

2. 遍历字符串

for c in s:
    # c是每个字符

---

3. 长度和查找

• 长度：len(s)
• 查找子串：s.find(substr)（找不到返回-1）
• 子串计数：s.count(substr)
• 包含判断：substr in s

---

4. 分割与拼接

• 分割：s.split(sep)（如空格、逗号等）
• 去除首尾空格：s.strip()
• 拼接：' '.join(list_of_str)（用空格连接）

---

5. 替换与修改

• 替换：s.replace(old, new)
• 大小写转换：s.lower()，s.upper()
• 判断字母/数字：s.isalpha()，s.isdigit()

---

6. 反转字符串

s[::-1]

---

7. 排序

''.join(sorted(s))   # 字符排序后组成新字符串

---

8. 字符转数字与数字转字符

• 字符转ASCII：ord(c)
• ASCII转字符：chr(n)

---

9. 常见LeetCode题型场景

• 字符计数：collections.Counter(s)
• 判断回文：s == s[::-1]
• 滑动窗口：用切片分割子串
• 异位词：sorted(s1) == sorted(s2)

---

这些API和技巧覆盖了 LeetCode 字符串处理的高频场景

LeetCode常用数据结构转换（Python）

---

1. 字符串和列表

• 字符串 → 列表（字符列表）

  s = "abcde"
  lst = list(s)       # ['a', 'b', 'c', 'd', 'e']

• 列表 → 字符串

  lst = ['a', 'b', 'c']
  s = ''.join(lst)    # 'abc'

---

2. 列表和集合

• 列表 → 集合（去重/查找快）

  nums = [1, 2, 2, 3]
  st = set(nums)      # {1, 2, 3}

• 集合 → 列表

  st = {1, 2, 3}
  nums = list(st)     # [1, 2, 3]，顺序不保证

---

3. 列表和元组

• 列表 → 元组（不可变）

  nums = [1, 2, 3]
  t = tuple(nums)     # (1, 2, 3)

• 元组 → 列表

  t = (1, 2, 3)
  nums = list(t)      # [1, 2, 3]

---

4. 字符串和集合

• 字符串 → 集合（唯一字符）

  s = "leetcode"
  st = set(s)         # {'l', 'e', 't', 'c', 'o', 'd'}

---

5. 列表和字典（或Counter）

• 列表 → Counter（统计频次，非常高频）

  from collections import Counter
  nums = [1, 2, 2, 3]
  counter = Counter(nums)   # {1:1, 2:2, 3:1}

• 列表 → 字典（如映射索引）

  nums = [10, 20, 30]
  idx_map = {v: i for i, v in enumerate(nums)}  # {10:0, 20:1, 30:2}

---

6. 字典和列表

• 字典 → 键列表

  d = {'a': 1, 'b': 2}
  keys = list(d.keys())     # ['a', 'b']

• 字典 → 值列表

  values = list(d.values()) # [1, 2]

---

7. 其他常用转换

• 二维列表 → 一维列表

  grid = [[1,2],[3,4]]
  flat = [x for row in grid for x in row]   # [1,2,3,4]

• 列表元素类型转换

  nums = ['1', '2', '3']
  int_nums = list(map(int, nums))           # [1, 2, 3]

---

8. 应用场景举例

• 去重：列表 → 集合
• 统计频次：列表/字符串 → Counter
• 索引映射：列表 → 字典
• 判断唯一性：len(set(lst)) == len(lst)
• 恢复字符串：字符列表 → 字符串
• 枚举所有字符：字符串 → 列表/集合

---

这些转换覆盖了 LeetCode 刷题绝大多数高频场景

Python 刷 LeetCode时常用的 range API

---

1. 基本用法

• range(stop)
  从0到stop-1

  for i in range(5):    # i = 0,1,2,3,4

• range(start, stop)
  从start到stop-1

  for i in range(2, 6): # i = 2,3,4,5

• range(start, stop, step)
  从start到stop-1，步长为step

  for i in range(0, 10, 2): # i = 0,2,4,6,8

---

2. 高频场景

• 遍历数组/字符串下标

  for i in range(len(nums)):
      # nums[i]

• 倒序遍历

  for i in range(len(nums)-1, -1, -1):
      # nums[i]

• 枚举区间（如滑动窗口）

  for l in range(0, n - k + 1):
      window = nums[l:l+k]

• 枚举所有二元组/多元组

  for i in range(n):
      for j in range(i+1, n):
          # nums[i], nums[j]

• 生成列表（必须用list()）

  lst = list(range(5))    # [0,1,2,3,4]

---

3. 注意事项

• range 生成的是不可变序列，不是列表，要用 list(range(...)) 转换成列表。
• 支持负步长，常用于倒序。
• 通常搭配 for 使用，也可直接转列表用于索引等。

---

4. LeetCode题型常见用法总结

• 遍历索引、枚举左/右指针、滑动窗口、双指针、枚举排列组合等
• 需要索引时优先用 range(len(...))
• 只遍历元素时推荐直接 for x in ...，如 for x in nums:

---

Python 刷 LeetCode时常用的集合（set）API

---

1. 创建集合

• 空集合：s = set()
• 由列表/字符串创建：s = set([1, 2, 3])，s = set('abc')

---

2. 常用操作

• 添加元素：s.add(x)
• 删除元素：s.remove(x)（如果不存在会报错）
• 安全删除：s.discard(x)（不存在不报错）
• 判断元素是否存在：x in s
• 集合大小：len(s)
• 清空集合：s.clear()

---

3. 高频LeetCode场景

• 去重：

  nums = [1,2,2,3]
  unique = set(nums)   # {1,2,3}

• 哈希去重/快速查找：

  if num in seen:
      # 已经出现过
  seen.add(num)

• 记录访问状态（如BFS/DFS/回溯）：

  visited = set()
  visited.add((x, y))  # 二维坐标

• 集合运算（交集、并集、差集）：

  s1 & s2   # 交集
  s1 | s2   # 并集
  s1 - s2   # 差集

---

4. 遍历集合

for x in s:
    # x是集合中的元素

---

5. 其他

• 集合元素必须是不可变类型（如数字、元组，不能是列表）
• 集合无序，不能索引访问

---

6. 常见题型应用

• 判断是否有重复元素
• 统计唯一元素个数
• 记录已访问节点/状态
• 集合运算做筛选、计数等

---

这些API和技巧覆盖了 LeetCode 刷题绝大多数集合高频场景

Python 刷 LeetCode时常用的 enumerate() 用法

---

1. 基本功能

• enumerate(iterable) 同时遍历元素和其索引（下标）。
• 返回一个迭代器，每次输出 (索引, 元素) 二元组。

---

2. 高频场景

• 遍历列表/字符串时要用下标和元素

  nums = [10, 20, 30]
  for i, x in enumerate(nums):
      # i 是索引（0,1,2），x 是值（10,20,30）

• 遍历二维数组时同时获得行号和行内容

  matrix = [[1,2], [3,4]]
  for i, row in enumerate(matrix):
      # i 是行号，row 是当前行

• 遍历字符串时获得索引和字符

  s = "leetcode"
  for i, c in enumerate(s):
      # i 是位置，c 是字符

---

3. 带起始索引

• enumerate(iterable, start) 可以指定索引起始值

  for i, x in enumerate(nums, 1):
      # i 从 1 开始计数

---

4. LeetCode题型常见应用

• 统计、查找、标记索引
• 与哈希表结合记录元素位置
• 滑动窗口、双指针题型需要用到下标

---

5. 注意事项

• 通常写法为：for i, x in enumerate(序列):
• 比 for i in range(len(nums)) 更简洁、直观
• 适合需要同时用到索引和元素的场景

---

这些用法覆盖了 LeetCode 刷题绝大多数 enumerate() 高频场景

Python 刷 LeetCode时常用的栈（stack）用法

---

1. 栈的基本定义

• 栈是一种**后进先出（LIFO）**的数据结构。
• Python 没有专门的 stack 类型，通常用**列表（list）**实现。

---

2. 创建和基本操作

stack = []        # 创建空栈

stack.append(x)   # 入栈
top = stack.pop() # 出栈（弹出栈顶元素）
peek = stack[-1]  # 取栈顶元素（不弹出）

---

3. 高频LeetCode场景

• 括号匹配、逆序输出、单调栈、最近较大/较小元素等题目
• 递归模拟
• DFS（深度优先搜索）非递归写法

---

4. 单调栈模板

stack = []
for x in arr:
    while stack and x < stack[-1]:
        stack.pop()
    stack.append(x)

• 用于处理“下一个更小/更大元素”问题

---

5. 判断栈空

if not stack:
    # 栈为空

---

6. 其他

• collections.deque 也可以当栈用，但 LeetCode 常用 list
• stack.pop() 若栈为空会抛异常，可用 if stack: 先判断
• 不要用 insert(0, x)/pop(0)，那是队列操作

---

7. 总结

• Python 用 list 实现栈，append 入栈，pop 出栈
• 高频题型：括号、单调栈、DFS等
• 适用于需要逆序处理或回溯的场景

Python 刷 LeetCode时常用的队列（queue）用法

---

1. 队列的基本定义

• 队列是一种**先进先出（FIFO）**的数据结构。
• Python 标准库没有专门的 queue 类型，但常用这两种实现：
  • collections.deque
  • queue.Queue（多线程场景用）

---

2. 用 list 实现队列（不推荐）

q = []
q.append(x)     # 入队（到尾部）
x = q.pop(0)    # 出队（从头部）

• 不推荐：pop(0) 时间复杂度 O(n)，慢！

---

3. 推荐用 deque 实现队列

from collections import deque

q = deque()
q.append(x)     # 入队
x = q.popleft() # 出队

• popleft() 时间复杂度 O(1)，高效！

---

4. 常见LeetCode题型

• BFS（广度优先搜索）模板
• 层序遍历
• 滑动窗口

BFS队列模板

from collections import deque

q = deque()
q.append(start)
visited = set([start])

while q:
    node = q.popleft()
    # 扩展邻居
    for nei in graph[node]:
        if nei not in visited:
            q.append(nei)
            visited.add(nei)

---

5. 其他用法

• len(q) 获取队列长度
• q[0] 获取队首元素，不弹出
• q.clear() 清空队列

---

6. 多线程场景

• 用 queue.Queue 更安全，支持线程同步

from queue import Queue

q = Queue()
q.put(x)      # 入队
x = q.get()   # 出队

---

7. 总结

• 刷题推荐用 collections.deque 实现队列
• append 入队，popleft 出队，O(1)效率
• 高频题型：BFS、层序遍历、滑动窗口

Python any() 及类似的聚合判断API介绍

---

1. any()

• 语法：any(iterable)
• 功能：只要迭代对象里有一个元素为真（bool(x) == True），就返回 True；否则返回 False。
• 刷题场景：判断是否“至少有一个”满足条件。

示例

nums = [0, 1, 0]
print(any(nums))  # True

print(any(x > 10 for x in nums))  # False

---

2. all()

• 语法：all(iterable)
• 功能：迭代对象所有元素都为真（bool(x) == True）时，返回 True；否则返回 False。
• 刷题场景：判断是否“全部”满足条件。

示例

nums = [1, 2, 3]
print(all(nums))  # True

print(all(x > 0 for x in nums))  # True
print(all(x > 2 for x in nums))  # False

---

3. 内置 max(), min(), sum()

虽然不是布尔聚合，但常用于刷题中的“是否存在最大/最小/累加情况”。

• max(iterable): 返回最大值
• min(iterable): 返回最小值
• sum(iterable): 计算总和

配合条件判断

nums = [1, 2, 3]
if max(nums) > 2:
    print("有元素大于2")

---

4. filter()

• 语法：filter(function, iterable)
• 功能：筛选可迭代对象中满足 function 条件的元素。
• 常和 any()/all() 配合判定“是否有满足条件的元素”。

示例

nums = [1, -1, 3, 0]
positive_nums = list(filter(lambda x: x > 0, nums))  # [1, 3]

---

5. 内置 enumerate(), zip()、map()

这些不是布尔聚合，但常用于组合条件判断：

• enumerate(iterable): 获取索引和值
• zip(a, b): 并行遍历
• map(func, iterable): 批量映射

配合 any/all

a = [1, 2, 3]
b = [1, 2, 4]
print(any(x != y for x, y in zip(a, b)))  # True, 判断是否有不相等的元素

---

6. 刷题常见场景举例

• 矩阵是否存在某个值：any(val == target for row in matrix for val in row)
• 全体条件满足：all(x >= 0 for x in nums)
• 是否有重复：any(nums.count(x) > 1 for x in nums) 或更高效用 set

---

7. 其他相关函数

• set(): 去重后判定
• sorted(): 排序后判定

---

8. 总结对比

API	判断逻辑	返回类型
any()	至少有一个为真	bool
all()	全部都为真	bool
filter	返回符合条件的元素	可迭代对象
max/min/sum	聚合值	数值

---

刷题时，any() 用于“存在性”判定，all() 用于“全体性”判定，经常和生成式搭配，写法简洁高效。

Python 的 reduce 用法介绍

reduce 是 Python 中一个用于将序列归约为单一值的高阶函数。它可以对序列中的元素进行累积计算，常用于累加、累乘等场景。

---

1. 基本语法

from functools import reduce

reduce(function, iterable[, initializer])

• function：二元函数（接受两个参数，如 lambda x, y: x + y）
• iterable：可迭代对象（如列表、元组等）
• initializer（可选）：指定初始值

---

2. 工作原理

reduce 会对序列的前两个元素调用函数，将结果与第三个元素继续调用函数，依次进行，直到序列处理完毕。

例如：

from functools import reduce

result = reduce(lambda x, y: x + y, [1, 2, 3, 4])
print(result)  # 输出 10

过程：

• 1 + 2 = 3
• 3 + 3 = 6
• 6 + 4 = 10

---

3. 使用 initializer

如果提供了 initializer，则它会作为第一次运算的左参数：

result = reduce(lambda x, y: x + y, [1, 2, 3], 10)
print(result)  # 输出 16
# 10 + 1 = 11, 11 + 2 = 13, 13 + 3 = 16

---

4. 常见用途示例

累乘

from functools import reduce
result = reduce(lambda x, y: x * y, [1, 2, 3, 4])
print(result)  # 输出 24

拼接字符串

reduce(lambda x, y: x + y, ['a', 'b', 'c'])  # 输出 'abc'

求最大值

reduce(lambda x, y: x if x > y else y, [1, 5, 3, 2])  # 输出 5

---

5. 注意事项

• 如果序列为空且未指定 initializer，会报错。
• 许多简单场景可以用内置函数（如 sum, max）替代。
• reduce 在需要复杂归约时很有用。

---

6. 小结

• reduce 可以将序列归约为单一值。
• 适合累积、合并等复杂操作。
• 需要导入 functools 模块。

---

参考

• 官方文档：functools.reduce