intervals.sort(key=lambda p: p[0])

LC 189 [:]切片操作

dict

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 包含初始键值对的字典
filled_dict = {'key1': 'value1', 'key2': 'value2'}

# 使用 dict() 构造函数
constructed_dict = dict(key1='value1', key2='value2')

valueList=list(filled_dict.values())

my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
for key in my_dict.keys():
    print(f"Key: {key}")

LC 49

defaultdict

defaultdict(int) 更适合一般的需要“键不存在时给默认值”的场景，不一定都是计数。

1
2
3

dd = defaultdict(int)  # int 类型，缺省值为 0
dd = defaultdict(lambda: 'default_value')
defaultdict(lambda: [0, 0]) # key 为一个数组

Counter

Counter 更适合对可迭代对象做频次统计、出现次数分析等，它自带的计数方法可以让实现许多场景更为简洁。Counter(p)表示从一个iterable创建计数器。

Iterable: list, tuple, str, dict, set, range, enumerate, map

del cnt[x] 删除对于x的计数。len(cnt)获取一共给几个元素计数。

新建一个 Counter

1

collections.Counter(nums)

list

index()

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

numbers = [1, 2, 3, 4, 5]

# 查找数字3的位置
position = numbers.index(3)
print(position)  # 输出: 2

# 在索引1到4之间查找数字3
position = numbers.index(3, 1, 4)
print(position)  # 输出: 2

# 尝试查找不存在的数字
try:
    position = numbers.index(7)
except ValueError as e:
    print("Not found")  # 输出: Not found

sort()

它直接在原列表上进行排序操作，不创建新的列表。只能应用于列表。

字符串比较大小

与长度无关

1

print("apple" < "apricot")  # False

iterable

Iterable: list, tuple, str, dict, set, range, enumerate, map sorted(iterable)返回一个新的已排序列表。原始的可迭代对象不会被修改。时间复杂度为O(nlogn)

deque = collections.deque()

ACM模式

知乎整理

zip

1
2
3
4
5

names = ['Alice', 'Bob', 'Charlie']
scores = [90, 85, 88]

zipped = zip(names, scores)
print(list(zipped))

输出: [(‘Alice’, 90), (‘Bob’, 85), (‘Charlie’, 88)]

heapq

1
2
3
4
5
6
7

import heapq

heap = []
heapq.heappush(heap, 3)
heapq.heappush(heap, 1)
heapq.heappush(heap, 2)
print(heap)  # 输出: [1, 3, 2]

对于单个元素：如果元素是可比较的（例如整数、浮点数等），那么堆会根据元素的大小进行排序，最小的元素位于堆顶。
对于元组元素：当元素是元组时，堆会首先比较元组的第一个元素。如果第一个元素相等，再比较第二个元素，以此类推。在你给出的代码中，压入堆的元素是 (value, key) 元组，堆会根据 value（即元素出现的频率）进行排序，value 最小的元素位于堆顶。

heapify(pq) 的作用是将任意列表转换为合法的最小堆，时间复杂度为 O (n)。

转换后： pq[0] 是最小值。
其他元素的位置满足堆性质，但不保证整体有序。

除法

python3 的地板除 “//” 是整数除法， “-3 // 2 = -2” ；向下取整

python3 的除法 “/” 是浮点除法， “-3 / 2 = -1.5” ；

而其他语言的除法是向零取整。在 Python 中要这样写：

int(a/float(b))

这里的 int 取整，是向零取整

负数

isdigit()无法判断负数，应该这样判断：

x.lstrip(’-’).isdigit()

注意如果想改变 x, 需要用 x=x.lstrip(c)

sort

1

ListNode.__lt__ = lambda a, b: a.val < b.val  # 让堆可以比较节点大小

692. 前K个高频单词

Complexity

heap

heapify: Time: O(k)
heapq.heappush: Time&Space: O(logK)

Recursion

merge sort: T(n)=2T(n/2)+T(n)=T(nLogn)
S(n)=S(logn)

LC 23: T(k)=2T(k/2)+O(n)=T(nLogK)

Sorted List

1. 插入 / 删除操作：SortedList 的时间复杂度是 O (log n)
2. SortedList 支持 O (1) 时间复杂度的随机访问

1
2

sl = SortedList([1, 3, 4])
sl.bisect_left(2)  # 返回 1（插入后变为 [1, 2, 3, 4]）

矩阵的深拷贝

result = [row[:] for row in matrix]