From f6b9a75c8f33f3f2b275a453f1ddd5b713e019ac Mon Sep 17 00:00:00 2001 From: krahets Date: Sun, 12 Mar 2023 18:46:03 +0800 Subject: [PATCH] build --- chapter_array_and_linkedlist/array.md | 16 +-- chapter_array_and_linkedlist/linked_list.md | 22 +-- chapter_array_and_linkedlist/list.md | 38 ++--- .../space_complexity.md | 62 ++++---- .../space_time_tradeoff.md | 4 +- .../time_complexity.md | 71 +++++----- chapter_graph/graph_operations.md | 30 ++-- chapter_hashing/hash_map.md | 40 +++--- chapter_heap/heap.md | 8 +- chapter_searching/binary_search.md | 4 +- chapter_searching/hashing_search.md | 8 +- chapter_searching/linear_search.md | 4 +- chapter_sorting/bubble_sort.md | 10 +- chapter_sorting/insertion_sort.md | 6 +- chapter_sorting/merge_sort.md | 88 +++++++++--- chapter_sorting/quick_sort.md | 16 +-- chapter_stack_and_queue/deque.md | 134 +++++++++--------- chapter_stack_and_queue/queue.md | 58 ++++---- chapter_stack_and_queue/stack.md | 46 +++--- chapter_tree/avl_tree.md | 40 +++--- chapter_tree/binary_search_tree.md | 16 +-- chapter_tree/binary_tree.md | 24 ++-- chapter_tree/binary_tree_traversal.md | 20 +-- 23 files changed, 406 insertions(+), 359 deletions(-) diff --git a/chapter_array_and_linkedlist/array.md b/chapter_array_and_linkedlist/array.md index 0b71aa6be..5b6785118 100755 --- a/chapter_array_and_linkedlist/array.md +++ b/chapter_array_and_linkedlist/array.md @@ -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: diff --git a/chapter_array_and_linkedlist/linked_list.md b/chapter_array_and_linkedlist/linked_list.md index a533a2e4e..461250e02 100755 --- a/chapter_array_and_linkedlist/linked_list.md +++ b/chapter_array_and_linkedlist/linked_list.md @@ -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" diff --git a/chapter_array_and_linkedlist/list.md b/chapter_array_and_linkedlist/list.md index b3acb7c5b..2a83b79fd 100755 --- a/chapter_array_and_linkedlist/list.md +++ b/chapter_array_and_linkedlist/list.md @@ -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] ``` diff --git a/chapter_computational_complexity/space_complexity.md b/chapter_computational_complexity/space_complexity.md index 005ed7cb3..96a60fb0f 100755 --- a/chapter_computational_complexity/space_complexity.md +++ b/chapter_computational_complexity/space_complexity.md @@ -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) diff --git a/chapter_computational_complexity/space_time_tradeoff.md b/chapter_computational_complexity/space_time_tradeoff.md index 5c319fcf4..14ae43adf 100755 --- a/chapter_computational_complexity/space_time_tradeoff.md +++ b/chapter_computational_complexity/space_time_tradeoff.md @@ -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 [] ``` diff --git a/chapter_computational_complexity/time_complexity.md b/chapter_computational_complexity/time_complexity.md index abe5b20ce..308867c5d 100755 --- a/chapter_computational_complexity/time_complexity.md +++ b/chapter_computational_complexity/time_complexity.md @@ -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) diff --git a/chapter_graph/graph_operations.md b/chapter_graph/graph_operations.md index dda7ea2a5..5abfaed8c 100644 --- a/chapter_graph/graph_operations.md +++ b/chapter_graph/graph_operations.md @@ -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]) diff --git a/chapter_hashing/hash_map.md b/chapter_hashing/hash_map.md index d47bc579b..ee39192d1 100755 --- a/chapter_hashing/hash_map.md +++ b/chapter_hashing/hash_map.md @@ -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: diff --git a/chapter_heap/heap.md b/chapter_heap/heap.md index efd1bc275..4aeef1672 100644 --- a/chapter_heap/heap.md +++ b/chapter_heap/heap.md @@ -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) ``` diff --git a/chapter_searching/binary_search.md b/chapter_searching/binary_search.md index e9dae2ecf..05415bcd0 100755 --- a/chapter_searching/binary_search.md +++ b/chapter_searching/binary_search.md @@ -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) diff --git a/chapter_searching/hashing_search.md b/chapter_searching/hashing_search.md index ba971cae7..1ffddac97 100755 --- a/chapter_searching/hashing_search.md +++ b/chapter_searching/hashing_search.md @@ -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" diff --git a/chapter_searching/linear_search.md b/chapter_searching/linear_search.md index 1aaf53dc8..500b370e0 100755 --- a/chapter_searching/linear_search.md +++ b/chapter_searching/linear_search.md @@ -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: diff --git a/chapter_sorting/bubble_sort.md b/chapter_sorting/bubble_sort.md index c7f7616f3..2ff3c6c15 100755 --- a/chapter_sorting/bubble_sort.md +++ b/chapter_sorting/bubble_sort.md @@ -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]: diff --git a/chapter_sorting/insertion_sort.md b/chapter_sorting/insertion_sort.md index 0dbb019ab..635a1f15e 100755 --- a/chapter_sorting/insertion_sort.md +++ b/chapter_sorting/insertion_sort.md @@ -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] 向右移动一位 diff --git a/chapter_sorting/merge_sort.md b/chapter_sorting/merge_sort.md index 13fda8892..a135092f6 100755 --- a/chapter_sorting/merge_sort.md +++ b/chapter_sorting/merge_sort.md @@ -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()` 的流程： diff --git a/chapter_sorting/quick_sort.md b/chapter_sorting/quick_sort.md index 1c132cfa1..27eee7f66 100755 --- a/chapter_sorting/quick_sort.md +++ b/chapter_sorting/quick_sort.md @@ -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) # 递归排序左子数组 diff --git a/chapter_stack_and_queue/deque.md b/chapter_stack_and_queue/deque.md index 9dbe60b13..aed90e73a 100644 --- a/chapter_stack_and_queue/deque.md +++ b/chapter_stack_and_queue/deque.md @@ -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 ``` diff --git a/chapter_stack_and_queue/queue.md b/chapter_stack_and_queue/queue.md index 3089da0e4..56e21bbc2 100755 --- a/chapter_stack_and_queue/queue.md +++ b/chapter_stack_and_queue/queue.md @@ -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 diff --git a/chapter_stack_and_queue/stack.md b/chapter_stack_and_queue/stack.md index b53fc43c6..785c7c5ec 100755 --- a/chapter_stack_and_queue/stack.md +++ b/chapter_stack_and_queue/stack.md @@ -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 ``` diff --git a/chapter_tree/avl_tree.md b/chapter_tree/avl_tree.md index 358d198d5..bd10f8e7a 100644 --- a/chapter_tree/avl_tree.md +++ b/chapter_tree/avl_tree.md @@ -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]: """ 递归删除结点（辅助方法） """ diff --git a/chapter_tree/binary_search_tree.md b/chapter_tree/binary_search_tree.md index 2dc441ac2..f8e640038 100755 --- a/chapter_tree/binary_search_tree.md +++ b/chapter_tree/binary_search_tree.md @@ -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 diff --git a/chapter_tree/binary_tree.md b/chapter_tree/binary_tree.md index 4529b3378..ea7811587 100644 --- a/chapter_tree/binary_tree.md +++ b/chapter_tree/binary_tree.md @@ -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? // 左子结点指针 diff --git a/chapter_tree/binary_tree_traversal.md b/chapter_tree/binary_tree_traversal.md index a9ec83083..762ac68cd 100755 --- a/chapter_tree/binary_tree_traversal.md +++ b/chapter_tree/binary_tree_traversal.md @@ -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