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

22
chapter_array_and_linkedlist/linked_list.md
View File

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

38
chapter_array_and_linkedlist/list.md
View File

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

54
chapter_computational_complexity/space_complexity.md
View File

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

67
chapter_computational_complexity/time_complexity.md
View File

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

28
chapter_graph/graph_operations.md
View File

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

40
chapter_hashing/hash_map.md
View File

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

8
chapter_heap/heap.md
View File

@ -139,7 +139,7 @@ comments: true
heapq.heappush(max_heap, flag * 4) 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 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) heapq.heapify(min_heap)
``` ```

4
chapter_searching/binary_search.md
View File

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

8
chapter_searching/hashing_search.md
View File

@ -45,7 +45,7 @@ comments: true
=== "Python" === "Python"
```python title="hashing_search.py" ```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: 目标元素，value: 索引
# 若哈希表中无此 key ，返回 -1 # 若哈希表中无此 key ，返回 -1
@ -163,11 +163,11 @@ comments: true
=== "Python" === "Python"
```python title="hashing_search.py" ```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: 目标元素，value: 结点对象
# 若哈希表中无此 key ，返回 -1 # 若哈希表中无此 key ，返回 None
return mapp.get(target, -1) return mapp.get(target, None)
``` ```
=== "Go" === "Go"

4
chapter_searching/linear_search.md
View File

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

10
chapter_sorting/bubble_sort.md
View File

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

6
chapter_sorting/insertion_sort.md
View File

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

82
chapter_sorting/merge_sort.md
View File

@ -146,18 +146,21 @@ comments: true
=== "Python" === "Python"
```python title="merge_sort.py" ```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] # 左子数组区间 [left, mid]
# 右子数组区间 [mid + 1, right] # 右子数组区间 [mid + 1, right]
# 初始化辅助数组 借助 copy模块 # 初始化辅助数组 借助 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 分别指向左子数组、右子数组的首元素
i, j = left_start, right_start i: int = left_start
j: int = right_start
# 通过覆盖原数组 nums 来合并左子数组和右子数组 # 通过覆盖原数组 nums 来合并左子数组和右子数组
for k in range(left, right + 1): for k in range(left, right + 1):
# 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++ # 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
@ -173,13 +176,13 @@ comments: true
nums[k] = tmp[j] nums[k] = tmp[j]
j += 1 j += 1
def merge_sort(nums, left, right): def merge_sort(nums: List[int], left: int, right: int) -> None:
""" 归并排序 """ """ 归并排序 """
# 终止条件 # 终止条件
if left >= right: if left >= right:
return # 当子数组长度为 1 时终止递归 return # 当子数组长度为 1 时终止递归
# 划分阶段 # 划分阶段
mid = (left + right) // 2 # 计算中点 mid: int = (left + right) // 2 # 计算中点
merge_sort(nums, left, mid) # 递归左子数组 merge_sort(nums, left, mid) # 递归左子数组
merge_sort(nums, mid + 1, right) # 递归右子数组 merge_sort(nums, mid + 1, right) # 递归右子数组
# 合并阶段 # 合并阶段
@ -189,11 +192,9 @@ comments: true
=== "Go" === "Go"
```go title="merge_sort.go" ```go title="merge_sort.go"
/* /* 合并左子数组和右子数组 */
合并左子数组和右子数组 // 左子数组区间 [left, mid]
左子数组区间 [left, mid] // 右子数组区间 [mid + 1, right]
右子数组区间 [mid + 1, right]
*/
func merge(nums []int, left, mid, right int) { func merge(nums []int, left, mid, right int) {
// 初始化辅助数组 借助 copy 模块 // 初始化辅助数组 借助 copy 模块
tmp := make([]int, right-left+1) tmp := make([]int, right-left+1)
@ -224,6 +225,7 @@ comments: true
} }
} }
/* 归并排序 */
func mergeSort(nums []int, left, right int) { func mergeSort(nums []int, left, right int) {
// 终止条件 // 终止条件
if left >= right { if left >= right {
@ -378,11 +380,9 @@ comments: true
=== "Swift" === "Swift"
```swift title="merge_sort.swift" ```swift title="merge_sort.swift"
/** /* 合并左子数组和右子数组 */
* 合并左子数组和右子数组 // 左子数组区间 [left, mid]
* 左子数组区间 [left, mid] // 右子数组区间 [mid + 1, right]
* 右子数组区间 [mid + 1, right]
*/
func merge(nums: inout [Int], left: Int, mid: Int, right: Int) { func merge(nums: inout [Int], left: Int, mid: Int, right: Int) {
// 初始化辅助数组 // 初始化辅助数组
let tmp = Array(nums[left ..< (right + 1)]) let tmp = Array(nums[left ..< (right + 1)])
@ -433,7 +433,55 @@ comments: true
=== "Zig" === "Zig"
```zig title="merge_sort.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()` 的流程： 下面重点解释一下合并方法 `merge()` 的流程：

16
chapter_sorting/quick_sort.md
View File

@ -100,7 +100,7 @@ comments: true
=== "Python" === "Python"
```python title="quick_sort.py" ```python title="quick_sort.py"
def partition(self, nums, left, right): def partition(self, nums: List[int], left: int, right: int) -> int:
""" 哨兵划分 """ """ 哨兵划分 """
# 以 nums[left] 作为基准数 # 以 nums[left] 作为基准数
i, j = left, right i, j = left, right
@ -333,13 +333,13 @@ comments: true
=== "Python" === "Python"
```python title="quick_sort.py" ```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 时终止递归 # 子数组长度为 1 时终止递归
if left >= right: if left >= right:
return 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, left, pivot - 1)
self.quick_sort(nums, pivot + 1, right) self.quick_sort(nums, pivot + 1, right)
@ -552,7 +552,7 @@ comments: true
=== "Python" === "Python"
```python title="quick_sort.py" ```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 # 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
@ -562,10 +562,10 @@ comments: true
return mid return mid
return right return right
def partition(self, nums, left, right): def partition(self, nums: List[int], left: int, right: int) -> int:
""" 哨兵划分（三数取中值） """ """ 哨兵划分（三数取中值） """
# 以 nums[left] 作为基准数 # 以 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], nums[med] = nums[med], nums[left]
# 以 nums[left] 作为基准数 # 以 nums[left] 作为基准数
@ -845,12 +845,12 @@ comments: true
=== "Python" === "Python"
```python title="quick_sort.py" ```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 时终止 # 子数组长度为 1 时终止
while left < right: while left < right:
# 哨兵划分操作 # 哨兵划分操作
pivot = self.partition(nums, left, right) pivot: int = self.partition(nums, left, right)
# 对两个子数组中较短的那个执行快排 # 对两个子数组中较短的那个执行快排
if pivot - left < right - pivot: if pivot - left < right - pivot:
self.quick_sort(nums, left, pivot - 1) # 递归排序左子数组 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" ```python title="deque.py"
""" 初始化双向队列 """ """ 初始化双向队列 """
deque = deque() deque: Deque[int] = collections.deque()
""" 元素入队 """ """ 元素入队 """
deque.append(2) # 添加至队尾 deque.append(2) # 添加至队尾
@ -99,18 +99,18 @@ comments: true
deque.appendleft(1) deque.appendleft(1)
""" 访问元素 """ """ 访问元素 """
front = deque[0] # 队首元素 front: int = deque[0] # 队首元素
rear = deque[-1] # 队尾元素 rear: int = deque[-1] # 队尾元素
""" 元素出队 """ """ 元素出队 """
pop_front = deque.popleft() # 队首元素出队 pop_front: int = deque.popleft() # 队首元素出队
pop_rear = deque.pop() # 队尾元素出队 pop_rear: int = deque.pop() # 队尾元素出队
""" 获取双向队列的长度 """ """ 获取双向队列的长度 """
size = len(deque) size: int = len(deque)
""" 判断双向队列是否为空 """ """ 判断双向队列是否为空 """
is_empty = len(deque) == 0 is_empty: bool = len(deque) == 0
``` ```
=== "Go" === "Go"
@ -590,28 +590,29 @@ comments: true
```python title="linkedlist_deque.py" ```python title="linkedlist_deque.py"
class ListNode: class ListNode:
""" 双向链表结点 """ """ 双向链表结点 """
def __init__(self, val): def __init__(self, val: int) -> None:
""" 构造方法 """ """ 构造方法 """
self.val = val self.val: int = val
self.next = None # 后继结点引用（指针） self.next: Optional[ListNode] = None # 后继结点引用（指针）
self.prev = None # 前驱结点引用（指针） self.prev: Optional[ListNode] = None # 前驱结点引用（指针）
class LinkedListDeque: class LinkedListDeque:
""" 基于双向链表实现的双向队列 """ """ 基于双向链表实现的双向队列 """
def __init__(self): def __init__(self) -> None:
""" 构造方法 """ """ 构造方法 """
self.front, self.rear = None, None # 头结点 front ，尾结点 rear self.front: Optional[ListNode] = None # 头结点 front
self.__size = 0 # 双向队列的长度 self.rear: Optional[ListNode] = None # 尾结点 rear
self.__size: int = 0 # 双向队列的长度
def size(self): def size(self) -> int:
""" 获取双向队列的长度 """ """ 获取双向队列的长度 """
return self.__size return self.__size
def is_empty(self): def is_empty(self) -> bool:
""" 判断双向队列是否为空 """ """ 判断双向队列是否为空 """
return self.size() == 0 return self.size() == 0
def push(self, num, is_front): def push(self, num: int, is_front: bool) -> None:
""" 入队操作 """ """ 入队操作 """
node = ListNode(num) node = ListNode(num)
# 若链表为空，则令 front, rear 都指向 node # 若链表为空，则令 front, rear 都指向 node
@ -631,33 +632,33 @@ comments: true
self.rear = node # 更新尾结点 self.rear = node # 更新尾结点
self.__size += 1 # 更新队列长度 self.__size += 1 # 更新队列长度
def push_first(self, num): def push_first(self, num: int) -> None:
""" 队首入队 """ """ 队首入队 """
self.push(num, True) self.push(num, True)
def push_last(self, num): def push_last(self, num: int) -> None:
""" 队尾入队 """ """ 队尾入队 """
self.push(num, False) self.push(num, False)
def poll(self, is_front): def poll(self, is_front: bool) -> int:
""" 出队操作 """ """ 出队操作 """
# 若队列为空，直接返回 None # 若队列为空，直接返回 None
if self.is_empty(): if self.is_empty():
return None return None
# 队首出队操作 # 队首出队操作
if is_front: 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: if fnext != None:
fnext.prev = None fnext.prev = None
self.front.next = None self.front.next = None
self.front = fnext # 更新头结点 self.front = fnext # 更新头结点
# 队尾出队操作 # 队尾出队操作
else: else:
val = self.rear.val # 暂存尾结点值 val: int = self.rear.val # 暂存尾结点值
# 删除尾结点 # 删除尾结点
rprev = self.rear.prev rprev: Optional[ListNode] = self.rear.prev
if rprev != None: if rprev != None:
rprev.next = None rprev.next = None
self.rear.prev = None self.rear.prev = None
@ -665,26 +666,26 @@ comments: true
self.__size -= 1 # 更新队列长度 self.__size -= 1 # 更新队列长度
return val return val
def poll_first(self): def poll_first(self) -> int:
""" 队首出队 """ """ 队首出队 """
return self.poll(True) return self.poll(True)
def poll_last(self): def poll_last(self) -> int:
""" 队尾出队 """ """ 队尾出队 """
return self.poll(False) return self.poll(False)
def peek_first(self): def peek_first(self) -> int:
""" 访问队首元素 """ """ 访问队首元素 """
return None if self.is_empty() else self.front.val 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 return None if self.is_empty() else self.rear.val
def to_array(self): def to_array(self) -> List[int]:
""" 返回数组用于打印 """ """ 返回数组用于打印 """
node = self.front node: Optional[ListNode] = self.front
res = [0] * self.size() res: List[int] = [0] * self.size()
for i in range(self.size()): for i in range(self.size()):
res[i] = node.val res[i] = node.val
node = node.next node = node.next
@ -1594,86 +1595,87 @@ comments: true
```python title="array_deque.py" ```python title="array_deque.py"
class ArrayDeque: class ArrayDeque:
""" 基于环形数组实现的双向队列 """ """ 基于环形数组实现的双向队列 """
def __init__(self, capacity):
def __init__(self, capacity: int) -> None:
""" 构造方法 """ """ 构造方法 """
self.nums = [0] * capacity self.__nums: List[int] = [0] * capacity
self.front = 0 self.__front: int = 0
self.que_size = 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 越过数组尾部后，回到头部
# 当 i 越过数组头部后，回到尾部 # 当 i 越过数组头部后，回到尾部
return (i + self.capacity()) % self.capacity() 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("双向队列已满") print("双向队列已满")
return return
# 队首指针向左移动一位 # 队首指针向左移动一位
# 通过取余操作，实现 front 越过数组头部后回到尾部 # 通过取余操作，实现 front 越过数组头部后回到尾部
self.front = self.index(self.front-1) self.__front = self.index(self.__front - 1)
# 将 num 添加至队首 # 将 num 添加至队首
self.nums[self.front] = num self.__nums[self.__front] = num
self.que_size += 1 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("双向队列已满") print("双向队列已满")
return return
# 计算尾指针，指向队尾索引 + 1 # 计算尾指针，指向队尾索引 + 1
rear = self.index(self.front + self.que_size) rear = self.index(self.__front + self.__size)
# 将 num 添加至队尾 # 将 num 添加至队尾
self.nums[rear] = num self.__nums[rear] = num
self.que_size += 1 self.__size += 1
def poll_first(self): def poll_first(self) -> int:
""" 队首出队 """ """ 队首出队 """
num = self.peek_first() num = self.peek_first()
# 队首指针向后移动一位 # 队首指针向后移动一位
self.front = self.index(self.front+1) self.__front = self.index(self.__front + 1)
self.que_size -= 1 self.__size -= 1
return num return num
def poll_last(self): def poll_last(self) -> int:
""" 队尾出队 """ """ 队尾出队 """
num = self.peek_last() num = self.peek_last()
self.que_size -= 1 self.__size -= 1
return num return num
def peek_first(self): def peek_first(self) -> int:
""" 访问队首元素 """ """ 访问队首元素 """
assert not self.is_empty(), "双向队列为空" 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(), "双向队列为空" assert not self.is_empty(), "双向队列为空"
# 计算尾元素索引 # 计算尾元素索引
last = self.index(self.front + self.que_size - 1) last = self.index(self.__front + self.__size - 1)
return self.nums[last] return self.__nums[last]
def to_array(self): def to_array(self) -> List[int]:
""" 返回数组用于打印 """ """ 返回数组用于打印 """
# 仅转换有效长度范围内的列表元素 # 仅转换有效长度范围内的列表元素
res = [] res = []
for i in range(self.que_size): for i in range(self.__size):
res.append(self.nums[self.index(self.front+i)]) res.append(self.__nums[self.index(self.__front + i)])
return res return res
``` ```

58
chapter_stack_and_queue/queue.md
View File

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

46
chapter_stack_and_queue/stack.md
View File

@ -87,7 +87,7 @@ comments: true
```python title="stack.py" ```python title="stack.py"
""" 初始化栈 """ """ 初始化栈 """
# Python 没有内置的栈类，可以把 List 当作栈来使用 # Python 没有内置的栈类，可以把 List 当作栈来使用
stack = [] stack: List[int] = []
""" 元素入栈 """ """ 元素入栈 """
stack.append(1) stack.append(1)
@ -97,16 +97,16 @@ comments: true
stack.append(4) 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" === "Go"
@ -411,40 +411,40 @@ comments: true
""" 基于链表实现的栈 """ """ 基于链表实现的栈 """
def __init__(self): def __init__(self):
""" 构造方法 """ """ 构造方法 """
self.__peek = None self.__peek: Optional[ListNode] = None
self.__size = 0 self.__size: int = 0
def size(self): def size(self) -> int:
""" 获取栈的长度 """ """ 获取栈的长度 """
return self.__size return self.__size
def is_empty(self): def is_empty(self) -> bool:
""" 判断栈是否为空 """ """ 判断栈是否为空 """
return not self.__peek return not self.__peek
def push(self, val): def push(self, val: int) -> None:
""" 入栈 """ """ 入栈 """
node = ListNode(val) node = ListNode(val)
node.next = self.__peek node.next = self.__peek
self.__peek = node self.__peek = node
self.__size += 1 self.__size += 1
def pop(self): def pop(self) -> int:
""" 出栈 """ """ 出栈 """
num = self.peek() num: int = self.peek()
self.__peek = self.__peek.next self.__peek = self.__peek.next
self.__size -= 1 self.__size -= 1
return num return num
def peek(self): def peek(self) -> int:
""" 访问栈顶元素 """ """ 访问栈顶元素 """
# 判空处理 # 判空处理
if not self.__peek: return None if not self.__peek: return None
return self.__peek.val return self.__peek.val
def to_list(self): def to_list(self) -> List[int]:
""" 转化为列表用于打印 """ """ 转化为列表用于打印 """
arr = [] arr: List[int] = []
node = self.__peek node = self.__peek
while node: while node:
arr.append(node.val) arr.append(node.val)
@ -951,33 +951,33 @@ comments: true
```python title="array_stack.py" ```python title="array_stack.py"
class ArrayStack: 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) return len(self.__stack)
def is_empty(self): def is_empty(self) -> bool:
""" 判断栈是否为空 """ """ 判断栈是否为空 """
return self.__stack == [] return self.__stack == []
def push(self, item): def push(self, item: int) -> None:
""" 入栈 """ """ 入栈 """
self.__stack.append(item) self.__stack.append(item)
def pop(self): def pop(self) -> int:
""" 出栈 """ """ 出栈 """
assert not self.is_empty(), "栈为空" assert not self.is_empty(), "栈为空"
return self.__stack.pop() return self.__stack.pop()
def peek(self): def peek(self) -> int:
""" 访问栈顶元素 """ """ 访问栈顶元素 """
assert not self.is_empty(), "栈为空" assert not self.is_empty(), "栈为空"
return self.__stack[-1] return self.__stack[-1]
def to_list(self): def to_list(self) -> List[int]:
""" 返回列表用于打印 """ """ 返回列表用于打印 """
return self.__stack 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="" ```python title=""
""" AVL 树结点类 """ """ AVL 树结点类 """
class TreeNode: class TreeNode:
def __init__(self, val=None, left=None, right=None): def __init__(self, val: int):
self.val = val # 结点值 self.val: int = val # 结点值
self.height = 0 # 结点高度 self.height: int = 0 # 结点高度
self.left = left # 左子结点引用 self.left: Optional[TreeNode] = None # 左子结点引用
self.right = right # 右子结点引用 self.right: Optional[TreeNode] = None # 右子结点引用
``` ```
=== "Go" === "Go"
@ -517,7 +517,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "Python" === "Python"
```python title="avl_tree.py" ```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 child = node.left
grand_child = child.right grand_child = child.right
@ -701,7 +701,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "Python" === "Python"
```python title="avl_tree.py" ```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 child = node.right
grand_child = child.left grand_child = child.left
@ -940,7 +940,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "Python" === "Python"
```python title="avl_tree.py" ```python title="avl_tree.py"
def __rotate(self, node: Optional[TreeNode]) -> TreeNode: def __rotate(self, node: Optional[TreeNode]) -> Optional[TreeNode]:
""" 执行旋转操作，使该子树重新恢复平衡 """ """ 执行旋转操作，使该子树重新恢复平衡 """
# 获取结点 node 的平衡因子 # 获取结点 node 的平衡因子
balance_factor = self.balance_factor(node) balance_factor = self.balance_factor(node)
@ -1251,8 +1251,8 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
```python title="avl_tree.py" ```python title="avl_tree.py"
def insert(self, val) -> TreeNode: def insert(self, val) -> TreeNode:
""" 插入结点 """ """ 插入结点 """
self.root = self.__insert_helper(self.root, val) self.__root = self.__insert_helper(self.__root, val)
return self.root return self.__root
def __insert_helper(self, node: Optional[TreeNode], val: int) -> TreeNode: def __insert_helper(self, node: Optional[TreeNode], val: int) -> TreeNode:
""" 递归插入结点（辅助方法）""" """ 递归插入结点（辅助方法）"""
@ -1571,10 +1571,10 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "Python" === "Python"
```python title="avl_tree.py" ```python title="avl_tree.py"
def remove(self, val: int): def remove(self, val: int) -> Optional[TreeNode]:
""" 删除结点 """ """ 删除结点 """
root = self.__remove_helper(self.root, val) self.__root = self.__remove_helper(self.__root, val)
return root return self.__root
def __remove_helper(self, node: Optional[TreeNode], val: int) -> Optional[TreeNode]: 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" ```python title="binary_search_tree.py"
def search(self, num: int) -> Optional[TreeNode]: def search(self, num: int) -> Optional[TreeNode]:
""" 查找结点 """ """ 查找结点 """
cur = self.root cur: Optional[TreeNode] = self.__root
# 循环查找，越过叶结点后跳出 # 循环查找，越过叶结点后跳出
while cur is not None: while cur is not None:
# 目标结点在 cur 的右子树中 # 目标结点在 cur 的右子树中
@ -310,13 +310,12 @@ comments: true
```python title="binary_search_tree.py" ```python title="binary_search_tree.py"
def insert(self, num: int) -> Optional[TreeNode]: def insert(self, num: int) -> Optional[TreeNode]:
""" 插入结点 """ """ 插入结点 """
root = self.root
# 若树为空，直接提前返回 # 若树为空，直接提前返回
if root is None: if self.__root is None:
return None return None
# 循环查找，越过叶结点后跳出 # 循环查找，越过叶结点后跳出
cur, pre = root, None cur, pre = self.__root, None
while cur is not None: while cur is not None:
# 找到重复结点，直接返回 # 找到重复结点，直接返回
if cur.val == num: if cur.val == num:
@ -694,13 +693,12 @@ comments: true
```python title="binary_search_tree.py" ```python title="binary_search_tree.py"
def remove(self, num: int) -> Optional[TreeNode]: def remove(self, num: int) -> Optional[TreeNode]:
""" 删除结点 """ """ 删除结点 """
root = self.root
# 若树为空，直接提前返回 # 若树为空，直接提前返回
if root is None: if self.__root is None:
return None return None
# 循环查找，越过叶结点后跳出 # 循环查找，越过叶结点后跳出
cur, pre = root, None cur, pre = self.__root, None
while cur is not None: while cur is not None:
# 找到待删除结点，跳出循环 # 找到待删除结点，跳出循环
if cur.val == num: if cur.val == num:
@ -726,8 +724,8 @@ comments: true
# 子结点数量 = 2 # 子结点数量 = 2
else: else:
# 获取中序遍历中 cur 的下一个结点 # 获取中序遍历中 cur 的下一个结点
nex = self.get_inorder_next(cur.right) nex: TreeNode = self.get_inorder_next(cur.right)
tmp = nex.val tmp: int = nex.val
# 递归删除结点 nex # 递归删除结点 nex
self.remove(nex.val) self.remove(nex.val)
# 将 nex 的值复制给 cur # 将 nex 的值复制给 cur

24
chapter_tree/binary_tree.md
View File

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

14
chapter_tree/binary_tree_traversal.md
View File

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