build
This commit is contained in:
krahets
parent
209d82a8cc
commit
f6b9a75c8f
@ -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:
|
||||
|
||||
@ -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"
|
||||
|
||||
@ -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]
|
||||
```
|
||||
|
||||
@ -72,8 +72,8 @@ comments: true
|
||||
int algorithm(int n) { // 输入数据
|
||||
const int a = 0; // 暂存数据（常量）
|
||||
int b = 0; // 暂存数据（变量）
|
||||
Node* node = new Node(0); // 暂存数据（对象）
|
||||
int c = func(); // 栈帧空间（调用函数）
|
||||
Node* node = new Node(0); // 暂存数据（对象）
|
||||
int c = func(); // 栈帧空间（调用函数）
|
||||
return a + b + c; // 输出数据
|
||||
}
|
||||
```
|
||||
@ -83,20 +83,20 @@ 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 # 暂存数据（变量）
|
||||
node = Node(0) # 暂存数据（对象）
|
||||
c = function() # 栈帧空间（调用函数）
|
||||
return a + b + c # 输出数据
|
||||
def algorithm(n) -> int: # 输入数据
|
||||
b: int = 0 # 暂存数据（变量）
|
||||
node = Node(0) # 暂存数据（对象）
|
||||
c: int = function() # 栈帧空间（调用函数）
|
||||
return a + b + c # 输出数据
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
@ -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)
|
||||
|
||||
@ -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 []
|
||||
```
|
||||
|
||||
@ -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,9 +613,9 @@ $$
|
||||
=== "Python"
|
||||
|
||||
```python title=""
|
||||
def algorithm(n):
|
||||
a = 1 # +0（技巧 1）
|
||||
a = a + n # +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):
|
||||
print(0)
|
||||
@ -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,11 +2134,11 @@ $$
|
||||
=== "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) + \
|
||||
linear_log_recur(n // 2)
|
||||
count: int = linear_log_recur(n // 2) + \
|
||||
linear_log_recur(n // 2)
|
||||
for _ in range(n):
|
||||
count += 1
|
||||
return count
|
||||
@ -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)
|
||||
|
||||
@ -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])
|
||||
|
||||
@ -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:
|
||||
|
||||
@ -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)
|
||||
```
|
||||
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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"
|
||||
|
||||
@ -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:
|
||||
|
||||
@ -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]:
|
||||
|
||||
@ -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] 向右移动一位
|
||||
|
||||
@ -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 {
|
||||
@ -267,7 +269,7 @@ comments: true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* 归并排序 */
|
||||
function mergeSort(nums, left, right) {
|
||||
// 终止条件
|
||||
@ -301,10 +303,10 @@ comments: true
|
||||
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
if (i > leftEnd) {
|
||||
nums[k] = tmp[j++];
|
||||
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
} else if (j > rightEnd || tmp[i] <= tmp[j]) {
|
||||
nums[k] = tmp[i++];
|
||||
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
} else {
|
||||
nums[k] = tmp[j++];
|
||||
}
|
||||
@ -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()` 的流程：
|
||||
|
||||
@ -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) # 递归排序左子数组
|
||||
|
||||
@ -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):
|
||||
""" 构造方法 """
|
||||
self.nums = [0] * capacity
|
||||
self.front = 0
|
||||
self.que_size = 0
|
||||
|
||||
def capacity(self):
|
||||
def __init__(self, capacity: int) -> None:
|
||||
""" 构造方法 """
|
||||
self.__nums: List[int] = [0] * capacity
|
||||
self.__front: int = 0
|
||||
self.__size: int = 0
|
||||
|
||||
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
|
||||
```
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
```
|
||||
|
||||
@ -35,9 +35,9 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
|
||||
```java title=""
|
||||
/* AVL 树结点类 */
|
||||
class TreeNode {
|
||||
public int val; // 结点值
|
||||
public int height; // 结点高度
|
||||
public TreeNode left; // 左子结点
|
||||
public int val; // 结点值
|
||||
public int height; // 结点高度
|
||||
public TreeNode left; // 左子结点
|
||||
public TreeNode right; // 右子结点
|
||||
public TreeNode(int x) { val = x; }
|
||||
}
|
||||
@ -48,10 +48,10 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
|
||||
```cpp title=""
|
||||
/* AVL 树结点类 */
|
||||
struct TreeNode {
|
||||
int val{}; // 结点值
|
||||
int height = 0; // 结点高度
|
||||
TreeNode *left{}; // 左子结点
|
||||
TreeNode *right{}; // 右子结点
|
||||
int val{}; // 结点值
|
||||
int height = 0; // 结点高度
|
||||
TreeNode *left{}; // 左子结点
|
||||
TreeNode *right{}; // 右子结点
|
||||
TreeNode() = default;
|
||||
explicit TreeNode(int x) : val(x){}
|
||||
};
|
||||
@ -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]:
|
||||
""" 递归删除结点（辅助方法） """
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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? // 左子结点指针
|
||||
|
||||
@ -69,20 +69,20 @@ 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() # 队列出队
|
||||
res.append(node.val) # 保存结点值
|
||||
node: TreeNode = queue.popleft() # 队列出队
|
||||
res.append(node.val) # 保存结点值
|
||||
if node.left is not None:
|
||||
queue.append(node.left) # 左子结点入队
|
||||
queue.append(node.left) # 左子结点入队
|
||||
if node.right is not None:
|
||||
queue.append(node.right) # 右子结点入队
|
||||
queue.append(node.right) # 右子结点入队
|
||||
return res
|
||||
```
|
||||
|
||||
@ -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
|
||||
|
||||
Loading…
Reference in New Issue
Block a user