build

chapter_array_and_linkedlist/array.md

@@ -35,7 +35,7 @@ comments: true
 === "Python"
 
     ```python title="array.py"
-    """ 初始化数组 """
+    # 初始化数组
     arr: List[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]
     nums: List[int] = [1, 3, 2, 5, 4]  
     ```
@@ -527,7 +527,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     }
     ```
 
-删除元素也是类似，如果我们想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。值得注意的是，删除元素后，原先末尾的元素变得“无意义”了，我们无需特意去修改它。
+删除元素也类似，如果我们想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。值得注意的是，删除元素后，原先末尾的元素变得“无意义”了，我们无需特意去修改它。
 
 ![数组删除元素](array.assets/array_remove_element.png)
 

chapter_array_and_linkedlist/linked_list.md

@@ -39,8 +39,8 @@ comments: true
 === "Python"
 
     ```python title=""
-    """ 链表节点类 """ 
     class ListNode:
+        """链表节点类"""
         def __init__(self, val: int):
             self.val: int = val                  # 节点值
             self.next: Optional[ListNode] = None # 指向下一节点的指针（引用）
@@ -207,7 +207,7 @@ comments: true
 === "Python"
 
     ```python title="linked_list.py"
-    """ 初始化链表 1 -> 3 -> 2 -> 5 -> 4 """
+    # 初始化链表 1 -> 3 -> 2 -> 5 -> 4
     # 初始化各个节点 
     n0 = ListNode(1)
     n1 = ListNode(3)
@@ -934,8 +934,8 @@ comments: true
 === "Python"
 
     ```python title=""
-    """ 双向链表节点类 """ 
     class ListNode:
+        """双向链表节点类"""
         def __init__(self, val: int):
             self.val: int = val                   # 节点值
             self.next: Optional[ListNode] = None  # 指向后继节点的指针（引用）

chapter_array_and_linkedlist/list.md

@@ -37,7 +37,7 @@ comments: true
 === "Python"
 
     ```python title="list.py"
-    """ 初始化列表 """
+    # 初始化列表
     # 无初始值
     list1: List[int] = []
     # 有初始值
@@ -135,10 +135,10 @@ comments: true
 === "Python"
 
     ```python title="list.py"
-    """ 访问元素 """
+    # 访问元素
     num: int = list[1]  # 访问索引 1 处的元素
 
-    """ 更新元素 """
+    # 更新元素
     list[1] = 0    # 将索引 1 处的元素更新为 0
     ```
 
@@ -253,20 +253,20 @@ comments: true
 === "Python"
 
     ```python title="list.py"
-    """ 清空列表 """
+    # 清空列表
     list.clear()
 
-    """ 尾部添加元素 """
+    # 尾部添加元素
     list.append(1)
     list.append(3)
     list.append(2)
     list.append(5)
     list.append(4)
 
-    """ 中间插入元素 """
+    # 中间插入元素
     list.insert(3, 6)  # 在索引 3 处插入数字 6
 
-    """ 删除元素 """
+    # 删除元素
     list.pop(3)        # 删除索引 3 处的元素
     ```
 
@@ -433,12 +433,12 @@ comments: true
 === "Python"
 
     ```python title="list.py"
-    """ 通过索引遍历列表 """
+    # 通过索引遍历列表
     count: int = 0
     for i in range(len(list)):
         count += 1
 
-    """ 直接遍历列表元素 """
+    # 直接遍历列表元素
     count: int = 0
     for n in list:
         count += 1
@@ -571,7 +571,7 @@ comments: true
 === "Python"
 
     ```python title="list.py"
-    """ 拼接两个列表 """
+    # 拼接两个列表
     list1: List[int] = [6, 8, 7, 10, 9]
     list += list1  # 将列表 list1 拼接到 list 之后
     ```
@@ -651,7 +651,7 @@ comments: true
 === "Python"
 
     ```python title="list.py"
-    """ 排序列表 """
+    # 排序列表
     list.sort()  # 排序后，列表元素从小到大排列
     ```
 

chapter_computational_complexity/space_complexity.md

@@ -81,14 +81,14 @@ comments: true
 === "Python"
 
     ```python title=""
-    """ 类 """
     class Node:
+        """类"""
         def __init__(self, x: int):
             self.val: int = x                 # 节点值
             self.next: Optional[Node] = None  # 指向下一节点的指针（引用）
 
-    """ 函数 """
     def function() -> int:
+        """函数"""
         # do something...
         return 0
 
@@ -419,13 +419,13 @@ comments: true
         # do something
         return 0
 
-    """ 循环 O(1) """
     def loop(n: int) -> None:
+        """循环 O(1)"""
         for _ in range(n):
             function()
 
-    """ 递归 O(n) """
     def recur(n: int) -> int:
+        """递归 O(n)"""
         if n == 1: return
         return recur(n - 1)
     ```

chapter_data_structure/data_and_memory.md

@@ -138,7 +138,7 @@ $$
 === "Python"
 
     ```python title=""
-    """ Python 的 list 可以自由存储各种基本数据类型和对象 """
+    # Python 的 list 可以自由存储各种基本数据类型和对象
     list = [0, 0.0, 'a', False]
     ```
 

chapter_hashing/hash_map.md

@@ -86,10 +86,10 @@ comments: true
 === "Python"
 
     ```python title="hash_map.py"
-    """ 初始化哈希表 """
+    # 初始化哈希表
     mapp: Dict = {}
     
-    """ 添加操作 """
+    # 添加操作
     # 在哈希表中添加键值对 (key, value)
     mapp[12836] = "小哈"
     mapp[15937] = "小啰"
@@ -97,11 +97,11 @@ comments: true
     mapp[13276] = "小法"
     mapp[10583] = "小鸭"
     
-    """ 查询操作 """
+    # 查询操作
     # 向哈希表输入键 key ，得到值 value
     name: str = mapp[15937]
     
-    """ 删除操作 """
+    # 删除操作
     # 在哈希表中删除键值对 (key, value)
     mapp.pop(10583)
     ```
@@ -277,7 +277,7 @@ comments: true
 === "Python"
 
     ```python title="hash_map.py"
-    """ 遍历哈希表 """
+    # 遍历哈希表
     # 遍历键值对 key->value
     for key, value in mapp.items():
         print(key, "->", value)

chapter_heap/heap.md

@@ -131,17 +131,18 @@ comments: true
     # Python 的 heapq 模块默认实现小顶堆
     # 考虑将“元素取负”后再入堆，这样就可以将大小关系颠倒，从而实现大顶堆
     # 在本示例中，flag = 1 时对应小顶堆，flag = -1 时对应大顶堆
-    """ 元素入堆 """
+
+    # 元素入堆
     heapq.heappush(max_heap, flag * 1)
     heapq.heappush(max_heap, flag * 3)
     heapq.heappush(max_heap, flag * 2)
     heapq.heappush(max_heap, flag * 5)
     heapq.heappush(max_heap, flag * 4)
 
-    """ 获取堆顶元素 """
+    # 获取堆顶元素
     peek: int = flag * max_heap[0] # 5
 
-    """ 堆顶元素出堆 """
+    # 堆顶元素出堆
     # 出堆元素会形成一个从大到小的序列
     val = flag * heapq.heappop(max_heap) # 5
     val = flag * heapq.heappop(max_heap) # 4
@@ -149,13 +150,13 @@ comments: true
     val = flag * heapq.heappop(max_heap) # 2
     val = flag * heapq.heappop(max_heap) # 1
 
-    """ 获取堆大小 """
+    # 获取堆大小
     size: int = len(max_heap)
 
-    """ 判断堆是否为空 """
+    # 判断堆是否为空
     is_empty: bool = not max_heap
 
-    """ 输入列表并建堆 """
+    # 输入列表并建堆
     min_heap: List[int] = [1, 3, 2, 5, 4]
     heapq.heapify(min_heap)
     ```

chapter_preface/suggestions.md

@@ -61,7 +61,7 @@ comments: true
 === "Python"
 
     ```python title=""
-    """ 标题注释，用于标注函数、类、测试样例等 """
+    """标题注释，用于标注函数、类、测试样例等"""
     
     # 内容注释，用于详解代码
     

chapter_stack_and_queue/deque.md

@@ -88,28 +88,28 @@ comments: true
 === "Python"
 
     ```python title="deque.py"
-    """ 初始化双向队列 """
+    # 初始化双向队列
     deque: Deque[int] = collections.deque()
     
-    """ 元素入队 """
+    # 元素入队
     deque.append(2)      # 添加至队尾
     deque.append(5)
     deque.append(4)
     deque.appendleft(3)  # 添加至队首
     deque.appendleft(1)
     
-    """ 访问元素 """
+    # 访问元素
     front: int = deque[0]  # 队首元素
     rear: int = deque[-1]  # 队尾元素
     
-    """ 元素出队 """
+    # 元素出队
     pop_front: int = deque.popleft()  # 队首元素出队
     pop_rear: int = deque.pop()       # 队尾元素出队
     
-    """ 获取双向队列的长度 """
+    # 获取双向队列的长度
     size: int = len(deque)
     
-    """ 判断双向队列是否为空 """
+    # 判断双向队列是否为空
     is_empty: bool = len(deque) == 0
     ```
 

chapter_stack_and_queue/queue.md

@@ -4,7 +4,7 @@ comments: true
 
 # 5.2.   队列
 
-「队列 Queue」是一种遵循「先入先出 first in, first out」数据操作规则的线性数据结构。顾名思义，队列模拟的是排队现象，即外面的人不断加入队列尾部，而处于队列头部的人不断地离开。
+「队列 Queue」是一种遵循先入先出（first in, first out）数据操作规则的线性数据结构。顾名思义，队列模拟的是排队现象，即外面的人不断加入队列尾部，而处于队列头部的人不断地离开。
 
 我们将队列头部称为「队首」，队列尾部称为「队尾」，将把元素加入队尾的操作称为「入队」，删除队首元素的操作称为「出队」。
 
@@ -83,28 +83,28 @@ comments: true
 === "Python"
 
     ```python title="queue.py"
-    """ 初始化队列 """
+    # 初始化队列
     # 在 Python 中，我们一般将双向队列类 deque 看作队列使用
     # 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不建议
     que: Deque[int] = collections.deque()
     
-    """ 元素入队 """
+    # 元素入队
     que.append(1)
     que.append(3)
     que.append(2)
     que.append(5)
     que.append(4)
     
-    """ 访问队首元素 """
+    # 访问队首元素
     front: int = que[0];
     
-    """ 元素出队 """
+    # 元素出队
     pop: int = que.popleft()
     
-    """ 获取队列的长度 """
+    # 获取队列的长度
     size: int = len(que)
     
-    """ 判断队列是否为空 """
+    # 判断队列是否为空
     is_empty: bool = len(que) == 0
     ```
 

chapter_stack_and_queue/stack.md

@@ -4,7 +4,7 @@ comments: true
 
 # 5.1.   栈
 
-「栈 Stack」是一种遵循「先入后出 first in, last out」数据操作规则的线性数据结构。我们可以将栈类比为放在桌面上的一摞盘子，如果需要拿出底部的盘子，则需要先将上面的盘子依次取出。
+「栈 Stack」是一种遵循先入后出（first in, last out）数据操作规则的线性数据结构。我们可以将栈类比为放在桌面上的一摞盘子，如果需要拿出底部的盘子，则需要先将上面的盘子依次取出。
 
 “盘子”是一种形象比喻，我们将盘子替换为任意一种元素（例如整数、字符、对象等），就得到了栈数据结构。
 
@@ -85,27 +85,27 @@ comments: true
 === "Python"
 
     ```python title="stack.py"
-    """ 初始化栈 """
+    # 初始化栈
     # Python 没有内置的栈类，可以把 List 当作栈来使用 
     stack: List[int] = []
     
-    """ 元素入栈 """
+    # 元素入栈
     stack.append(1)
     stack.append(3)
     stack.append(2)
     stack.append(5)
     stack.append(4)
     
-    """ 访问栈顶元素 """
+    # 访问栈顶元素
     peek: int = stack[-1]
     
-    """ 元素出栈 """
+    # 元素出栈
     pop: int = stack.pop()
     
-    """ 获取栈的长度 """
+    # 获取栈的长度
     size: int = len(stack)
     
-    """ 判断是否为空 """
+    # 判断是否为空
     is_empty: bool = len(stack) == 0
     ```
 

chapter_tree/avl_tree.md

@@ -60,8 +60,8 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "Python"
 
     ```python title=""
-    """ AVL 树节点类 """
     class TreeNode:
+        """AVL 树节点类"""
         def __init__(self, val: int):
             self.val: int = val                    # 节点值
             self.height: int = 0                   # 节点高度

chapter_tree/binary_tree.md

@@ -33,8 +33,8 @@ comments: true
 === "Python"
 
     ```python title=""
-    """ 二叉树节点类 """
     class TreeNode:
+        """二叉树节点类"""
         def __init__(self, val: int):
             self.val: int = val                   # 节点值
             self.left: Optional[TreeNode] = None  # 左子节点指针
@@ -196,7 +196,7 @@ comments: true
 === "Python"
 
     ```python title="binary_tree.py"
-    """ 初始化二叉树 """
+    # 初始化二叉树
     # 初始化节点
     n1 = TreeNode(val=1)
     n2 = TreeNode(val=2)
@@ -338,7 +338,7 @@ comments: true
 === "Python"
 
     ```python title="binary_tree.py"
-    """ 插入与删除节点 """
+    # 插入与删除节点
     p = TreeNode(0)
     # 在 n1 -> n2 中间插入节点 P
     n1.left = p
@@ -526,7 +526,7 @@ comments: true
 === "Python"
 
     ```python title=""
-    """ 二叉树的数组表示 """
+    # 二叉树的数组表示
     # 直接使用 None 来表示空位
     tree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
     ```