github/hello-algo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets 2023-03-12 18:46:03 +08:00
parent 209d82a8cc
commit f6b9a75c8f
23 changed files with 406 additions and 359 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
chapter_array_and_linkedlist/array.md
View File

@ -40,8 +40,8 @@ comments: true
```python title="array.py"
""" 初始化数组 """
arr = [0] * 5 # [ 0, 0, 0, 0, 0 ]
nums = [1, 3, 2, 5, 4]
arr: List[int] = [0] * 5 # [ 0, 0, 0, 0, 0 ]
nums: List[int] = [1, 3, 2, 5, 4]
```
=== "Go"
@ -149,7 +149,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
=== "Python"
```python title="array.py"
def random_access(nums):
def random_access(nums: List[int]) -> int:
""" 随机访问元素 """
# 在区间 [0, len(nums)-1] 中随机抽取一个数字
random_index = random.randint(0, len(nums) - 1)
@ -285,7 +285,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
=== "Python"
```python title="array.py"
def extend(nums, enlarge):
def extend(nums: List[int], enlarge: int) -> List[int]:
""" 扩展数组长度 """
# 初始化一个扩展长度后的数组
res = [0] * (len(nums) + enlarge)
@ -440,7 +440,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
=== "Python"
```python title="array.py"
def insert(nums, num, index):
def insert(nums: List[int], num: int, index: int) -> None:
""" 在数组的索引 index 处插入元素 num """
# 把索引 index 以及之后的所有元素向后移动一位
for i in range(len(nums) - 1, index, -1):
@ -560,7 +560,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
=== "Python"
```python title="array.py"
def remove(nums, index):
def remove(nums: List[int], index: int) -> None:
""" 删除索引 index 处元素 """
# 把索引 index 之后的所有元素向前移动一位
for i in range(index, len(nums) - 1):
@ -692,7 +692,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
=== "Python"
```python title="array.py"
def traverse(nums):
def traverse(nums: List[int]) -> None:
""" 遍历数组 """
count = 0
# 通过索引遍历数组
@ -848,7 +848,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
=== "Python"
```python title="array.py"
def find(nums, target):
def find(nums: List[int], target: int) -> int:
""" 在数组中查找指定元素 """
for i in range(len(nums)):
if nums[i] == target:

22
chapter_array_and_linkedlist/linked_list.md
View File

@ -43,9 +43,9 @@ comments: true
```python title=""
""" 链表结点类 """
class ListNode:
def __init__(self, x):
self.val = x # 结点值
self.next = None # 指向下一结点的指针（引用）
def __init__(self, val: int):
self.val: int = val # 结点值
self.next: Optional[ListNode] = None # 指向下一结点的指针（引用）
```
=== "Go"
@ -351,7 +351,7 @@ comments: true
=== "Python"
```python title="linked_list.py"
def insert(n0, P):
def insert(n0: ListNode, P: ListNode) -> None:
""" 在链表的结点 n0 之后插入结点 P """
n1 = n0.next
P.next = n1
@ -470,7 +470,7 @@ comments: true
=== "Python"
```python title="linked_list.py"
def remove(n0):
def remove(n0: ListNode) -> None:
""" 删除链表的结点 n0 之后的首个结点 """
if not n0.next:
return
@ -609,7 +609,7 @@ comments: true
=== "Python"
```python title="linked_list.py"
def access(head, index):
def access(head: ListNode, index: int) -> Optional[ListNode]:
""" 访问链表中索引为 index 的结点 """
for _ in range(index):
if not head:
@ -757,7 +757,7 @@ comments: true
=== "Python"
```python title="linked_list.py"
def find(head, target):
def find(head: ListNode, target: int) -> int:
""" 在链表中查找值为 target 的首个结点 """
index = 0
while head:
@ -914,10 +914,10 @@ comments: true
```python title=""
""" 双向链表结点类 """
class ListNode:
def __init__(self, x):
self.val = x # 结点值
self.next = None # 指向后继结点的指针（引用）
self.prev = None # 指向前驱结点的指针（引用）
def __init__(self, val: int):
self.val: int = val # 结点值
self.next: Optional[ListNode] = None # 指向后继结点的指针（引用）
self.prev: Optional[ListNode] = None # 指向前驱结点的指针（引用）
```
=== "Go"

38
chapter_array_and_linkedlist/list.md
View File

@ -39,9 +39,9 @@ comments: true
```python title="list.py"
""" 初始化列表 """
# 无初始值
list1 = []
list1: List[int] = []
# 有初始值
list = [1, 3, 2, 5, 4]
list: List[int] = [1, 3, 2, 5, 4]
```
=== "Go"
@ -136,7 +136,7 @@ comments: true
```python title="list.py"
""" 访问元素 """
num = list[1] # 访问索引 1 处的元素
num: int = list[1] # 访问索引 1 处的元素
""" 更新元素 """
list[1] = 0 # 将索引 1 处的元素更新为 0
@ -434,12 +434,12 @@ comments: true
```python title="list.py"
""" 通过索引遍历列表 """
count = 0
count: int = 0
for i in range(len(list)):
count += 1
""" 直接遍历列表元素 """
count = 0
count: int = 0
for n in list:
count += 1
```
@ -572,7 +572,7 @@ comments: true
```python title="list.py"
""" 拼接两个列表 """
list1 = [6, 8, 7, 10, 9]
list1: List[int] = [6, 8, 7, 10, 9]
list += list1 # 将列表 list1 拼接到 list 之后
```
@ -937,31 +937,31 @@ comments: true
""" 列表类简易实现 """
def __init__(self):
""" 构造方法 """
self.__capacity = 10 # 列表容量
self.__nums = [0] * self.__capacity # 数组（存储列表元素）
self.__size = 0 # 列表长度（即当前元素数量）
self.__extend_ratio = 2 # 每次列表扩容的倍数
self.__capacity: int = 10 # 列表容量
self.__nums: List[int] = [0] * self.__capacity # 数组（存储列表元素）
self.__size: int = 0 # 列表长度（即当前元素数量）
self.__extend_ratio: int = 2 # 每次列表扩容的倍数
def size(self):
def size(self) -> int:
""" 获取列表长度（即当前元素数量） """
return self.__size
def capacity(self):
def capacity(self) -> int:
""" 获取列表容量 """
return self.__capacity
def get(self, index):
def get(self, index: int) -> int:
""" 访问元素 """
# 索引如果越界则抛出异常，下同
assert index >= 0 and index < self.__size, "索引越界"
return self.__nums[index]
def set(self, num, index):
def set(self, num: int, index: int) -> None:
""" 更新元素 """
assert index >= 0 and index < self.__size, "索引越界"
self.__nums[index] = num
def add(self, num):
def add(self, num: int) -> None:
""" 尾部添加元素 """
# 元素数量超出容量时，触发扩容机制
if self.size() == self.capacity():
@ -969,7 +969,7 @@ comments: true
self.__nums[self.__size] = num
self.__size += 1
def insert(self, num, index):
def insert(self, num: int, index: int) -> None:
""" 中间插入元素 """
assert index >= 0 and index < self.__size, "索引越界"
# 元素数量超出容量时，触发扩容机制
@ -982,7 +982,7 @@ comments: true
# 更新元素数量
self.__size += 1
def remove(self, index):
def remove(self, index: int) -> int:
""" 删除元素 """
assert index >= 0 and index < self.__size, "索引越界"
num = self.__nums[index]
@ -994,14 +994,14 @@ comments: true
# 返回被删除元素
return num
def extend_capacity(self):
def extend_capacity(self) -> None:
""" 列表扩容 """
# 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组
self.__nums = self.__nums + [0] * self.capacity() * (self.__extend_ratio - 1)
# 更新列表容量
self.__capacity = len(self.__nums)
def to_array(self):
def to_array(self) -> List[int]:
""" 返回有效长度的列表 """
return self.__nums[:self.__size]
```

54
chapter_computational_complexity/space_complexity.md
View File

@ -83,19 +83,19 @@ comments: true
```python title=""
""" 类 """
class Node:
def __init__(self, x):
self.val = x # 结点值
self.next = None # 指向下一结点的指针（引用）
def __init__(self, x: int):
self.val: int = x # 结点值
self.next: Optional[Node] = None # 指向下一结点的指针（引用）
""" 函数 """
def function():
def function() -> int:
# do something...
return 0
def algorithm(n): # 输入数据
b = 0 # 暂存数据（变量）
def algorithm(n) -> int: # 输入数据
b: int = 0 # 暂存数据（变量）
node = Node(0) # 暂存数据（对象）
c = function() # 栈帧空间（调用函数）
c: int = function() # 栈帧空间（调用函数）
return a + b + c # 输出数据
```
@ -286,11 +286,11 @@ comments: true
=== "Python"
```python title=""
def algorithm(n):
a = 0 # O(1)
b = [0] * 10000 # O(1)
def algorithm(n: int) -> None:
a: int = 0 # O(1)
b: List[int] = [0] * 10000 # O(1)
if n > 10:
nums = [0] * n # O(n)
nums: List[int] = [0] * n # O(n)
```
=== "Go"
@ -414,17 +414,17 @@ comments: true
=== "Python"
```python title=""
def function():
def function() -> int:
# do something
return 0
""" 循环 O(1) """
def loop(n):
def loop(n: int) -> None:
for _ in range(n):
function()
""" 递归 O(n) """
def recur(n):
def recur(n: int) -> int:
if n == 1: return
return recur(n - 1)
```
@ -624,15 +624,15 @@ $$
=== "Python"
```python title="space_complexity.py"
def constant(n):
def constant(n: int) -> None:
""" 常数阶 """
# 常量、变量、对象占用 O(1) 空间
a = 0
nums = [0] * 10000
a: int = 0
nums: List[int] = [0] * 10000
node = ListNode(0)
# 循环中的变量占用 O(1) 空间
for _ in range(n):
c = 0
c: int = 0
# 循环中的函数占用 O(1) 空间
for _ in range(n):
function()
@ -829,12 +829,12 @@ $$
=== "Python"
```python title="space_complexity.py"
def linear(n):
def linear(n: int) -> None:
""" 线性阶 """
# 长度为 n 的列表占用 O(n) 空间
nums = [0] * n
nums: List[int] = [0] * n
# 长度为 n 的哈希表占用 O(n) 空间
mapp = {}
mapp: Dict = {}
for i in range(n):
mapp[i] = str(i)
```
@ -996,7 +996,7 @@ $$
=== "Python"
```python title="space_complexity.py"
def linear_recur(n):
def linear_recur(n: int) -> None:
""" 线性阶（递归实现） """
print("递归 n =", n)
if n == 1: return
@ -1127,10 +1127,10 @@ $$
=== "Python"
```python title="space_complexity.py"
def quadratic(n):
def quadratic(n: int) -> None:
""" 平方阶 """
# 二维列表占用 O(n^2) 空间
num_matrix = [[0] * n for _ in range(n)]
num_matrix: List[List[int]] = [[0] * n for _ in range(n)]
```
=== "Go"
@ -1275,11 +1275,11 @@ $$
=== "Python"
```python title="space_complexity.py"
def quadratic_recur(n):
def quadratic_recur(n: int) -> int:
""" 平方阶（递归实现） """
if n <= 0: return 0
# 数组 nums 长度为 n, n-1, ..., 2, 1
nums = [0] * n
nums: List[int] = [0] * n
return quadratic_recur(n - 1)
```
@ -1405,7 +1405,7 @@ $$
=== "Python"
```python title="space_complexity.py"
def build_tree(n):
def build_tree(n: int) -> Optional[TreeNode]:
""" 指数阶（建立满二叉树） """
if n == 0: return None
root = TreeNode(0)

4
chapter_computational_complexity/space_time_tradeoff.md
View File

@ -71,7 +71,7 @@ comments: true
for i in range(len(nums) - 1):
for j in range(i + 1, len(nums)):
if nums[i] + nums[j] == target:
return i, j
return [i, j]
return []
```
@ -249,7 +249,7 @@ comments: true
# 单层循环，时间复杂度 O(n)
for i in range(len(nums)):
if target - nums[i] in dic:
return dic[target - nums[i]], i
return [dic[target - nums[i]], i]
dic[nums[i]] = i
return []
```

67
chapter_computational_complexity/time_complexity.md
View File

@ -52,7 +52,7 @@ $$
```python title=""
# 在某运行平台下
def algorithm(n):
def algorithm(n: int) -> None:
a = 2 # 1 ns
a = a + 1 # 1 ns
a = a * 2 # 10 ns
@ -217,14 +217,14 @@ $$
```python title=""
# 算法 A 时间复杂度：常数阶
def algorithm_A(n):
def algorithm_A(n: int) -> None:
print(0)
# 算法 B 时间复杂度：线性阶
def algorithm_B(n):
def algorithm_B(n: int) -> None:
for _ in range(n):
print(0)
# 算法 C 时间复杂度：常数阶
def algorithm_C(n):
def algorithm_C(n: int) -> None:
for _ in range(1000000):
print(0)
```
@ -420,8 +420,8 @@ $$
=== "Python"
```python title=""
def algorithm(n):
a = 1 # +1
def algorithm(n: int) -> None:
a: int = 1 # +1
a = a + 1 # +1
a = a * 2 # +1
# 循环 n 次
@ -613,8 +613,8 @@ $$
=== "Python"
```python title=""
def algorithm(n):
a = 1 # +0（技巧 1）
def algorithm(n: int) -> None:
a: int = 1 # +0（技巧 1）
a = a + n # +0（技巧 1）
# +n（技巧 2）
for i in range(5 * n + 1):
@ -821,10 +821,10 @@ $$
=== "Python"
```python title="time_complexity.py"
def constant(n):
def constant(n: int) -> int:
""" 常数阶 """
count = 0
size = 100000
count: int = 0
size: int = 100000
for _ in range(size):
count += 1
return count
@ -949,9 +949,9 @@ $$
=== "Python"
```python title="time_complexity.py"
def linear(n):
def linear(n: int) -> int:
""" 线性阶 """
count = 0
count: int = 0
for _ in range(n):
count += 1
return count
@ -1075,9 +1075,9 @@ $$
=== "Python"
```python title="time_complexity.py"
def array_traversal(nums):
def array_traversal(nums: List[int]) -> int:
""" 线性阶（遍历数组）"""
count = 0
count: int = 0
# 循环次数与数组长度成正比
for num in nums:
count += 1
@ -1215,9 +1215,9 @@ $$
=== "Python"
```python title="time_complexity.py"
def quadratic(n):
def quadratic(n: int) -> int:
""" 平方阶 """
count = 0
count: int = 0
# 循环次数与数组长度成平方关系
for i in range(n):
for j in range(n):
@ -1391,16 +1391,16 @@ $$
=== "Python"
```python title="time_complexity.py"
def bubble_sort(nums):
def bubble_sort(nums: List[int]) -> int:
""" 平方阶（冒泡排序）"""
count = 0 # 计数器
count: int = 0 # 计数器
# 外循环：待排序元素数量为 n-1, n-2, ..., 1
for i in range(len(nums) - 1, 0, -1):
# 内循环：冒泡操作
for j in range(i):
if nums[j] > nums[j + 1]:
# 交换 nums[j] 与 nums[j + 1]
tmp = nums[j]
tmp: int = nums[j]
nums[j] = nums[j + 1]
nums[j + 1] = tmp
count += 3 # 元素交换包含 3 个单元操作
@ -1604,9 +1604,10 @@ $$
=== "Python"
```python title="time_complexity.py"
def exponential(n):
def exponential(n: int) -> int:
""" 指数阶（循环实现）"""
count, base = 0, 1
count: int = 0
base: int = 1
# cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
for _ in range(n):
for _ in range(base):
@ -1768,7 +1769,7 @@ $$
=== "Python"
```python title="time_complexity.py"
def exp_recur(n):
def exp_recur(n: int) -> int:
""" 指数阶（递归实现）"""
if n == 1: return 1
return exp_recur(n - 1) + exp_recur(n - 1) + 1
@ -1884,9 +1885,9 @@ $$
=== "Python"
```python title="time_complexity.py"
def logarithmic(n):
def logarithmic(n: float) -> int:
""" 对数阶（循环实现）"""
count = 0
count: int = 0
while n > 1:
n = n / 2
count += 1
@ -2017,7 +2018,7 @@ $$
=== "Python"
```python title="time_complexity.py"
def log_recur(n):
def log_recur(n: float) -> int:
""" 对数阶（递归实现）"""
if n <= 1: return 0
return log_recur(n / 2) + 1
@ -2133,10 +2134,10 @@ $$
=== "Python"
```python title="time_complexity.py"
def linear_log_recur(n):
def linear_log_recur(n: float) -> int:
""" 线性对数阶 """
if n <= 1: return 1
count = linear_log_recur(n // 2) + \
count: int = linear_log_recur(n // 2) + \
linear_log_recur(n // 2)
for _ in range(n):
count += 1
@ -2290,10 +2291,10 @@ $$
=== "Python"
```python title="time_complexity.py"
def factorial_recur(n):
def factorial_recur(n: int) -> int:
""" 阶乘阶（递归实现）"""
if n == 0: return 1
count = 0
count: int = 0
# 从 1 个分裂出 n 个
for _ in range(n):
count += factorial_recur(n - 1)
@ -2480,15 +2481,15 @@ $$
=== "Python"
```python title="worst_best_time_complexity.py"
def random_numbers(n):
def random_numbers(n: int) -> List[int]:
""" 生成一个数组，元素为: 1, 2, ..., n ，顺序被打乱 """
# 生成数组 nums =: 1, 2, 3, ..., n
nums = [i for i in range(1, n + 1)]
nums: List[int] = [i for i in range(1, n + 1)]
# 随机打乱数组元素
random.shuffle(nums)
return nums
def find_one(nums):
def find_one(nums: List[int]) -> int:
""" 查找数组 nums 中数字 1 所在索引 """
for i in range(len(nums)):
# 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)

30
chapter_graph/graph_operations.md
View File

@ -216,14 +216,14 @@ comments: true
class GraphAdjMat:
""" 基于邻接矩阵实现的无向图类 """
# 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
vertices = []
vertices: List[int] = []
# 邻接矩阵，行列索引对应“顶点索引”
adj_mat = []
adj_mat: List[List[int]] = []
def __init__(self, vertices, edges):
def __init__(self, vertices: List[int], edges: List[List[int]]) -> None:
""" 构造方法 """
self.vertices = []
self.adj_mat = []
self.vertices: List[int] = []
self.adj_mat: List[List[int]] = []
# 添加顶点
for val in vertices:
self.add_vertex(val)
@ -232,23 +232,23 @@ comments: true
for e in edges:
self.add_edge(e[0], e[1])
def size(self):
def size(self) -> int:
""" 获取顶点数量 """
return len(self.vertices)
def add_vertex(self, val):
def add_vertex(self, val: int) -> None:
""" 添加顶点 """
n = self.size()
# 向顶点列表中添加新顶点的值
self.vertices.append(val)
# 在邻接矩阵中添加一行
new_row = [0]*n
new_row = [0] * n
self.adj_mat.append(new_row)
# 在邻接矩阵中添加一列
for row in self.adj_mat:
row.append(0)
def remove_vertex(self, index):
def remove_vertex(self, index: int) -> None:
""" 删除顶点 """
if index >= self.size():
raise IndexError()
@ -260,7 +260,7 @@ comments: true
for row in self.adj_mat:
row.pop(index)
def add_edge(self, i, j):
def add_edge(self, i: int, j: int) -> None:
""" 添加边 """
# 参数 i, j 对应 vertices 元素索引
# 索引越界与相等处理
@ -270,7 +270,7 @@ comments: true
self.adj_mat[i][j] = 1
self.adj_mat[j][i] = 1
def remove_edge(self, i, j):
def remove_edge(self, i: int, j: int) -> None:
""" 删除边 """
# 参数 i, j 对应 vertices 元素索引
# 索引越界与相等处理
@ -279,7 +279,7 @@ comments: true
self.adj_mat[i][j] = 0
self.adj_mat[j][i] = 0
def print(self):
def print(self) -> None:
""" 打印邻接矩阵 """
print("顶点列表 =", self.vertices)
print("邻接矩阵 =")
@ -965,12 +965,10 @@ comments: true
```python title="graph_adjacency_list.py"
class GraphAdjList:
""" 基于邻接表实现的无向图类 """
# 邻接表，key: 顶点，value：该顶点的所有邻接顶点
adj_list = {}
def __init__(self, edges: List[List[Vertex]]) -> None:
""" 构造方法 """
self.adj_list = {}
# 邻接表，key: 顶点，value：该顶点的所有邻接顶点
self.adj_list: Dict = {}
# 添加所有顶点和边
for edge in edges:
self.add_vertex(edge[0])

40
chapter_hashing/hash_map.md
View File

@ -87,7 +87,7 @@ comments: true
```python title="hash_map.py"
""" 初始化哈希表 """
mapp = {}
mapp: Dict = {}
""" 添加操作 """
# 在哈希表中添加键值对 (key, value)
@ -99,7 +99,7 @@ comments: true
""" 查询操作 """
# 向哈希表输入键 key ，得到值 value
name = mapp[15937]
name: str = mapp[15937]
""" 删除操作 """
# 在哈希表中删除键值对 (key, value)
@ -606,7 +606,7 @@ $$
```python title="array_hash_map.py"
class Entry:
""" 键值对 int->String """
def __init__(self, key, val):
def __init__(self, key: int, val: str):
self.key = key
self.val = val
@ -615,58 +615,58 @@ $$
def __init__(self):
""" 构造方法 """
# 初始化一个长度为 100 的桶（数组）
self.bucket = [None] * 100
self.bucket: List[Optional[Entry]] = [None] * 100
def hash_func(self, key):
def hash_func(self, key: int) -> int:
""" 哈希函数 """
index = key % 100
index: int = key % 100
return index
def get(self, key):
def get(self, key: int) -> str:
""" 查询操作 """
index = self.hash_func(key)
pair = self.bucket[index]
index: int = self.hash_func(key)
pair: Entry = self.bucket[index]
if pair is None:
return None
return pair.val
def put(self, key, val):
def put(self, key: int, val: str) -> None:
""" 添加操作 """
pair = Entry(key, val)
index = self.hash_func(key)
index: int = self.hash_func(key)
self.bucket[index] = pair
def remove(self, key):
def remove(self, key: int) -> None:
""" 删除操作 """
index = self.hash_func(key)
index: int = self.hash_func(key)
# 置为 None ，代表删除
self.bucket[index] = None
def entry_set(self):
def entry_set(self) -> List[Entry]:
""" 获取所有键值对 """
result = []
result: List[Entry] = []
for pair in self.bucket:
if pair is not None:
result.append(pair)
return result
def key_set(self):
def key_set(self) -> List[int]:
""" 获取所有键 """
result = []
result: List[int] = []
for pair in self.bucket:
if pair is not None:
result.append(pair.key)
return result
def value_set(self):
def value_set(self) -> List[str]:
""" 获取所有值 """
result = []
result: List[str] = []
for pair in self.bucket:
if pair is not None:
result.append(pair.val)
return result
def print(self):
def print(self) -> None:
""" 打印哈希表 """
for pair in self.bucket:
if pair is not None:

8
chapter_heap/heap.md
View File

@ -139,7 +139,7 @@ comments: true
heapq.heappush(max_heap, flag * 4)
""" 获取堆顶元素 """
peek = flag * max_heap[0] # 5
peek: int = flag * max_heap[0] # 5
""" 堆顶元素出堆 """
# 出堆元素会形成一个从大到小的序列
@ -150,13 +150,13 @@ comments: true
val = flag * heapq.heappop(max_heap) # 1
""" 获取堆大小 """
size = len(max_heap)
size: int = len(max_heap)
""" 判断堆是否为空 """
is_empty = not max_heap
is_empty: bool = not max_heap
""" 输入列表并建堆 """
min_heap = [1, 3, 2, 5, 4]
min_heap: List[int] = [1, 3, 2, 5, 4]
heapq.heapify(min_heap)
```

4
chapter_searching/binary_search.md
View File

@ -98,7 +98,7 @@ $$
=== "Python"
```python title="binary_search.py"
def binary_search(nums, target):
def binary_search(nums: List[int], target: int) -> int:
""" 二分查找（双闭区间） """
# 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
i, j = 0, len(nums) - 1
@ -309,7 +309,7 @@ $$
=== "Python"
```python title="binary_search.py"
def binary_search1(nums, target):
def binary_search1(nums: List[int], target: int) -> int:
""" 二分查找（左闭右开） """
# 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
i, j = 0, len(nums)

8
chapter_searching/hashing_search.md
View File

@ -45,7 +45,7 @@ comments: true
=== "Python"
```python title="hashing_search.py"
def hashing_search_array(mapp, target):
def hashing_search_array(mapp: Dict[int, int], target: int) -> int:
""" 哈希查找（数组） """
# 哈希表的 key: 目标元素，value: 索引
# 若哈希表中无此 key ，返回 -1
@ -163,11 +163,11 @@ comments: true
=== "Python"
```python title="hashing_search.py"
def hashing_search_linkedlist(mapp, target):
def hashing_search_linkedlist(mapp: Dict[int, ListNode], target: int) -> Optional[ListNode]:
""" 哈希查找（链表） """
# 哈希表的 key: 目标元素，value: 结点对象
# 若哈希表中无此 key ，返回 -1
return mapp.get(target, -1)
# 若哈希表中无此 key ，返回 None
return mapp.get(target, None)
```
=== "Go"

4
chapter_searching/linear_search.md
View File

@ -49,7 +49,7 @@ comments: true
=== "Python"
```python title="linear_search.py"
def linear_search_array(nums, target):
def linear_search_array(nums: List[int], target: int) -> int:
""" 线性查找（数组） """
# 遍历数组
for i in range(len(nums)):
@ -206,7 +206,7 @@ comments: true
=== "Python"
```python title="linear_search.py"
def linear_search_linkedlist(head, target):
def linear_search_linkedlist(head: ListNode, target: int) -> Optional[ListNode]:
""" 线性查找（链表） """
# 遍历链表
while head:

10
chapter_sorting/bubble_sort.md
View File

@ -87,9 +87,9 @@ comments: true
=== "Python"
```python title="bubble_sort.py"
def bubble_sort(nums):
def bubble_sort(nums: List[int]) -> None:
""" 冒泡排序 """
n = len(nums)
n: int = len(nums)
# 外循环：待排序元素数量为 n-1, n-2, ..., 1
for i in range(n - 1, 0, -1):
# 内循环：冒泡操作
@ -295,12 +295,12 @@ comments: true
=== "Python"
```python title="bubble_sort.py"
def bubble_sort_with_flag(nums):
def bubble_sort_with_flag(nums: List[int]) -> None:
""" 冒泡排序（标志优化） """
n = len(nums)
n: int = len(nums)
# 外循环：待排序元素数量为 n-1, n-2, ..., 1
for i in range(n - 1, 0, -1):
flag = False # 初始化标志位
flag: bool = False # 初始化标志位
# 内循环：冒泡操作
for j in range(i):
if nums[j] > nums[j + 1]:

6
chapter_sorting/insertion_sort.md
View File

@ -63,12 +63,12 @@ comments: true
=== "Python"
```python title="insertion_sort.py"
def insertion_sort(nums):
def insertion_sort(nums: List[int]) -> None:
""" 插入排序 """
# 外循环：base = nums[1], nums[2], ..., nums[n-1]
for i in range(1, len(nums)):
base = nums[i]
j = i - 1
base: int = nums[i]
j: int = i - 1
# 内循环：将 base 插入到左边的正确位置
while j >= 0 and nums[j] > base:
nums[j + 1] = nums[j] # 1. 将 nums[j] 向右移动一位

82
chapter_sorting/merge_sort.md
View File

@ -146,18 +146,21 @@ comments: true
=== "Python"
```python title="merge_sort.py"
def merge(nums, left, mid, right):
def merge(nums: List[int], left: int, mid: int, right: int) -> None:
""" 合并左子数组和右子数组 """
# 左子数组区间 [left, mid]
# 右子数组区间 [mid + 1, right]
# 初始化辅助数组 借助 copy模块
tmp = nums[left:right + 1]
tmp: List[int] = nums[left:right + 1].copy()
# 左子数组的起始索引和结束索引
left_start, left_end = left - left, mid - left
left_start: int = 0
left_end: int = mid - left
# 右子数组的起始索引和结束索引
right_start, right_end = mid + 1 - left, right - left
right_start: int = mid + 1 - left
right_end: int = right - left
# i, j 分别指向左子数组、右子数组的首元素
i, j = left_start, right_start
i: int = left_start
j: int = right_start
# 通过覆盖原数组 nums 来合并左子数组和右子数组
for k in range(left, right + 1):
# 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
@ -173,13 +176,13 @@ comments: true
nums[k] = tmp[j]
j += 1
def merge_sort(nums, left, right):
def merge_sort(nums: List[int], left: int, right: int) -> None:
""" 归并排序 """
# 终止条件
if left >= right:
return # 当子数组长度为 1 时终止递归
# 划分阶段
mid = (left + right) // 2 # 计算中点
mid: int = (left + right) // 2 # 计算中点
merge_sort(nums, left, mid) # 递归左子数组
merge_sort(nums, mid + 1, right) # 递归右子数组
# 合并阶段
@ -189,11 +192,9 @@ comments: true
=== "Go"
```go title="merge_sort.go"
/*
合并左子数组和右子数组
左子数组区间 [left, mid]
右子数组区间 [mid + 1, right]
*/
/* 合并左子数组和右子数组 */
// 左子数组区间 [left, mid]
// 右子数组区间 [mid + 1, right]
func merge(nums []int, left, mid, right int) {
// 初始化辅助数组 借助 copy 模块
tmp := make([]int, right-left+1)
@ -224,6 +225,7 @@ comments: true
}
}
/* 归并排序 */
func mergeSort(nums []int, left, right int) {
// 终止条件
if left >= right {
@ -378,11 +380,9 @@ comments: true
=== "Swift"
```swift title="merge_sort.swift"
/**
* 合并左子数组和右子数组
* 左子数组区间 [left, mid]
* 右子数组区间 [mid + 1, right]
*/
/* 合并左子数组和右子数组 */
// 左子数组区间 [left, mid]
// 右子数组区间 [mid + 1, right]
func merge(nums: inout [Int], left: Int, mid: Int, right: Int) {
// 初始化辅助数组
let tmp = Array(nums[left ..< (right + 1)])
@ -433,7 +433,55 @@ comments: true
=== "Zig"
```zig title="merge_sort.zig"
// 合并左子数组和右子数组
// 左子数组区间 [left, mid]
// 右子数组区间 [mid + 1, right]
fn merge(nums: []i32, left: usize, mid: usize, right: usize) !void {
// 初始化辅助数组
var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer mem_arena.deinit();
const mem_allocator = mem_arena.allocator();
var tmp = try mem_allocator.alloc(i32, right + 1 - left);
std.mem.copy(i32, tmp, nums[left..right+1]);
// 左子数组的起始索引和结束索引
var leftStart = left - left;
var leftEnd = mid - left;
// 右子数组的起始索引和结束索引
var rightStart = mid + 1 - left;
var rightEnd = right - left;
// i, j 分别指向左子数组、右子数组的首元素
var i = leftStart;
var j = rightStart;
// 通过覆盖原数组 nums 来合并左子数组和右子数组
var k = left;
while (k <= right) : (k += 1) {
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
if (i > leftEnd) {
nums[k] = tmp[j];
j += 1;
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
} else if (j > rightEnd or tmp[i] <= tmp[j]) {
nums[k] = tmp[i];
i += 1;
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
} else {
nums[k] = tmp[j];
j += 1;
}
}
}
// 归并排序
fn mergeSort(nums: []i32, left: usize, right: usize) !void {
// 终止条件
if (left >= right) return; // 当子数组长度为 1 时终止递归
// 划分阶段
var mid = (left + right) / 2; // 计算中点
try mergeSort(nums, left, mid); // 递归左子数组
try mergeSort(nums, mid + 1, right); // 递归右子数组
// 合并阶段
try merge(nums, left, mid, right);
}
```
下面重点解释一下合并方法 `merge()` 的流程：

16
chapter_sorting/quick_sort.md
View File

@ -100,7 +100,7 @@ comments: true
=== "Python"
```python title="quick_sort.py"
def partition(self, nums, left, right):
def partition(self, nums: List[int], left: int, right: int) -> int:
""" 哨兵划分 """
# 以 nums[left] 作为基准数
i, j = left, right
@ -333,13 +333,13 @@ comments: true
=== "Python"
```python title="quick_sort.py"
def quick_sort(self, nums, left, right):
def quick_sort(self, nums: List[int], left: int, right: int) -> None:
""" 快速排序 """
# 子数组长度为 1 时终止递归
if left >= right:
return
# 哨兵划分
pivot = self.partition(nums, left, right)
pivot: int = self.partition(nums, left, right)
# 递归左子数组、右子数组
self.quick_sort(nums, left, pivot - 1)
self.quick_sort(nums, pivot + 1, right)
@ -552,7 +552,7 @@ comments: true
=== "Python"
```python title="quick_sort.py"
def median_three(self, nums, left, mid, right):
def median_three(self, nums: List[int], left: int, mid: int, right: int) -> int:
""" 选取三个元素的中位数 """
# 此处使用异或运算来简化代码
# 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
@ -562,10 +562,10 @@ comments: true
return mid
return right
def partition(self, nums, left, right):
def partition(self, nums: List[int], left: int, right: int) -> int:
""" 哨兵划分（三数取中值） """
# 以 nums[left] 作为基准数
med = self.median_three(nums, left, (left + right) // 2, right)
med: int = self.median_three(nums, left, (left + right) // 2, right)
# 将中位数交换至数组最左端
nums[left], nums[med] = nums[med], nums[left]
# 以 nums[left] 作为基准数
@ -845,12 +845,12 @@ comments: true
=== "Python"
```python title="quick_sort.py"
def quick_sort(self, nums, left, right):
def quick_sort(self, nums: List[int], left: int, right: int) -> None:
""" 快速排序（尾递归优化） """
# 子数组长度为 1 时终止
while left < right:
# 哨兵划分操作
pivot = self.partition(nums, left, right)
pivot: int = self.partition(nums, left, right)
# 对两个子数组中较短的那个执行快排
if pivot - left < right - pivot:
self.quick_sort(nums, left, pivot - 1) # 递归排序左子数组

132
chapter_stack_and_queue/deque.md
View File

@ -89,7 +89,7 @@ comments: true
```python title="deque.py"
""" 初始化双向队列 """
deque = deque()
deque: Deque[int] = collections.deque()
""" 元素入队 """
deque.append(2) # 添加至队尾
@ -99,18 +99,18 @@ comments: true
deque.appendleft(1)
""" 访问元素 """
front = deque[0] # 队首元素
rear = deque[-1] # 队尾元素
front: int = deque[0] # 队首元素
rear: int = deque[-1] # 队尾元素
""" 元素出队 """
pop_front = deque.popleft() # 队首元素出队
pop_rear = deque.pop() # 队尾元素出队
pop_front: int = deque.popleft() # 队首元素出队
pop_rear: int = deque.pop() # 队尾元素出队
""" 获取双向队列的长度 """
size = len(deque)
size: int = len(deque)
""" 判断双向队列是否为空 """
is_empty = len(deque) == 0
is_empty: bool = len(deque) == 0
```
=== "Go"
@ -590,28 +590,29 @@ comments: true
```python title="linkedlist_deque.py"
class ListNode:
""" 双向链表结点 """
def __init__(self, val):
def __init__(self, val: int) -> None:
""" 构造方法 """
self.val = val
self.next = None # 后继结点引用（指针）
self.prev = None # 前驱结点引用（指针）
self.val: int = val
self.next: Optional[ListNode] = None # 后继结点引用（指针）
self.prev: Optional[ListNode] = None # 前驱结点引用（指针）
class LinkedListDeque:
""" 基于双向链表实现的双向队列 """
def __init__(self):
def __init__(self) -> None:
""" 构造方法 """
self.front, self.rear = None, None # 头结点 front ，尾结点 rear
self.__size = 0 # 双向队列的长度
self.front: Optional[ListNode] = None # 头结点 front
self.rear: Optional[ListNode] = None # 尾结点 rear
self.__size: int = 0 # 双向队列的长度
def size(self):
def size(self) -> int:
""" 获取双向队列的长度 """
return self.__size
def is_empty(self):
def is_empty(self) -> bool:
""" 判断双向队列是否为空 """
return self.size() == 0
def push(self, num, is_front):
def push(self, num: int, is_front: bool) -> None:
""" 入队操作 """
node = ListNode(num)
# 若链表为空，则令 front, rear 都指向 node
@ -631,33 +632,33 @@ comments: true
self.rear = node # 更新尾结点
self.__size += 1 # 更新队列长度
def push_first(self, num):
def push_first(self, num: int) -> None:
""" 队首入队 """
self.push(num, True)
def push_last(self, num):
def push_last(self, num: int) -> None:
""" 队尾入队 """
self.push(num, False)
def poll(self, is_front):
def poll(self, is_front: bool) -> int:
""" 出队操作 """
# 若队列为空，直接返回 None
if self.is_empty():
return None
# 队首出队操作
if is_front:
val = self.front.val # 暂存头结点值
val: int = self.front.val # 暂存头结点值
# 删除头结点
fnext = self.front.next
fnext: Optional[ListNode] = self.front.next
if fnext != None:
fnext.prev = None
self.front.next = None
self.front = fnext # 更新头结点
# 队尾出队操作
else:
val = self.rear.val # 暂存尾结点值
val: int = self.rear.val # 暂存尾结点值
# 删除尾结点
rprev = self.rear.prev
rprev: Optional[ListNode] = self.rear.prev
if rprev != None:
rprev.next = None
self.rear.prev = None
@ -665,26 +666,26 @@ comments: true
self.__size -= 1 # 更新队列长度
return val
def poll_first(self):
def poll_first(self) -> int:
""" 队首出队 """
return self.poll(True)
def poll_last(self):
def poll_last(self) -> int:
""" 队尾出队 """
return self.poll(False)
def peek_first(self):
def peek_first(self) -> int:
""" 访问队首元素 """
return None if self.is_empty() else self.front.val
def peek_last(self):
def peek_last(self) -> int:
""" 访问队尾元素 """
return None if self.is_empty() else self.rear.val
def to_array(self):
def to_array(self) -> List[int]:
""" 返回数组用于打印 """
node = self.front
res = [0] * self.size()
node: Optional[ListNode] = self.front
res: List[int] = [0] * self.size()
for i in range(self.size()):
res[i] = node.val
node = node.next
@ -1594,86 +1595,87 @@ comments: true
```python title="array_deque.py"
class ArrayDeque:
""" 基于环形数组实现的双向队列 """
def __init__(self, capacity):
def __init__(self, capacity: int) -> None:
""" 构造方法 """
self.nums = [0] * capacity
self.front = 0
self.que_size = 0
self.__nums: List[int] = [0] * capacity
self.__front: int = 0
self.__size: int = 0
def capacity(self):
def capacity(self) -> int:
""" 获取双向队列的容量 """
return len(self.nums)
return len(self.__nums)
def size(self):
def size(self) -> int:
""" 获取双向队列的长度 """
return self.que_size
return self.__size
def is_empty(self):
def is_empty(self) -> bool:
""" 判断双向队列是否为空 """
return self.que_size == 0
return self.__size == 0
def index(self, i):
def index(self, i: int) -> int:
""" 计算环形数组索引 """
# 通过取余操作实现数组首尾相连
# 当 i 越过数组尾部后，回到头部
# 当 i 越过数组头部后，回到尾部
return (i + self.capacity()) % self.capacity()
def push_first(self, num):
def push_first(self, num: int) -> None:
""" 队首入队 """
if self.que_size == self.capacity():
if self.__size == self.capacity():
print("双向队列已满")
return
# 队首指针向左移动一位
# 通过取余操作，实现 front 越过数组头部后回到尾部
self.front = self.index(self.front-1)
self.__front = self.index(self.__front - 1)
# 将 num 添加至队首
self.nums[self.front] = num
self.que_size += 1
self.__nums[self.__front] = num
self.__size += 1
def push_last(self, num):
def push_last(self, num: int) -> None:
""" 队尾入队 """
if self.que_size == self.capacity():
if self.__size == self.capacity():
print("双向队列已满")
return
# 计算尾指针，指向队尾索引 + 1
rear = self.index(self.front + self.que_size)
rear = self.index(self.__front + self.__size)
# 将 num 添加至队尾
self.nums[rear] = num
self.que_size += 1
self.__nums[rear] = num
self.__size += 1
def poll_first(self):
def poll_first(self) -> int:
""" 队首出队 """
num = self.peek_first()
# 队首指针向后移动一位
self.front = self.index(self.front+1)
self.que_size -= 1
self.__front = self.index(self.__front + 1)
self.__size -= 1
return num
def poll_last(self):
def poll_last(self) -> int:
""" 队尾出队 """
num = self.peek_last()
self.que_size -= 1
self.__size -= 1
return num
def peek_first(self):
def peek_first(self) -> int:
""" 访问队首元素 """
assert not self.is_empty(), "双向队列为空"
return self.nums[self.front]
return self.__nums[self.__front]
def peek_last(self):
def peek_last(self) -> int:
""" 访问队尾元素 """
assert not self.is_empty(), "双向队列为空"
# 计算尾元素索引
last = self.index(self.front + self.que_size - 1)
return self.nums[last]
last = self.index(self.__front + self.__size - 1)
return self.__nums[last]
def to_array(self):
def to_array(self) -> List[int]:
""" 返回数组用于打印 """
# 仅转换有效长度范围内的列表元素
res = []
for i in range(self.que_size):
res.append(self.nums[self.index(self.front+i)])
for i in range(self.__size):
res.append(self.__nums[self.index(self.__front + i)])
return res
```

58
chapter_stack_and_queue/queue.md
View File

@ -86,7 +86,7 @@ comments: true
""" 初始化队列 """
# 在 Python 中，我们一般将双向队列类 deque 看作队列使用
# 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不建议
que = collections.deque()
que: Deque[int] = collections.deque()
""" 元素入队 """
que.append(1)
@ -96,16 +96,16 @@ comments: true
que.append(4)
""" 访问队首元素 """
front = que[0];
front: int = que[0];
""" 元素出队 """
pop = que.popleft()
pop: int = que.popleft()
""" 获取队列的长度 """
size = len(que)
size: int = len(que)
""" 判断队列是否为空 """
is_empty = len(que) == 0
is_empty: bool = len(que) == 0
```
=== "Go"
@ -431,19 +431,19 @@ comments: true
""" 基于链表实现的队列 """
def __init__(self):
""" 构造方法 """
self.__front = None # 头结点 front
self.__rear = None # 尾结点 rear
self.__size = 0
self.__front: Optional[ListNode] = None # 头结点 front
self.__rear: Optional[ListNode] = None # 尾结点 rear
self.__size: int = 0
def size(self):
def size(self) -> int:
""" 获取队列的长度 """
return self.__size
def is_empty(self):
def is_empty(self) -> bool:
""" 判断队列是否为空 """
return not self.__front
def push(self, num):
def push(self, num: int) -> None:
""" 入队 """
# 尾结点后添加 num
node = ListNode(num)
@ -457,7 +457,7 @@ comments: true
self.__rear = node
self.__size += 1
def poll(self):
def poll(self) -> int:
""" 出队 """
num = self.peek()
# 删除头结点
@ -465,14 +465,14 @@ comments: true
self.__size -= 1
return num
def peek(self):
def peek(self) -> int:
""" 访问队首元素 """
if self.size() == 0:
print("队列为空")
return False
return self.__front.val
def to_list(self):
def to_list(self) -> List[int]:
""" 转化为列表用于打印 """
queue = []
temp = self.__front
@ -1104,51 +1104,51 @@ comments: true
```python title="array_queue.py"
class ArrayQueue:
""" 基于环形数组实现的队列 """
def __init__(self, size):
def __init__(self, size: int) -> None:
""" 构造方法 """
self.__nums = [0] * size # 用于存储队列元素的数组
self.__front = 0 # 队首指针，指向队首元素
self.__size = 0 # 队列长度
self.__nums: List[int] = [0] * size # 用于存储队列元素的数组
self.__front: int = 0 # 队首指针，指向队首元素
self.__size: int = 0 # 队列长度
def capacity(self):
def capacity(self) -> int:
""" 获取队列的容量 """
return len(self.__nums)
def size(self):
def size(self) -> int:
""" 获取队列的长度 """
return self.__size
def is_empty(self):
def is_empty(self) -> bool:
""" 判断队列是否为空 """
return self.__size == 0
def push(self, num):
def push(self, num: int) -> None:
""" 入队 """
assert self.__size < self.capacity(), "队列已满"
# 计算尾指针，指向队尾索引 + 1
# 通过取余操作，实现 rear 越过数组尾部后回到头部
rear = (self.__front + self.__size) % self.capacity()
rear: int = (self.__front + self.__size) % self.capacity()
# 将 num 添加至队尾
self.__nums[rear] = num
self.__size += 1
def poll(self):
def poll(self) -> int:
""" 出队 """
num = self.peek()
num: int = self.peek()
# 队首指针向后移动一位，若越过尾部则返回到数组头部
self.__front = (self.__front + 1) % self.capacity()
self.__size -= 1
return num
def peek(self):
def peek(self) -> int:
""" 访问队首元素 """
assert not self.is_empty(), "队列为空"
return self.__nums[self.__front]
def to_list(self):
def to_list(self) -> List[int]:
""" 返回列表用于打印 """
res = [0] * self.size()
j = self.__front
res: List[int] = [0] * self.size()
j: int = self.__front
for i in range(self.size()):
res[i] = self.__nums[(j % self.capacity())]
j += 1

46
chapter_stack_and_queue/stack.md
View File

@ -87,7 +87,7 @@ comments: true
```python title="stack.py"
""" 初始化栈 """
# Python 没有内置的栈类，可以把 List 当作栈来使用
stack = []
stack: List[int] = []
""" 元素入栈 """
stack.append(1)
@ -97,16 +97,16 @@ comments: true
stack.append(4)
""" 访问栈顶元素 """
peek = stack[-1]
peek: int = stack[-1]
""" 元素出栈 """
pop = stack.pop()
pop: int = stack.pop()
""" 获取栈的长度 """
size = len(stack)
size: int = len(stack)
""" 判断是否为空 """
is_empty = len(stack) == 0
is_empty: bool = len(stack) == 0
```
=== "Go"
@ -411,40 +411,40 @@ comments: true
""" 基于链表实现的栈 """
def __init__(self):
""" 构造方法 """
self.__peek = None
self.__size = 0
self.__peek: Optional[ListNode] = None
self.__size: int = 0
def size(self):
def size(self) -> int:
""" 获取栈的长度 """
return self.__size
def is_empty(self):
def is_empty(self) -> bool:
""" 判断栈是否为空 """
return not self.__peek
def push(self, val):
def push(self, val: int) -> None:
""" 入栈 """
node = ListNode(val)
node.next = self.__peek
self.__peek = node
self.__size += 1
def pop(self):
def pop(self) -> int:
""" 出栈 """
num = self.peek()
num: int = self.peek()
self.__peek = self.__peek.next
self.__size -= 1
return num
def peek(self):
def peek(self) -> int:
""" 访问栈顶元素 """
# 判空处理
if not self.__peek: return None
return self.__peek.val
def to_list(self):
def to_list(self) -> List[int]:
""" 转化为列表用于打印 """
arr = []
arr: List[int] = []
node = self.__peek
while node:
arr.append(node.val)
@ -951,33 +951,33 @@ comments: true
```python title="array_stack.py"
class ArrayStack:
""" 基于数组实现的栈 """
def __init__(self):
def __init__(self) -> None:
""" 构造方法 """
self.__stack = []
self.__stack: List[int] = []
def size(self):
def size(self) -> int:
""" 获取栈的长度 """
return len(self.__stack)
def is_empty(self):
def is_empty(self) -> bool:
""" 判断栈是否为空 """
return self.__stack == []
def push(self, item):
def push(self, item: int) -> None:
""" 入栈 """
self.__stack.append(item)
def pop(self):
def pop(self) -> int:
""" 出栈 """
assert not self.is_empty(), "栈为空"
return self.__stack.pop()
def peek(self):
def peek(self) -> int:
""" 访问栈顶元素 """
assert not self.is_empty(), "栈为空"
return self.__stack[-1]
def to_list(self):
def to_list(self) -> List[int]:
""" 返回列表用于打印 """
return self.__stack
```

26
chapter_tree/avl_tree.md
View File

@ -62,11 +62,11 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
```python title=""
""" AVL 树结点类 """
class TreeNode:
def __init__(self, val=None, left=None, right=None):
self.val = val # 结点值
self.height = 0 # 结点高度
self.left = left # 左子结点引用
self.right = right # 右子结点引用
def __init__(self, val: int):
self.val: int = val # 结点值
self.height: int = 0 # 结点高度
self.left: Optional[TreeNode] = None # 左子结点引用
self.right: Optional[TreeNode] = None # 右子结点引用
```
=== "Go"
@ -517,7 +517,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "Python"
```python title="avl_tree.py"
def __right_rotate(self, node: Optional[TreeNode]) -> TreeNode:
def __right_rotate(self, node: Optional[TreeNode]) -> Optional[TreeNode]:
""" 右旋操作 """
child = node.left
grand_child = child.right
@ -701,7 +701,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "Python"
```python title="avl_tree.py"
def __left_rotate(self, node: Optional[TreeNode]) -> TreeNode:
def __left_rotate(self, node: Optional[TreeNode]) -> Optional[TreeNode]:
""" 左旋操作 """
child = node.right
grand_child = child.left
@ -940,7 +940,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "Python"
```python title="avl_tree.py"
def __rotate(self, node: Optional[TreeNode]) -> TreeNode:
def __rotate(self, node: Optional[TreeNode]) -> Optional[TreeNode]:
""" 执行旋转操作，使该子树重新恢复平衡 """
# 获取结点 node 的平衡因子
balance_factor = self.balance_factor(node)
@ -1251,8 +1251,8 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
```python title="avl_tree.py"
def insert(self, val) -> TreeNode:
""" 插入结点 """
self.root = self.__insert_helper(self.root, val)
return self.root
self.__root = self.__insert_helper(self.__root, val)
return self.__root
def __insert_helper(self, node: Optional[TreeNode], val: int) -> TreeNode:
""" 递归插入结点（辅助方法）"""
@ -1571,10 +1571,10 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "Python"
```python title="avl_tree.py"
def remove(self, val: int):
def remove(self, val: int) -> Optional[TreeNode]:
""" 删除结点 """
root = self.__remove_helper(self.root, val)
return root
self.__root = self.__remove_helper(self.__root, val)
return self.__root
def __remove_helper(self, node: Optional[TreeNode], val: int) -> Optional[TreeNode]:
""" 递归删除结点（辅助方法） """

16
chapter_tree/binary_search_tree.md
View File

@ -82,7 +82,7 @@ comments: true
```python title="binary_search_tree.py"
def search(self, num: int) -> Optional[TreeNode]:
""" 查找结点 """
cur = self.root
cur: Optional[TreeNode] = self.__root
# 循环查找，越过叶结点后跳出
while cur is not None:
# 目标结点在 cur 的右子树中
@ -310,13 +310,12 @@ comments: true
```python title="binary_search_tree.py"
def insert(self, num: int) -> Optional[TreeNode]:
""" 插入结点 """
root = self.root
# 若树为空，直接提前返回
if root is None:
if self.__root is None:
return None
# 循环查找，越过叶结点后跳出
cur, pre = root, None
cur, pre = self.__root, None
while cur is not None:
# 找到重复结点，直接返回
if cur.val == num:
@ -694,13 +693,12 @@ comments: true
```python title="binary_search_tree.py"
def remove(self, num: int) -> Optional[TreeNode]:
""" 删除结点 """
root = self.root
# 若树为空，直接提前返回
if root is None:
if self.__root is None:
return None
# 循环查找，越过叶结点后跳出
cur, pre = root, None
cur, pre = self.__root, None
while cur is not None:
# 找到待删除结点，跳出循环
if cur.val == num:
@ -726,8 +724,8 @@ comments: true
# 子结点数量 = 2
else:
# 获取中序遍历中 cur 的下一个结点
nex = self.get_inorder_next(cur.right)
tmp = nex.val
nex: TreeNode = self.get_inorder_next(cur.right)
tmp: int = nex.val
# 递归删除结点 nex
self.remove(nex.val)
# 将 nex 的值复制给 cur

24
chapter_tree/binary_tree.md
View File

@ -9,7 +9,7 @@ comments: true
=== "Java"
```java title=""
/* 链表结点类 */
/* 二叉树结点类 */
class TreeNode {
int val; // 结点值
TreeNode left; // 左子结点指针
@ -21,7 +21,7 @@ comments: true
=== "C++"
```cpp title=""
/* 链表结点结构体 */
/* 二叉树结点结构体 */
struct TreeNode {
int val; // 结点值
TreeNode *left; // 左子结点指针
@ -33,18 +33,18 @@ comments: true
=== "Python"
```python title=""
""" 链表结点类 """
""" 二叉树结点类 """
class TreeNode:
def __init__(self, val=None, left=None, right=None):
self.val = val # 结点值
self.left = left # 左子结点指针
self.right = right # 右子结点指针
def __init__(self, val: int):
self.val: int = val # 结点值
self.left: Optional[TreeNode] = None # 左子结点指针
self.right: Optional[TreeNode] = None # 右子结点指针
```
=== "Go"
```go title=""
/* 链表结点结构体 */
/* 二叉树结点结构体 */
type TreeNode struct {
Val int
Left *TreeNode
@ -63,7 +63,7 @@ comments: true
=== "JavaScript"
```javascript title=""
/* 链表结点类 */
/* 二叉树结点类 */
function TreeNode(val, left, right) {
this.val = (val === undefined ? 0 : val); // 结点值
this.left = (left === undefined ? null : left); // 左子结点指针
@ -74,7 +74,7 @@ comments: true
=== "TypeScript"
```typescript title=""
/* 链表结点类 */
/* 二叉树结点类 */
class TreeNode {
val: number;
left: TreeNode | null;
@ -97,7 +97,7 @@ comments: true
=== "C#"
```csharp title=""
/* 链表结点类 */
/* 二叉树结点类 */
class TreeNode {
int val; // 结点值
TreeNode? left; // 左子结点指针
@ -109,7 +109,7 @@ comments: true
=== "Swift"
```swift title=""
/* 链表结点类 */
/* 二叉树结点类 */
class TreeNode {
var val: Int // 结点值
var left: TreeNode? // 左子结点指针

14
chapter_tree/binary_tree_traversal.md
View File

@ -69,15 +69,15 @@ comments: true
=== "Python"
```python title="binary_tree_bfs.py"
def level_order(root: Optional[TreeNode]):
def level_order(root: Optional[TreeNode]) -> List[int]:
""" 层序遍历 """
# 初始化队列，加入根结点
queue = collections.deque()
queue: Deque[TreeNode] = collections.deque()
queue.append(root)
# 初始化一个列表，用于保存遍历序列
res = []
res: List[int] = []
while queue:
node = queue.popleft() # 队列出队
node: TreeNode = queue.popleft() # 队列出队
res.append(node.val) # 保存结点值
if node.left is not None:
queue.append(node.left) # 左子结点入队
@ -337,7 +337,7 @@ comments: true
=== "Python"
```python title="binary_tree_dfs.py"
def pre_order(root: Optional[TreeNode]):
def pre_order(root: Optional[TreeNode]) -> None:
""" 前序遍历 """
if root is None:
return
@ -346,7 +346,7 @@ comments: true
pre_order(root=root.left)
pre_order(root=root.right)
def in_order(root: Optional[TreeNode]):
def in_order(root: Optional[TreeNode]) -> None:
""" 中序遍历 """
if root is None:
return
@ -355,7 +355,7 @@ comments: true
res.append(root.val)
in_order(root=root.right)
def post_order(root: Optional[TreeNode]):
def post_order(root: Optional[TreeNode]) -> None:
""" 后序遍历 """
if root is None:
return