From 9eac1275f65f4f7f70e2d23bcc325ae9eed4f1fb Mon Sep 17 00:00:00 2001
From: a16su <33782391+a16su@users.noreply.github.com>
Date: Tue, 20 Dec 2022 15:52:00 +0800
Subject: [PATCH 001/158] add binary_tree and avl_tree python code

---
 codes/python/chapter_tree/avl_tree.py         | 281 ++++++++++++++++++
 .../python/chapter_tree/binary_search_tree.py | 167 ++++++++++-
 codes/python/chapter_tree/binary_tree.py      |  32 +-
 codes/python/chapter_tree/binary_tree_bfs.py  |  39 ++-
 codes/python/chapter_tree/binary_tree_dfs.py  |  74 ++++-
 codes/python/include/binary_tree.py           |   2 +-
 docs/chapter_tree/avl_tree.md                 | 210 ++++++++++++-
 docs/chapter_tree/binary_search_tree.md       | 104 +++++++
 docs/chapter_tree/binary_tree.md              |  80 ++++-
 9 files changed, 967 insertions(+), 22 deletions(-)
 create mode 100644 codes/python/chapter_tree/avl_tree.py

diff --git a/codes/python/chapter_tree/avl_tree.py b/codes/python/chapter_tree/avl_tree.py
new file mode 100644
index 000000000..4e6e35727
--- /dev/null
+++ b/codes/python/chapter_tree/avl_tree.py
@@ -0,0 +1,281 @@
+import sys, os.path as osp
+import typing
+
+sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
+from include import *
+
+
+class AVLTreeNode:
+    def __init__(
+        self,
+        val=None,
+        height: int = 0,
+        left: typing.Optional["AVLTreeNode"] = None,
+        right: typing.Optional["AVLTreeNode"] = None,
+    ):
+        self.val = val
+        self.height = height
+        self.left = left
+        self.right = right
+
+    def __str__(self):
+        val = self.val
+        left_val = self.left.val if self.left else None
+        right_val = self.right.val if self.right else None
+        return "<AVLTreeNode: {}, leftAVLTreeNode: {}, rightAVLTreeNode: {}>".format(
+            val, left_val, right_val
+        )
+
+
+class AVLTree:
+    def __init__(self, root: typing.Optional[AVLTreeNode] = None):
+        self.root = root
+
+    @staticmethod
+    def height(node: typing.Optional[AVLTreeNode]) -> int:
+        """
+        获取结点高度
+        Args:
+            node:起始结点
+
+        Returns: 高度 or -1
+
+        """
+        # 空结点高度为 -1 ，叶结点高度为 0
+        if node is not None:
+            return node.height
+        return -1
+
+    def __update_height(self, node: AVLTreeNode):
+        """
+        更新结点高度
+        Args:
+            node: 要更新高度的结点
+
+        Returns: None
+
+        """
+        # 结点高度等于最高子树高度 + 1
+        node.height = max([self.height(node.left), self.height(node.right)]) + 1
+
+    def balance_factor(self, node: AVLTreeNode) -> int:
+        """
+        获取结点平衡因子
+        Args:
+            node: 要获取平衡因子的结点
+
+        Returns: 平衡因子
+
+        """
+        # 空结点平衡因子为 0
+        if node is None:
+            return 0
+        # 结点平衡因子 = 左子树高度 - 右子树高度
+        return self.height(node.left) - self.height(node.right)
+
+    def __right_rotate(self, node: AVLTreeNode) -> AVLTreeNode:
+        child = node.left
+        grand_child = child.right
+        # 以 child 为原点，将 node 向右旋转
+        child.right = node
+        node.left = grand_child
+        # 更新结点高度
+        self.__update_height(node)
+        self.__update_height(child)
+        # 返回旋转后子树的根节点
+        return child
+
+    def __left_rotate(self, node: AVLTreeNode) -> AVLTreeNode:
+        child = node.right
+        grand_child = child.left
+        # 以 child 为原点，将 node 向左旋转
+        child.left = node
+        node.right = grand_child
+        # 更新结点高度
+        self.__update_height(node)
+        self.__update_height(child)
+        # 返回旋转后子树的根节点
+        return child
+
+    def rotate(self, node: AVLTreeNode):
+        """
+        执行旋转操作，使该子树重新恢复平衡
+        Args:
+            node: 要旋转的根结点
+
+        Returns: 旋转后的根结点
+
+        """
+        # 获取结点 node 的平衡因子
+        balance_factor = self.balance_factor(node)
+        # 左偏树
+        if balance_factor > 1:
+            if self.balance_factor(node.left) >= 0:
+                # 右旋
+                return self.__right_rotate(node)
+            else:
+                # 先左旋后右旋
+                node.left = self.__left_rotate(node.left)
+                return self.__right_rotate(node)
+        # 右偏树
+        elif balance_factor < -1:
+            if self.balance_factor(node.right) <= 0:
+                # 左旋
+                return self.__left_rotate(node)
+            else:
+                # 先右旋后左旋
+                node.right = self.__right_rotate(node.right)
+                return self.__left_rotate(node)
+        # 平衡树，无需旋转，直接返回
+        return node
+
+    def insert(self, val) -> AVLTreeNode:
+        """
+        插入结点
+        Args:
+            val: 结点的值
+
+        Returns:
+            node: 插入结点后的根结点
+        """
+        self.root = self.insert_helper(self.root, val)
+        return self.root
+
+    def insert_helper(
+        self, node: typing.Optional[AVLTreeNode], val: int
+    ) -> AVLTreeNode:
+        """
+        递归插入结点（辅助函数）
+        Args:
+            node: 要插入的根结点
+            val: 要插入的结点的值
+
+        Returns: 插入结点后的根结点
+
+        """
+        if node is None:
+            return AVLTreeNode(val)
+        # 1. 查找插入位置，并插入结点
+        if val < node.val:
+            node.left = self.insert_helper(node.left, val)
+        elif val > node.val:
+            node.right = self.insert_helper(node.right, val)
+        else:
+            # 重复结点不插入，直接返回
+            return node
+        # 更新结点高度
+        self.__update_height(node)
+        # 2. 执行旋转操作，使该子树重新恢复平衡
+        return self.rotate(node)
+
+    def remove(self, val: int):
+        """
+        删除结点
+        Args:
+            val: 要删除的结点的值
+
+        Returns:
+
+        """
+        root = self.remove_helper(self.root, val)
+        return root
+
+    def remove_helper(
+        self, node: typing.Optional[AVLTreeNode], val: int
+    ) -> typing.Optional[AVLTreeNode]:
+        """
+        递归删除结点（辅助函数）
+        Args:
+            node:  删除的起始结点
+            val: 要删除的结点的值
+
+        Returns: 删除目标结点后的起始结点
+
+        """
+        if node is None:
+            return None
+        # 1. 查找结点，并删除之
+        if val < node.val:
+            node.left = self.remove_helper(node.left, val)
+        elif val > node.val:
+            node.right = self.remove_helper(node.right, val)
+        else:
+            if node.left is None or node.right is None:
+                child = node.left or node.right
+                # 子结点数量 = 0 ，直接删除 node 并返回
+                if child is None:
+                    return None
+                # 子结点数量 = 1 ，直接删除 node
+                else:
+                    node = child
+            else:  # 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+                temp = self.min_node(node.right)
+                node.right = self.remove_helper(node.right, temp.val)
+                node.val = temp.val
+        # 更新结点高度
+        self.__update_height(node)
+        # 2. 执行旋转操作，使该子树重新恢复平衡
+        return self.rotate(node)
+
+    def min_node(
+        self, node: typing.Optional[AVLTreeNode]
+    ) -> typing.Optional[AVLTreeNode]:
+        # 获取最小结点
+        if node is None:
+            return None
+        # 循环访问左子结点，直到叶结点时为最小结点，跳出
+        while node.left is not None:
+            node = node.left
+        return node
+
+    def search(self, val: int):
+        cur = self.root
+        while cur is not None:
+            if cur.val < val:
+                cur = cur.right
+            elif cur.val > val:
+                cur = cur.left
+            else:
+                break
+        return cur
+
+
+if __name__ == "__main__":
+
+    def test_insert(tree: AVLTree, val: int):
+        tree.insert(val)
+        print("\n插入结点 {} 后，AVL 树为".format(val))
+        print_tree(tree.root)
+
+    def test_remove(tree: AVLTree, val: int):
+        tree.remove(val)
+        print("\n删除结点 {} 后，AVL 树为".format(val))
+        print_tree(tree.root)
+
+    # 初始化空 AVL 树
+    avl_tree = AVLTree()
+
+    # 插入结点
+    # 请关注插入结点后，AVL 树是如何保持平衡的
+    test_insert(avl_tree, 1)
+    test_insert(avl_tree, 2)
+    test_insert(avl_tree, 3)
+    test_insert(avl_tree, 4)
+    test_insert(avl_tree, 5)
+    test_insert(avl_tree, 8)
+    test_insert(avl_tree, 7)
+    test_insert(avl_tree, 9)
+    test_insert(avl_tree, 10)
+    test_insert(avl_tree, 6)
+
+    # 插入重复结点
+    test_insert(avl_tree, 7)
+
+    # 删除结点
+    # 请关注删除结点后，AVL 树是如何保持平衡的
+    test_remove(avl_tree, 8)  # 删除度为 0 的结点
+    test_remove(avl_tree, 5)  # 删除度为 1 的结点
+    test_remove(avl_tree, 4)  # 删除度为 2 的结点
+
+    result_node = avl_tree.search(7)
+    print("\n查找到的结点对象为 {}，结点值 = {}".format(result_node, result_node.val))
diff --git a/codes/python/chapter_tree/binary_search_tree.py b/codes/python/chapter_tree/binary_search_tree.py
index f9dd9ec95..211e7c0df 100644
--- a/codes/python/chapter_tree/binary_search_tree.py
+++ b/codes/python/chapter_tree/binary_search_tree.py
@@ -1,10 +1,173 @@
-'''
+"""
 File: binary_search_tree.py
 Created Time: 2022-11-25
 Author: Krahets (krahets@163.com)
-'''
+"""
 
 import sys, os.path as osp
+
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
+
+class BinarySearchTree:
+    """
+    二叉搜索树
+    """
+
+    def __init__(self, nums) -> None:
+        nums.sort()
+        self.__root = self.buildTree(nums, 0, len(nums) - 1)
+
+    def buildTree(self, nums, start_index, end_index):
+        if start_index > end_index:
+            return None
+        mid = (start_index + end_index) // 2
+        root = TreeNode(nums[mid])
+        root.left = self.buildTree(
+            nums=nums, start_index=start_index, end_index=mid - 1
+        )
+        root.right = self.buildTree(nums=nums, start_index=mid + 1, end_index=end_index)
+        return root
+
+    def get_root(self):
+        return self.__root
+
+    def search(self, num):
+        """
+        查找结点
+        """
+        cur = self.get_root()
+        # 循环查找，越过叶结点后跳出
+        while cur is not None:
+            # 目标结点在 root 的右子树中
+            if cur.val < num:
+                cur = cur.right
+            # 目标结点在 root 的左子树中
+            elif cur.val > num:
+                cur = cur.left
+            # 找到目标结点，跳出循环
+            else:
+                break
+        return cur
+
+    def insert(self, num):
+        """
+        插入结点
+        """
+        root = self.get_root()
+        # 若树为空，直接提前返回
+        if root is None:
+            return None
+
+        cur = root
+        pre = None
+
+        # 循环查找，越过叶结点后跳出
+        while cur is not None:
+            # 找到重复结点，直接返回
+            if cur.val == num:
+                return None
+            pre = cur
+
+            if cur.val < num:  # 插入位置在 root 的右子树中
+                cur = cur.right
+            else:  # 插入位置在 root 的左子树中
+                cur = cur.left
+
+        # 插入结点 val
+        node = TreeNode(num)
+        if pre.val < num:
+            pre.right = node
+        else:
+            pre.left = node
+        return node
+
+    def remove(self, num):
+        """
+        删除结点
+        """
+        root = self.get_root()
+        # 若树为空，直接提前返回
+        if root is None:
+            return None
+
+        cur = root
+        pre = None
+
+        # 循环查找，越过叶结点后跳出
+        while cur is not None:
+            # 找到待删除结点，跳出循环
+            if cur.val == num:
+                break
+            pre = cur
+            if cur.val < num:  # 待删除结点在 root 的右子树中
+                cur = cur.right
+            else:  # 待删除结点在 root 的左子树中
+                cur = cur.left
+
+        # 若无待删除结点，则直接返回
+        if cur is None:
+            return None
+
+        # 子结点数量 = 0 or 1
+        if cur.left is None or cur.right is None:
+            # 当子结点数量 = 0 / 1 时， child = null / 该子结点
+            child = cur.left or cur.right
+            # 删除结点 cur
+            if pre.left == cur:
+                pre.left = child
+            else:
+                pre.right = child
+        # 子结点数量 = 2
+        else:
+            # 获取中序遍历中 cur 的下一个结点
+            nex = self.min(cur.right)
+            tmp = nex.val
+            # 递归删除结点 nex
+            self.remove(nex.val)
+            # 将 nex 的值复制给 cur
+            cur.val = tmp
+        return cur
+
+    def min(self, root):
+        """
+        获取最小结点
+        """
+        if root is None:
+            return root
+
+        # 循环访问左子结点，直到叶结点时为最小结点，跳出
+        while root.left is not None:
+            root = root.left
+        return root
+
+
+if __name__ == "__main__":
+    # 初始化二叉搜索树
+    nums = list(range(1, 16))
+    bst = BinarySearchTree(nums=nums)
+    print("\n初始化的二叉树为\n")
+    print_tree(bst.get_root())
+
+    # 查找结点
+    node = bst.search(5)
+    print("\n查找到的结点对象为: {}，结点值 = {}".format(node, node.val))
+
+    # 插入结点
+    ndoe = bst.insert(16)
+    print("\n插入结点 16 后，二叉树为\n")
+    print_tree(bst.get_root())
+
+    # 删除结点
+    bst.remove(1)
+    print("\n删除结点 1 后，二叉树为\n")
+    print_tree(bst.get_root())
+
+    bst.remove(2)
+    print("\n删除结点 2 后，二叉树为\n")
+    print_tree(bst.get_root())
+
+    bst.remove(4)
+    print("\n删除结点 4 后，二叉树为\n")
+    print_tree(bst.get_root())
diff --git a/codes/python/chapter_tree/binary_tree.py b/codes/python/chapter_tree/binary_tree.py
index 78afa868e..2a892fae8 100644
--- a/codes/python/chapter_tree/binary_tree.py
+++ b/codes/python/chapter_tree/binary_tree.py
@@ -1,10 +1,38 @@
-'''
+"""
 File: binary_tree.py
 Created Time: 2022-11-25
 Author: Krahets (krahets@163.com)
-'''
+"""
 
 import sys, os.path as osp
+
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
+
+""" Driver Code """
+if __name__ == "__main__":
+    # 初始化二叉树
+    # 初始化节点
+    n1 = TreeNode(val=1)
+    n2 = TreeNode(val=2)
+    n3 = TreeNode(val=3)
+    n4 = TreeNode(val=4)
+    n5 = TreeNode(val=5)
+    n1.left = n2
+    n1.right = n3
+    n2.left = n4
+    n2.right = n5
+    print_tree(n1)
+
+    # 插入与删除结点
+    P = TreeNode(0)
+
+    # 在 n1 -> n2 中间插入节点 P
+    n1.left = P
+    P.left = n2
+    print_tree(n1)
+
+    # 删除结点
+    n1.left = n2
+    print_tree(n1)
diff --git a/codes/python/chapter_tree/binary_tree_bfs.py b/codes/python/chapter_tree/binary_tree_bfs.py
index 43f192206..57d15f919 100644
--- a/codes/python/chapter_tree/binary_tree_bfs.py
+++ b/codes/python/chapter_tree/binary_tree_bfs.py
@@ -1,10 +1,45 @@
-'''
+"""
 File: binary_tree_bfs.py
 Created Time: 2022-11-25
 Author: Krahets (krahets@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
+
+def hierOrder(root):
+    # 初始化队列，加入根结点
+    queue = collections.deque()
+    queue.append(root)
+    # 初始化一个列表，用于保存遍历序列
+    result = []
+    while queue:
+        # 队列出队
+        node = queue.popleft()
+        # 保存节点值
+        result.append(node.val)
+        if node.left is not None:
+            # 左子结点入队
+            queue.append(node.left)
+        if node.right is not None:
+            # 右子结点入队
+            queue.append(node.right)
+    return result
+
+
+""" Driver Code """
+if __name__ == "__main__":
+    # 初始化二叉树
+    # 这里借助了一个从数组直接生成二叉树的函数
+    root = list_to_tree(
+        arr=[1, 2, 3, 4, 5, 6, 7, None, None, None, None, None, None, None, None]
+    )
+    print("\n初始化二叉树\n")
+    print_tree(root)
+
+    # 层序遍历
+    result = hierOrder(root)
+    print("\n层序遍历的结点打印序列 = ", result)
+    assert result == [1, 2, 3, 4, 5, 6, 7]
\ No newline at end of file
diff --git a/codes/python/chapter_tree/binary_tree_dfs.py b/codes/python/chapter_tree/binary_tree_dfs.py
index f8415ef56..6c5b92a3f 100644
--- a/codes/python/chapter_tree/binary_tree_dfs.py
+++ b/codes/python/chapter_tree/binary_tree_dfs.py
@@ -1,10 +1,80 @@
-'''
+"""
 File: binary_tree_dfs.py
 Created Time: 2022-11-25
 Author: Krahets (krahets@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
+
+result = []
+
+
+def preOrder(root):
+    """
+    前序遍历二叉树
+    """
+    if root is None:
+        return
+
+    # 访问优先级：根结点 -> 左子树 -> 右子树
+    result.append(root.val)
+    preOrder(root=root.left)
+    preOrder(root=root.right)
+
+
+def inOrder(root):
+    """
+    中序遍历二叉树
+    """
+    if root is None:
+        return
+
+    # 访问优先级：左子树 -> 根结点 -> 右子树
+    inOrder(root=root.left)
+    result.append(root.val)
+    inOrder(root=root.right)
+
+
+def postOrder(root):
+    """
+    后序遍历二叉树
+    """
+    if root is None:
+        return
+
+    # 访问优先级：左子树 -> 右子树 -> 根结点
+    postOrder(root=root.left)
+    postOrder(root=root.right)
+    result.append(root.val)
+
+
+""" Driver Code """
+if __name__ == "__main__":
+    # 初始化二叉树
+    # 这里借助了一个从数组直接生成二叉树的函数
+    root = list_to_tree(
+        arr=[1, 2, 3, 4, 5, 6, 7, None, None, None, None, None, None, None, None]
+    )
+    print("\n初始化二叉树\n")
+    print_tree(root)
+
+    # 前序遍历
+    result = []
+    preOrder(root)
+    print("\n前序遍历的结点打印序列 = ", result)
+    assert result == [1, 2, 4, 5, 3, 6, 7]
+
+    # 中序遍历
+    result = []
+    inOrder(root)
+    print("\n中序遍历的结点打印序列 = ", result)
+    assert result == [4, 2, 5, 1, 6, 3, 7]
+
+    # 后序遍历
+    result = []
+    postOrder(root)
+    print("\n后序遍历的结点打印序列 = ", result)
+    assert result == [4, 5, 2, 6, 7, 3, 1]
\ No newline at end of file
diff --git a/codes/python/include/binary_tree.py b/codes/python/include/binary_tree.py
index 24acb47d4..bfe5b5f27 100644
--- a/codes/python/include/binary_tree.py
+++ b/codes/python/include/binary_tree.py
@@ -9,7 +9,7 @@ import collections
 class TreeNode:
     """Definition for a binary tree node
     """    
-    def __init__(self, val=0, left=None, right=None):
+    def __init__(self, val=None, left=None, right=None):
         self.val = val
         self.left = left
         self.right = right
diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md
index bfa2391de..ef88975b2 100644
--- a/docs/chapter_tree/avl_tree.md
+++ b/docs/chapter_tree/avl_tree.md
@@ -48,7 +48,24 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "Python"
 
     ```python title="avl_tree.py"
-    
+    class AVLTreeNode:
+        def __init__(
+                self,
+                val=None,
+                height: int = 0,
+                left: typing.Optional["AVLTreeNode"] = None,
+                right: typing.Optional["AVLTreeNode"] = None
+        ):
+            self.val = val
+            self.height = height
+            self.left = left
+            self.right = right
+
+        def __str__(self):
+            val = self.val
+            left_val = self.left.val if self.left else None
+            right_val = self.right.val if self.right else None
+            return "<AVLTreeNode: {}, leftAVLTreeNode: {}, rightAVLTreeNode: {}>".format(val, left_val, right_val)
     ```
 
 === "Go"
@@ -108,7 +125,31 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "Python"
 
     ```python title="avl_tree.py"
-    
+    def height(node: typing.Optional[AVLTreeNode]) -> int:
+        """
+        获取结点高度
+        Args:
+            node:起始结点 
+
+        Returns: 高度 or -1
+
+        """
+        # 空结点高度为 -1 ，叶结点高度为 0
+        if node is not None:
+            return node.height
+        return -1
+
+    def update_height(node: AVLTreeNode):
+        """
+        更新结点高度
+        Args:
+            node: 要更新高度的结点
+
+        Returns: None
+
+        """
+        # 结点高度等于最高子树高度 + 1
+        node.height = max([height(node.left), height(node.right)]) + 1
     ```
 
 === "Go"
@@ -166,7 +207,20 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "Python"
 
     ```python title="avl_tree.py"
-    
+    def balance_factor(node: AVLTreeNode) -> int:
+        """
+        获取结点平衡因子
+        Args:
+            node: 要获取平衡因子的结点
+
+        Returns: 平衡因子
+
+        """
+        # 空结点平衡因子为 0
+        if node is None:
+            return 0
+        # 结点平衡因子 = 左子树高度 - 右子树高度
+        return height(node.left) - height(node.right)
     ```
 
 === "Go"
@@ -255,7 +309,17 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Python"
 
     ```python title="avl_tree.py"
-    
+    def rightRotate(node: AVLTreeNode):
+        child = node.left
+        grand_child = child.right
+        # 以 child 为原点，将 node 向右旋转
+        child.right = node
+        node.left = grand_child
+        # 更新结点高度
+        update_height(node)
+        update_height(child)
+        # 返回旋转后子树的根节点
+        return child
     ```
 
 === "Go"
@@ -323,7 +387,17 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Python"
 
     ```python title="avl_tree.py"
-    
+    def leftRotate(node: AVLTreeNode):
+        child = node.right
+        grand_child = child.left
+        # 以 child 为原点，将 node 向左旋转
+        child.left = node
+        node.right = grand_child
+        # 更新结点高度
+        update_height(node)
+        update_height(child)
+        # 返回旋转后子树的根节点
+        return child
     ```
 
 === "Go"
@@ -432,7 +506,37 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Python"
 
     ```python title="avl_tree.py"
-    
+    def rotate(node: AVLTreeNode):
+        """
+        执行旋转操作，使该子树重新恢复平衡
+        Args:
+            node: 要旋转的根结点
+
+        Returns: 旋转后的根结点
+
+        """
+        # 获取结点 node 的平衡因子
+        factor = balance_factor(node)
+        # 左偏树
+        if factor > 1:
+            if balance_factor(node.left) >= 0:
+                # 右旋
+                return right_rotate(node)
+            else:
+                # 先左旋后右旋
+                node.left = left_rotate(node.left)
+                return right_rotate(node)
+        # 右偏树
+        elif factor < -1:
+            if balance_factor(node.right) <= 0:
+                # 左旋
+                return left_rotate(node)
+            else:
+                # 先右旋后左旋
+                node.right = right_rotate(node.right)
+                return left_rotate(node)
+        # 平衡树，无需旋转，直接返回
+        return node
     ```
 
 === "Go"
@@ -507,7 +611,42 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Python"
 
     ```python title="avl_tree.py"
-    
+    def insert(val) -> AVLTreeNode:
+        """
+        插入结点
+        Args:
+            val: 结点的值 
+
+        Returns:
+            node: 插入结点后的根结点
+        """
+        root = insert_helper(root, val)
+        return root
+
+    def insert_helper(node: typing.Optional[AVLTreeNode], val: int) -> AVLTreeNode:
+        """
+        递归插入结点（辅助函数）
+        Args:
+            node: 要插入的根结点
+            val: 要插入的结点的值
+
+        Returns: 插入结点后的根结点
+
+        """
+        if node is None:
+            return AVLTreeNode(val)
+        # 1. 查找插入位置，并插入结点
+        if val < node.val:
+            node.left = insert_helper(node.left, val)
+        elif val > node.val:
+            node.right = insert_helper(node.right, val)
+        else:
+            # 重复结点不插入，直接返回
+            return node
+        # 更新结点高度
+        update_height(node)
+        # 2. 执行旋转操作，使该子树重新恢复平衡
+        return rotate(node)
     ```
 
 === "Go"
@@ -604,7 +743,62 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Python"
 
     ```python title="avl_tree.py"
-    
+    def remove(val: int):
+        """
+        删除结点
+        Args:
+            val: 要删除的结点的值
+
+        Returns:
+
+        """
+        root = remove_helper(root, val)
+        return root
+
+    def remove_helper(node: typing.Optional[AVLTreeNode], val: int) -> typing.Optional[AVLTreeNode]:
+        """
+        递归删除结点（辅助函数）
+        Args:
+            node:  删除的起始结点
+            val: 要删除的结点的值
+
+        Returns: 删除目标结点后的起始结点
+
+        """
+        if node is None:
+            return None
+        # 1. 查找结点，并删除之
+        if val < node.val:
+            node.left = remove_helper(node.left, val)
+        elif val > node.val:
+            node.right = remove_helper(node.right, val)
+        else:
+            if node.left is None or node.right is None:
+                child = node.left or node.right
+                # 子结点数量 = 0 ，直接删除 node 并返回
+                if child is None:
+                    return None
+                # 子结点数量 = 1 ，直接删除 node
+                else:
+                    node = child
+            else: # 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+                temp = min_node(node.right)
+                node.right = remove_helper(node.right, temp.val)
+                node.val = temp.val
+        # 更新结点高度
+        update_height(node)
+        # 2. 执行旋转操作，使该子树重新恢复平衡
+        return rotate(node)
+
+
+    def min_node(node: typing.Optional[AVLTreeNode]) -> typing.Optional[AVLTreeNode]:
+        # 获取最小结点
+        if node is None:
+            return None
+        # 循环访问左子结点，直到叶结点时为最小结点，跳出
+        while node.left is not None:
+            node = node.left
+        return node
     ```
 
 === "Go"
diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md
index 9ff364329..a9328ddc6 100644
--- a/docs/chapter_tree/binary_search_tree.md
+++ b/docs/chapter_tree/binary_search_tree.md
@@ -82,6 +82,23 @@ comments: true
 === "Python"
 
     ```python title="binary_search_tree.py"
+    def search(self, num):
+        """
+        查找结点
+        """
+        cur = self.get_root()
+        # 循环查找，越过叶结点后跳出
+        while cur is not None:
+            # 目标结点在 root 的右子树中
+            if cur.val < num:
+                cur = cur.right
+            # 目标结点在 root 的左子树中
+            elif cur.val > num:
+                cur = cur.left
+            # 找到目标结点，跳出循环
+            else:
+                break
+        return cur
 
     ```
 
@@ -228,7 +245,37 @@ comments: true
 === "Python"
 
     ```python title="binary_search_tree.py"
+    def insert(self, num):
+        """
+        插入结点
+        """
+        root = self.get_root()
+        # 若树为空，直接提前返回
+        if root is None:
+            return None
 
+        cur = root
+        pre = None
+
+        # 循环查找，越过叶结点后跳出
+        while cur is not None:
+            # 找到重复结点，直接返回
+            if cur.val == num:
+                return None
+            pre = cur
+
+            if cur.val < num:  # 插入位置在 root 的右子树中
+                cur = cur.right
+            else:  # 插入位置在 root 的左子树中
+                cur = cur.left
+
+        # 插入结点 val
+        node = TreeNode(num)
+        if pre.val < num:
+            pre.right = node
+        else:
+            pre.left = node
+        return node
     ```
 
 === "Go"
@@ -483,7 +530,64 @@ comments: true
 === "Python"
 
     ```python title="binary_search_tree.py"
+    def remove(self, num):
+        """
+        删除结点
+        """
+        root = self.get_root()
+        # 若树为空，直接提前返回
+        if root is None:
+            return None
+        
+        cur = root
+        pre = None
 
+        # 循环查找，越过叶结点后跳出
+        while cur is not None:
+            # 找到待删除结点，跳出循环
+            if cur.val == num:
+                break
+            pre = cur
+            if cur.val < num:  # 待删除结点在 root 的右子树中
+                cur = cur.right
+            else:  # 待删除结点在 root 的左子树中
+                cur = cur.left
+
+        # 若无待删除结点，则直接返回
+        if cur is None:
+            return None
+
+        # 子结点数量 = 0 or 1
+        if cur.left is None or cur.right is None:
+            # 当子结点数量 = 0 / 1 时， child = null / 该子结点
+            child = cur.left or cur.right
+            # 删除结点 cur
+            if pre.left == cur:
+                pre.left = child
+            else:
+                pre.right = child
+        # 子结点数量 = 2
+        else:
+            # 获取中序遍历中 cur 的下一个结点
+            nex = self.min(cur.right)
+            tmp = nex.val
+            # 递归删除结点 nex
+            self.remove(nex.val)
+            # 将 nex 的值复制给 cur
+            cur.val =  tmp
+        return cur
+
+    def min(self, root):
+        """
+        获取最小结点
+        """
+        if root is None:
+            return root
+
+        # 循环访问左子结点，直到叶结点时为最小结点，跳出
+        while root.left is not None:
+            root = root.left
+        return root
     ```
 
 === "Go"
diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md
index 243a0753f..ab67e6f80 100644
--- a/docs/chapter_tree/binary_tree.md
+++ b/docs/chapter_tree/binary_tree.md
@@ -33,9 +33,9 @@ comments: true
 === "Python"
 
     ```python title=""
-    """ 链表结点类 """
     class TreeNode:
-        def __init__(self, val=0, left=None, right=None):
+        """ 链表结点类 """
+        def __init__(self, val=None, left=None, right=None):
             self.val = val      # 结点值
             self.left = left    # 左子结点指针
             self.right = right  # 右子结点指针
@@ -190,7 +190,18 @@ comments: true
 === "Python"
 
     ```python title="binary_tree.py"
-
+    # 初始化二叉树
+    # 初始化节点
+    n1 = TreeNode(val=1)
+    n2 = TreeNode(val=2)
+    n3 = TreeNode(val=3)
+    n4 = TreeNode(val=4)
+    n5 = TreeNode(val=5)
+    # 构建引用指向（即指针）
+    n1.left = n2
+    n1.right = n3
+    n2.left = n4
+    n2.right = n5
     ```
 
 === "Go"
@@ -288,7 +299,13 @@ comments: true
 === "Python"
 
     ```python title="binary_tree.py"
-
+    # 插入与删除结点
+    p = TreeNode(0)
+    # 在 n1 -> n2 中间插入结点 P
+    n1.left = p
+    p.left = n2
+    # 删除节点 P
+    n1.left = n2
     ```
 
 === "Go"
@@ -406,7 +423,24 @@ comments: true
 === "Python"
 
     ```python title="binary_tree_bfs.py"
-
+    def hierOrder(root):
+        # 初始化队列，加入根结点
+        queue = collections.deque()
+        queue.append(root)
+        # 初始化一个列表，用于保存遍历序列
+        result = []
+        while queue:
+            # 队列出队
+            node = queue.popleft()
+            # 保存节点值
+            result.append(node.val)
+            if node.left is not None:
+                # 左子结点入队
+                queue.append(node.left)
+            if node.right is not None:
+                # 右子结点入队
+                queue.append(node.right)
+        return result
     ```
 
 === "Go"
@@ -578,7 +612,43 @@ comments: true
 === "Python"
 
     ```python title="binary_tree_dfs.py"
+    def preOrder(root):
+        """
+        前序遍历二叉树
+        """
+        if root is None:
+            return
+        
+        # 访问优先级：根结点 -> 左子树 -> 右子树
+        result.append(root.val)
+        preOrder(root=root.left)
+        preOrder(root=root.right)
 
+
+    def inOrder(root):
+        """
+        中序遍历二叉树
+        """
+        if root is None:
+            return
+
+        # 访问优先级：左子树 -> 根结点 -> 右子树
+        inOrder(root=root.left)
+        result.append(root.val)
+        inOrder(root=root.right)
+
+
+    def postOrder(root):
+        """
+        后序遍历二叉树
+        """
+        if root is None:
+            return
+        
+        # 访问优先级：左子树 -> 右子树 -> 根结点
+        postOrder(root=root.left)
+        postOrder(root=root.right)
+        result.append(root.val)
     ```
 
 === "Go"

From 0a72d37578ccf799d6af4d7010b7f86bb7d7b69d Mon Sep 17 00:00:00 2001
From: Meng Du <du_0326_meng@163.com>
Date: Wed, 21 Dec 2022 18:57:28 +0800
Subject: [PATCH 002/158] create c folder and finished array

---
 codes/c/chapter_array_and_linkedlist/array.c | 124 +++++++++++++++++++
 codes/c/include/PrintUtil.h                  |  30 +++++
 codes/c/include/include.h                    |  11 ++
 3 files changed, 165 insertions(+)
 create mode 100644 codes/c/chapter_array_and_linkedlist/array.c
 create mode 100644 codes/c/include/PrintUtil.h
 create mode 100644 codes/c/include/include.h

diff --git a/codes/c/chapter_array_and_linkedlist/array.c b/codes/c/chapter_array_and_linkedlist/array.c
new file mode 100644
index 000000000..6217a566f
--- /dev/null
+++ b/codes/c/chapter_array_and_linkedlist/array.c
@@ -0,0 +1,124 @@
+/*
+ * File: array.c
+ * Created Time: 2022-12-20
+ * Author: MolDuM (moldum@163.com)
+ */
+
+#include "../include/include.h"
+
+/* 随机返回一个数组元素 */
+int randomAccess(int* nums, int size) {
+    // 在区间 [0, size) 中随机抽取一个数字
+    int randomIndex = rand() % size;
+    // 获取并返回随机元素
+    int randomNum = nums[randomIndex];
+    return randomNum;
+}
+
+/* 扩展数组长度 */
+int* extend(int* nums, int size, int enlarge) {
+    // 初始化一个扩展长度后的数组
+    int* res = (int *)malloc(sizeof(int) * (size + enlarge));
+    // 将原数组中的所有元素复制到新数组
+    for (int i = 0; i < size; i++) {
+        res[i] = nums[i];
+    }
+    // 初始化扩展后的空间
+    for (int i = size; i < size + enlarge; i++) {
+        res[i] = 0;
+    }
+    // 返回扩展后的新数组
+    return res;
+}
+
+/* 在数组的索引 index 处插入元素 num */
+void insert(int* nums, int size, int num, int index) {
+    // 把索引 index 以及之后的所有元素向后移动一位
+    for (int i = size - 1; i > index; i--) {
+        nums[i] = nums[i - 1];
+    }
+    // 将 num 赋给 index 处元素
+    nums[index] = num;
+}
+
+/* 删除索引 index 处元素 */
+void removeItem(int* nums, int size, int index) {
+    // 把索引 index 之后的所有元素向前移动一位
+    for (int i = index; i < size - 1; i++) {
+        nums[i] = nums[i + 1];
+    }
+}
+
+/* 遍历数组 */
+void traverse(int* nums, int size) {
+    int count = 0;
+    // 通过索引遍历数组
+    for (int i = 0; i < size; i++) {
+        count++;
+    }
+}
+
+/* 在数组中查找指定元素 */
+int find(int* nums, int size, int target) {
+    for (int i = 0; i < size; i++) {
+        if (nums[i] == target)
+            return i;
+    }
+    return -1;
+}
+
+
+/* Driver Code */
+int main() {
+    /* 初始化数组 */
+    int size = 5;
+    int arr[5];
+    printf("数组 arr = ");
+    printArray(arr, size);
+
+    int arr2[5] = { 1, 3, 2, 5, 4 };
+    printf("数组 arr2 = ");
+    printArray(arr2, size);
+
+    int* nums = (int *)malloc(sizeof(int) * size);
+    nums[0] = 1;
+    nums[1] = 3;
+    nums[2] = 2;
+    nums[3] = 5;
+    nums[4] = 4;
+    printf("数组 nums = ");
+    printArray(nums, size);
+    
+    /* 随机访问 */
+    int randomNum = randomAccess(nums, size);
+    printf("在 nums 中获取随机元素 %d", randomNum);
+    
+    /* 长度扩展 */
+    int enlarge = 3;
+    int* res = extend(nums, size, enlarge);
+    int* temp = nums;
+    nums = res;
+    free(temp);
+    size += enlarge;
+    printf("将数组长度扩展至 8 ，得到 nums = ");
+    printArray(nums, size);
+    
+    /* 插入元素 */
+    insert(nums, size, 6, 3);
+    printf("在索引 3 处插入数字 6 ，得到 nums = ");
+    printArray(nums, size);
+
+    /* 删除元素 */
+    removeItem(nums, size, 2);
+    printf("删除索引 2 处的元素，得到 nums = ");
+    printArray(nums, size);
+    
+    /* 遍历数组 */
+    traverse(nums, size);
+    
+    /* 查找元素 */
+    int index = find(nums, size, 3);
+    printf("在 nums 中查找元素 3 ，得到索引 = %d\n", index);
+
+    return 0;
+}
diff --git a/codes/c/include/PrintUtil.h b/codes/c/include/PrintUtil.h
new file mode 100644
index 000000000..e471f0388
--- /dev/null
+++ b/codes/c/include/PrintUtil.h
@@ -0,0 +1,30 @@
+/*
+ * File: PrintUtil.h
+ * Created Time: 2022-12-21
+ * Author: MolDum (moldum@163.com)
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+// #include "ListNode.h"
+// #include "TreeNode.h"
+
+/**
+ * @brief Print an Array
+ * 
+ * @param arr 
+ * @param n 
+ */
+
+static void printArray(int* arr, int n)
+{
+    printf("[");
+    for (int i = 0; i < n - 1; i++) {
+        printf("%d, ", arr[i]);
+    }
+    printf("%d]\n", arr[n-1]);
+}
+
+
diff --git a/codes/c/include/include.h b/codes/c/include/include.h
new file mode 100644
index 000000000..aba6b4924
--- /dev/null
+++ b/codes/c/include/include.h
@@ -0,0 +1,11 @@
+/*
+ * File: include.h
+ * Created Time: 2022-12-20
+ * Author: MolDuM (moldum@163.com)
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "PrintUtil.h"
\ No newline at end of file

From 770e3ca4ce052cba5936a9a0874cc2b64a1876e4 Mon Sep 17 00:00:00 2001
From: L-Super <40905056+L-Super@users.noreply.github.com>
Date: Mon, 26 Dec 2022 10:17:35 +0800
Subject: [PATCH 003/158] Update bubble_sort.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

C++使用std::swap()交换数组，同时添加C语言代码，作为原始C++代码的补充
---
 docs/chapter_sorting/bubble_sort.md | 49 ++++++++++++++++++++++++-----
 1 file changed, 41 insertions(+), 8 deletions(-)

diff --git a/docs/chapter_sorting/bubble_sort.md b/docs/chapter_sorting/bubble_sort.md
index f44b11924..522f17af5 100644
--- a/docs/chapter_sorting/bubble_sort.md
+++ b/docs/chapter_sorting/bubble_sort.md
@@ -85,9 +85,7 @@ comments: true
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
-                    int tmp = nums[j];
-                    nums[j] = nums[j + 1];
-                    nums[j + 1] = tmp;
+                    std::swap(nums[j], nums[j+1]);
                 }
             }
         }
@@ -170,7 +168,24 @@ comments: true
 === "C"
 
     ```c title="bubble_sort.c"
-
+    /* 冒泡排序 */
+    void bubble_sort(int nums[], int size)
+    {
+        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        for (int i = 0; i < size - 1; i++)
+        {
+            // 内循环：冒泡操作
+            for (int j = 0; j < size - 1 - i; j++)
+            {
+                if (nums[j] > nums[j + 1])
+                {
+                    int temp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = temp;
+                }
+            }
+        }
+    }
     ```
 
 === "C#"
@@ -250,9 +265,7 @@ comments: true
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
-                    int tmp = nums[j];
-                    nums[j] = nums[j + 1];
-                    nums[j + 1] = tmp;
+                    std::swap(nums[j], nums[j+1]);
                     flag = true;  // 记录交换元素
                 }
             }
@@ -352,7 +365,27 @@ comments: true
 === "C"
 
     ```c title="bubble_sort.c"
-
+    /* 冒泡排序 */
+    void bubble_sort(int nums[], int size)
+    {
+        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        for (int i = 0; i < size - 1; i++)
+        {
+            bool flag = false;
+            // 内循环：冒泡操作
+            for (int j = 0; j < size - 1 - i; j++)
+            {
+                if (nums[j] > nums[j + 1])
+                {
+                    int temp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = temp;
+                    flag = true;
+                }
+            }
+            if(!falg) break;
+        }
+    }
     ```
 
 === "C#"

From 75be76cebeaa6f6458349d69c5e1885cff613646 Mon Sep 17 00:00:00 2001
From: L-Super <40905056+L-Super@users.noreply.github.com>
Date: Mon, 26 Dec 2022 12:11:21 +0800
Subject: [PATCH 004/158] Update bubble_sort.md

fixed `falg` to `flag`
---
 docs/chapter_sorting/bubble_sort.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/chapter_sorting/bubble_sort.md b/docs/chapter_sorting/bubble_sort.md
index 522f17af5..f71dce77d 100644
--- a/docs/chapter_sorting/bubble_sort.md
+++ b/docs/chapter_sorting/bubble_sort.md
@@ -383,7 +383,7 @@ comments: true
                     flag = true;
                 }
             }
-            if(!falg) break;
+            if(!flag) break;
         }
     }
     ```

From 2ee6fcfef114070012cdb5bb35cdaed25bd7af7a Mon Sep 17 00:00:00 2001
From: Listening <120311070@qq.com>
Date: Mon, 26 Dec 2022 12:43:37 +0800
Subject: [PATCH 005/158] add bubble sort in C code

---
 codes/c/chapter_sorting/bubble_sort.c | 72 +++++++++++++++++++++++++++
 codes/c/include/include.h             |  2 +
 2 files changed, 74 insertions(+)
 create mode 100644 codes/c/chapter_sorting/bubble_sort.c
 create mode 100644 codes/c/include/include.h

diff --git a/codes/c/chapter_sorting/bubble_sort.c b/codes/c/chapter_sorting/bubble_sort.c
new file mode 100644
index 000000000..3d23a5420
--- /dev/null
+++ b/codes/c/chapter_sorting/bubble_sort.c
@@ -0,0 +1,72 @@
+/**
+ * @file bubble_sort.c
+ * @author Listening (https://github.com/L-Super)
+ * @brief
+ * @date 2022-12-26
+ *
+ */
+
+#include "../include/include.h"
+
+/* 冒泡排序 */
+void bubble_sort(int nums[], int size)
+{
+    // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+    for (int i = 0; i < size - 1; i++)
+    {
+        // 内循环：冒泡操作
+        for (int j = 0; j < size - 1 - i; j++)
+        {
+            if (nums[j] > nums[j + 1])
+            {
+                int temp = nums[j];
+                nums[j] = nums[j + 1];
+                nums[j + 1] = temp;
+            }
+        }
+    }
+}
+
+/* 冒泡排序（标志优化）*/
+void bubble_sort_with_flag(int nums[], int size)
+{
+    // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+    for (int i = 0; i < size - 1; i++)
+    {
+        bool flag = false;
+        // 内循环：冒泡操作
+        for (int j = 0; j < size - 1 - i; j++)
+        {
+            if (nums[j] > nums[j + 1])
+            {
+                int temp = nums[j];
+                nums[j] = nums[j + 1];
+                nums[j + 1] = temp;
+                flag = true;
+            }
+        }
+        if (!flag)
+            break;
+    }
+}
+
+int main()
+{
+    int nums[6] = {4, 1, 3, 1, 5, 2};
+    printf("冒泡排序后:\n");
+    bubble_sort(nums, 6);
+    for (int i = 0; i < 6; i++)
+    {
+        printf("%d ", nums[i]);
+    }
+
+    printf("优化版冒泡排序后:\n");
+    bubble_sort_with_flag(nums, 6);
+    for (int i = 0; i < 6; i++)
+    {
+        printf("%d ", nums[i]);
+    }
+    printf("\n");
+
+    return 0;
+}
\ No newline at end of file
diff --git a/codes/c/include/include.h b/codes/c/include/include.h
new file mode 100644
index 000000000..44843254e
--- /dev/null
+++ b/codes/c/include/include.h
@@ -0,0 +1,2 @@
+#include <stdio.h>
+#include <stdbool.h>
\ No newline at end of file

From edf1029ac4e59aa923f59ba0508bbea4eda5185d Mon Sep 17 00:00:00 2001
From: Listening <120311070@qq.com>
Date: Mon, 26 Dec 2022 13:34:50 +0800
Subject: [PATCH 006/158] fixed the format of the file header

---
 codes/c/chapter_sorting/bubble_sort.c | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/codes/c/chapter_sorting/bubble_sort.c b/codes/c/chapter_sorting/bubble_sort.c
index 3d23a5420..f59b81d00 100644
--- a/codes/c/chapter_sorting/bubble_sort.c
+++ b/codes/c/chapter_sorting/bubble_sort.c
@@ -1,9 +1,7 @@
 /**
- * @file bubble_sort.c
- * @author Listening (https://github.com/L-Super)
- * @brief
- * @date 2022-12-26
- *
+ * File: bubble_sort.c
+ * Created Time: 2022-12-26
+ * Author: Listening (https://github.com/L-Super)
  */
 
 #include "../include/include.h"

From ae9b010894caeecef658dd47c0cd7e524f98fef8 Mon Sep 17 00:00:00 2001
From: nuomi1 <nuomi1@qq.com>
Date: Mon, 26 Dec 2022 23:28:45 +0800
Subject: [PATCH 007/158] feat: add Swift installation

---
 docs/chapter_preface/installation.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/docs/chapter_preface/installation.md b/docs/chapter_preface/installation.md
index b58457c7d..c6c1b2ee9 100644
--- a/docs/chapter_preface/installation.md
+++ b/docs/chapter_preface/installation.md
@@ -41,3 +41,8 @@ comments: true
 
 1. 下载并安装 [.Net 6.0](https://dotnet.microsoft.com/en-us/download) ；
 2. 在 VSCode 的插件市场中搜索 `c#` ，安装 c# 。
+
+## Swift 环境
+
+1. 下载并安装 [Swift](https://www.swift.org/download/)；
+2. 在 VSCode 的插件市场中搜索 `swift`，安装 [Swift for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=sswg.swift-lang)。

From 7e1ff8f74177be403888bbf6a10a3e0d2ab0ac4c Mon Sep 17 00:00:00 2001
From: nuomi1 <nuomi1@qq.com>
Date: Mon, 26 Dec 2022 23:29:37 +0800
Subject: [PATCH 008/158] feat: add Swift codes for time complexity article

---
 .../time_complexity.swift                     | 170 +++++++++++
 .../worst_best_time_complexity.swift          |  37 +++
 .../time_complexity.md                        | 276 ++++++++++++++++++
 3 files changed, 483 insertions(+)
 create mode 100644 codes/swift/chapter_computational_complexity/time_complexity.swift
 create mode 100644 codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift

diff --git a/codes/swift/chapter_computational_complexity/time_complexity.swift b/codes/swift/chapter_computational_complexity/time_complexity.swift
new file mode 100644
index 000000000..38bac4fae
--- /dev/null
+++ b/codes/swift/chapter_computational_complexity/time_complexity.swift
@@ -0,0 +1,170 @@
+/*
+ * File: time_complexity.swift
+ * Created Time: 2022-12-26
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+// 常数阶
+func constant(n: Int) -> Int {
+    var count = 0
+    let size = 100_000
+    for _ in 0 ..< size {
+        count += 1
+    }
+    return count
+}
+
+// 线性阶
+func linear(n: Int) -> Int {
+    var count = 0
+    for _ in 0 ..< n {
+        count += 1
+    }
+    return count
+}
+
+// 线性阶（遍历数组）
+func arrayTraversal(nums: [Int]) -> Int {
+    var count = 0
+    // 循环次数与数组长度成正比
+    for _ in nums {
+        count += 1
+    }
+    return count
+}
+
+// 平方阶
+func quadratic(n: Int) -> Int {
+    var count = 0
+    // 循环次数与数组长度成平方关系
+    for _ in 0 ..< n {
+        for _ in 0 ..< n {
+            count += 1
+        }
+    }
+    return count
+}
+
+// 平方阶（冒泡排序）
+func bubbleSort(nums: inout [Int]) -> Int {
+    var count = 0 // 计数器
+    // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+    for i in sequence(first: nums.count - 1, next: { $0 > 0 ? $0 - 1 : nil }) {
+        // 内循环：冒泡操作
+        for j in 0 ..< i {
+            if nums[j] > nums[j + 1] {
+                // 交换 nums[j] 与 nums[j + 1]
+                let tmp = nums[j]
+                nums[j] = nums[j + 1]
+                nums[j + 1] = tmp
+                count += 3 // 元素交换包含 3 个单元操作
+            }
+        }
+    }
+    return count
+}
+
+// 指数阶（循环实现）
+func exponential(n: Int) -> Int {
+    var count = 0
+    var base = 1
+    // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+    for _ in 0 ..< n {
+        for _ in 0 ..< base {
+            count += 1
+        }
+        base *= 2
+    }
+    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+    return count
+}
+
+// 指数阶（递归实现）
+func expRecur(n: Int) -> Int {
+    if n == 1 {
+        return 1
+    }
+    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1
+}
+
+// 对数阶（循环实现）
+func logarithmic(n: Int) -> Int {
+    var count = 0
+    var n = n
+    while n > 1 {
+        n = n / 2
+        count += 1
+    }
+    return count
+}
+
+// 对数阶（递归实现）
+func logRecur(n: Int) -> Int {
+    if n <= 1 {
+        return 0
+    }
+    return logRecur(n: n / 2) + 1
+}
+
+// 线性对数阶
+func linearLogRecur(n: Double) -> Int {
+    if n <= 1 {
+        return 1
+    }
+    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)
+    for _ in 0 ..< Int(n) {
+        count += 1
+    }
+    return count
+}
+
+// 阶乘阶（递归实现）
+func factorialRecur(n: Int) -> Int {
+    if n == 0 {
+        return 1
+    }
+    var count = 0
+    // 从 1 个分裂出 n 个
+    for _ in 0 ..< n {
+        count += factorialRecur(n: n - 1)
+    }
+    return count
+}
+
+func main() {
+    // 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
+    let n = 8
+    print("输入数据大小 n =", n)
+
+    var count = constant(n: n)
+    print("常数阶的计算操作数量 =", count)
+
+    count = linear(n: n)
+    print("线性阶的计算操作数量 =", count)
+    count = arrayTraversal(nums: Array(repeating: 0, count: n))
+    print("线性阶（遍历数组）的计算操作数量 =", count)
+
+    count = quadratic(n: n)
+    print("平方阶的计算操作数量 =", count)
+    var nums = Array(sequence(first: n, next: { $0 > 0 ? $0 - 1 : nil })) // [n,n-1,...,2,1]
+    count = bubbleSort(nums: &nums)
+    print("平方阶（冒泡排序）的计算操作数量 =", count)
+
+    count = exponential(n: n)
+    print("指数阶（循环实现）的计算操作数量 =", count)
+    count = expRecur(n: n)
+    print("指数阶（递归实现）的计算操作数量 =", count)
+
+    count = logarithmic(n: n)
+    print("对数阶（循环实现）的计算操作数量 =", count)
+    count = logRecur(n: n)
+    print("对数阶（递归实现）的计算操作数量 =", count)
+
+    count = linearLogRecur(n: Double(n))
+    print("线性对数阶（递归实现）的计算操作数量 =", count)
+
+    count = factorialRecur(n: n)
+    print("阶乘阶（递归实现）的计算操作数量 =", count)
+}
+
+main()
diff --git a/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift b/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift
new file mode 100644
index 000000000..73db6954d
--- /dev/null
+++ b/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift
@@ -0,0 +1,37 @@
+/*
+ * File: worst_best_time_complexity.swift
+ * Created Time: 2022-12-26
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+// 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱
+func randomNumbers(n: Int) -> [Int] {
+    // 生成数组 nums = { 1, 2, 3, ..., n }
+    var nums = Array(1 ... n)
+    // 随机打乱数组元素
+    nums.shuffle()
+    return nums
+}
+
+// 查找数组 nums 中数字 1 所在索引
+func findOne(nums: [Int]) -> Int {
+    for i in nums.indices {
+        if nums[i] == 1 {
+            return i
+        }
+    }
+    return -1
+}
+
+// Driver Code
+func main() {
+    for _ in 0 ..< 10 {
+        let n = 100
+        let nums = randomNumbers(n: n)
+        let index = findOne(nums: nums)
+        print("数组 [ 1, 2, ..., n ] 被打乱后 =", nums)
+        print("数字 1 的索引为", index)
+    }
+}
+
+main()
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 8841a613c..aafb0d893 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -111,6 +111,21 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    // 在某运行平台下
+    func algorithm(_ n: Int) {
+        var a = 2 // 1 ns
+        a = a + 1 // 1 ns
+        a = a * 2 // 10 ns
+        // 循环 n 次
+        for _ in 0 ..< n { // 1 ns
+            print(0) // 5 ns
+        }
+    }
+    ```
+
 但实际上， **统计算法的运行时间既不合理也不现实。** 首先，我们不希望预估时间和运行平台绑定，毕竟算法需要跑在各式各样的平台之上。其次，我们很难获知每一种操作的运行时间，这为预估过程带来了极大的难度。
 
 ## 统计时间增长趋势
@@ -246,6 +261,29 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    // 算法 A 时间复杂度：常数阶
+    func algorithmA(_ n: Int) {
+        print(0)
+    }
+
+    // 算法 B 时间复杂度：线性阶
+    func algorithmB(_ n: Int) {
+        for _ in 0 ..< n {
+            print(0)
+        }
+    }
+
+    // 算法 C 时间复杂度：常数阶
+    func algorithmC(_ n: Int) {
+        for _ in 0 ..< 1000000 {
+            print(0)
+        }
+    }
+    ```
+
 ![time_complexity_first_example](time_complexity.assets/time_complexity_first_example.png)
 
 <p align="center"> Fig. 算法 A, B, C 的时间增长趋势 </p>
@@ -352,6 +390,20 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    func algorithm(n: Int) {
+        var a = 1 // +1
+        a = a + 1 // +1
+        a = a * 2 // +1
+        // 循环 n 次
+        for _ in 0 ..< n { // +1
+            print(0) // +1
+        }
+    }
+    ```
+
 $T(n)$ 是个一次函数，说明时间增长趋势是线性的，因此易得时间复杂度是线性阶。
 
 我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号被称为「大 $O$ 记号 Big-$O$ Notation」，代表函数 $T(n)$ 的「渐近上界 asymptotic upper bound」。
@@ -516,6 +568,25 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    func algorithm(n: Int) {
+        var a = 1 // +0（技巧 1）
+        a = a + n // +0（技巧 1）
+        // +n（技巧 2）
+        for _ in 0 ..< (5 * n + 1) {
+            print(0)
+        }
+        // +n*n（技巧 3）
+        for _ in 0 ..< (2 * n) {
+            for _ in 0 ..< (n + 1) {
+                print(0)
+            }
+        }
+    }
+    ```
+
 ### 2. 判断渐近上界
 
 **时间复杂度由多项式 $T(n)$ 中最高阶的项来决定**。这是因为在 $n$ 趋于无穷大时，最高阶的项将处于主导作用，其它项的影响都可以被忽略。
@@ -643,6 +714,20 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="time_complexity.swift"
+    // 常数阶
+    func constant(n: Int) -> Int {
+        var count = 0
+        let size = 100000
+        for _ in 0 ..< size {
+            count += 1
+        }
+        return count
+    }
+    ```
+
 ### 线性阶 $O(n)$
 
 线性阶的操作数量相对输入数据大小成线性级别增长。线性阶常出现于单层循环。
@@ -726,6 +811,19 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="time_complexity.swift"
+    // 线性阶
+    func linear(n: Int) -> Int {
+        var count = 0
+        for _ in 0 ..< n {
+            count += 1
+        }
+        return count
+    }
+    ```
+
 「遍历数组」和「遍历链表」等操作，时间复杂度都为 $O(n)$ ，其中 $n$ 为数组或链表的长度。
 
 !!! tip
@@ -820,6 +918,20 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="time_complexity.swift"
+    // 线性阶（遍历数组）
+    func arrayTraversal(nums: [Int]) -> Int {
+        var count = 0
+        // 循环次数与数组长度成正比
+        for _ in nums {
+            count += 1
+        }
+        return count
+    }
+    ```
+
 ### 平方阶 $O(n^2)$
 
 平方阶的操作数量相对输入数据大小成平方级别增长。平方阶常出现于嵌套循环，外层循环和内层循环都为 $O(n)$ ，总体为 $O(n^2)$ 。
@@ -922,6 +1034,22 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="time_complexity.swift"
+    // 平方阶
+    func quadratic(n: Int) -> Int {
+        var count = 0
+        // 循环次数与数组长度成平方关系
+        for _ in 0 ..< n {
+            for _ in 0 ..< n {
+                count += 1
+            }
+        }
+        return count
+    }
+    ```
+
 ![time_complexity_constant_linear_quadratic](time_complexity.assets/time_complexity_constant_linear_quadratic.png)
 
 <p align="center"> Fig. 常数阶、线性阶、平方阶的时间复杂度 </p>
@@ -1066,6 +1194,29 @@ $$
 
     ```
 
+=== "Swift"
+
+    ```swift title="time_complexity.swift"
+    // 平方阶（冒泡排序）
+    func bubbleSort(nums: inout [Int]) -> Int {
+        var count = 0 // 计数器
+        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        for i in sequence(first: nums.count - 1, next: { $0 > 0 ? $0 - 1 : nil }) {
+            // 内循环：冒泡操作
+            for j in 0 ..< i {
+                if nums[j] > nums[j + 1] {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j]
+                    nums[j] = nums[j + 1]
+                    nums[j + 1] = tmp
+                    count += 3 // 元素交换包含 3 个单元操作
+                }
+            }
+        }
+        return count
+    }
+    ```
+
 ### 指数阶 $O(2^n)$
 
 !!! note
@@ -1182,6 +1333,25 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="time_complexity.swift"
+    // 指数阶（循环实现）
+    func exponential(n: Int) -> Int {
+        var count = 0
+        var base = 1
+        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        for _ in 0 ..< n {
+            for _ in 0 ..< base {
+                count += 1
+            }
+            base *= 2
+        }
+        // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+        return count
+    }
+    ```
+
 ![time_complexity_exponential](time_complexity.assets/time_complexity_exponential.png)
 
 <p align="center"> Fig. 指数阶的时间复杂度 </p>
@@ -1258,6 +1428,18 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="time_complexity.swift"
+    // 指数阶（递归实现）
+    func expRecur(n: Int) -> Int {
+        if n == 1 {
+            return 1
+        }
+        return expRecur(n: n - 1) + expRecur(n: n - 1) + 1
+    }
+    ```
+
 ### 对数阶 $O(\log n)$
 
 对数阶与指数阶正好相反，后者反映“每轮增加到两倍的情况”，而前者反映“每轮缩减到一半的情况”。对数阶仅次于常数阶，时间增长的很慢，是理想的时间复杂度。
@@ -1354,6 +1536,21 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="time_complexity.swift"
+    // 对数阶（循环实现）
+    func logarithmic(n: Int) -> Int {
+        var count = 0
+        var n = n
+        while n > 1 {
+            n = n / 2
+            count += 1
+        }
+        return count
+    }
+    ```
+
 ![time_complexity_logarithmic](time_complexity.assets/time_complexity_logarithmic.png)
 
 <p align="center"> Fig. 对数阶的时间复杂度 </p>
@@ -1430,6 +1627,18 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="time_complexity.swift"
+    // 对数阶（递归实现）
+    func logRecur(n: Int) -> Int {
+        if n <= 1 {
+            return 0
+        }
+        return logRecur(n: n / 2) + 1
+    }
+    ```
+
 ### 线性对数阶 $O(n \log n)$
 
 线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。
@@ -1531,6 +1740,22 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="time_complexity.swift"
+    // 线性对数阶
+    func linearLogRecur(n: Double) -> Int {
+        if n <= 1 {
+            return 1
+        }
+        var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)
+        for _ in 0 ..< Int(n) {
+            count += 1
+        }
+        return count
+    }
+    ```
+
 ![time_complexity_logarithmic_linear](time_complexity.assets/time_complexity_logarithmic_linear.png)
 
 <p align="center"> Fig. 线性对数阶的时间复杂度 </p>
@@ -1640,6 +1865,23 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="time_complexity.swift"
+    // 阶乘阶（递归实现）
+    func factorialRecur(n: Int) -> Int {
+        if n == 0 {
+            return 1
+        }
+        var count = 0
+        // 从 1 个分裂出 n 个
+        for _ in 0 ..< n {
+            count += factorialRecur(n: n - 1)
+        }
+        return count
+    }
+    ```
+
 ![time_complexity_factorial](time_complexity.assets/time_complexity_factorial.png)
 
 <p align="center"> Fig. 阶乘阶的时间复杂度 </p>
@@ -1872,6 +2114,40 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    // 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱
+    func randomNumbers(n: Int) -> [Int] {
+        // 生成数组 nums = { 1, 2, 3, ..., n }
+        var nums = Array(1 ... n)
+        // 随机打乱数组元素
+        nums.shuffle()
+        return nums
+    }
+
+    // 查找数组 nums 中数字 1 所在索引
+    func findOne(nums: [Int]) -> Int {
+        for i in nums.indices {
+            if nums[i] == 1 {
+                return i
+            }
+        }
+        return -1
+    }
+
+    // Driver Code
+    func main() {
+        for _ in 0 ..< 10 {
+            let n = 100
+            let nums = randomNumbers(n: n)
+            let index = findOne(nums: nums)
+            print("数组 [ 1, 2, ..., n ] 被打乱后 =", nums)
+            print("数字 1 的索引为", index)
+        }
+    }
+    ```
+
 !!! tip
 
     我们在实际应用中很少使用「最佳时间复杂度」，因为往往只有很小概率下才能达到，会带来一定的误导性。反之，「最差时间复杂度」最为实用，因为它给出了一个“效率安全值”，让我们可以放心地使用算法。

From 845a68d6f1cc932a6057a8624ebb886ac614b8ee Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 09:30:20 +1100
Subject: [PATCH 009/158] Add the TypeScript code and docs for Chapter of
 Binary Search

---
 docs/chapter_searching/binary_search.md | 59 ++++++++++++++++++++-----
 1 file changed, 47 insertions(+), 12 deletions(-)

diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
index a74c07aaf..32ae411c0 100644
--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@@ -116,17 +116,17 @@ $$
 === "Go"
 
     ```go title="binary_search.go"
-    /* 二分查找（左闭右开） */
-    func binarySearch1(nums []int, target int) int {
-        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
-        i, j := 0, len(nums)
-        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
-        for i < j {
+    /* 二分查找（双闭区间） */
+    func binarySearch(nums []int, target int) int {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        i, j := 0, len(nums)-1
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        for i <= j {
             m := (i + j) / 2                // 计算中点索引 m
-            if nums[m] < target {           // 此情况说明 target 在区间 [m+1, j) 中
+            if nums[m] < target {           // 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1
-            } else if nums[m] > target {    // 此情况说明 target 在区间 [i, m) 中
-                j = m
+            } else if nums[m] > target {    // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1
             } else {                        // 找到目标元素，返回其索引
                 return m
             }
@@ -161,7 +161,23 @@ $$
 === "TypeScript"
 
     ```typescript title="binary_search.ts"
-
+    /* 二分查找（左闭右开） */
+    const binarySearch1 = function (nums: number[], target: number): number {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        let i = 0, j = nums.length;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            let m = Math.floor(i + (j - i) / 2);    // 计算中点索引 m
+            if (nums[m] < target) {                 // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            } else if (nums[m] > target) {          // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            } else {                                // 找到目标元素，返回其索引
+                return m;
+            }
+        }
+        return -1; // 未找到目标元素，返回 -1
+    }
     ```
 
 === "C"
@@ -309,7 +325,23 @@ $$
 === "TypeScript"
 
     ```typescript title="binary_search.ts"
-
+    /* 二分查找（左闭右开） */
+    const binarySearch1 = function (nums: number[], target: number): number {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        let i = 0, j = nums.length;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            let m = Math.floor(i + (j - i) / 2);    // 计算中点索引 m
+            if (nums[m] < target) {                 // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            } else if (nums[m] > target) {          // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            } else {                                // 找到目标元素，返回其索引
+                return m;
+            }
+        }
+        return -1; // 未找到目标元素，返回 -1
+    }
     ```
 
 === "C"
@@ -407,7 +439,10 @@ $$
 === "TypeScript"
 
     ```typescript title=""
-
+    // (i + j) 有可能超出 Number 的取值范围
+    let m = Math.floor((i + j) / 2);
+    // 更换为此写法则不会越界
+    let m = Math.floor(i + (j - i) / 2);
     ```
 
 === "C"

From 67d7cba977e0f97b3a648ea53fdd2011bc50a95b Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 09:30:34 +1100
Subject: [PATCH 010/158] Add the TypeScript code and docs for Chapter of
 Binary Search

---
 .editorconfig                                 | 16 ++++++
 .../chapter_searching/binary_search.ts        | 54 +++++++++++++++++++
 2 files changed, 70 insertions(+)
 create mode 100644 .editorconfig
 create mode 100644 codes/typescript/chapter_searching/binary_search.ts

diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 000000000..53ad327c8
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,16 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+# Matches multiple files with brace expansion notation
+# Set default charset
+[*.{ts,js,py,java,go,c,cpp,cs}]
+charset = utf-8
+
+# 4 space indentation
+[*.{ts,js,py,java,go,c,cpp,cs}]
+indent_style = space
+indent_size = 4
\ No newline at end of file
diff --git a/codes/typescript/chapter_searching/binary_search.ts b/codes/typescript/chapter_searching/binary_search.ts
new file mode 100644
index 000000000..0a96720d9
--- /dev/null
+++ b/codes/typescript/chapter_searching/binary_search.ts
@@ -0,0 +1,54 @@
+/*
+* File: binary_search.ts
+* Created Time: 2022-12-27
+* Author: Daniel (better.sunjian@gmail.com)
+*/
+
+/* 二分查找（双闭区间） */
+const binarySearch = function (nums: number[], target: number): number {
+    // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+    let i = 0, j = nums.length - 1;
+    // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+    while (i <= j) {
+        let m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
+        if (nums[m] < target) {        // 此情况说明 target 在区间 [m+1, j] 中
+            i = m + 1;
+        } else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m-1] 中
+            j = m - 1;
+        } else {                       // 找到目标元素，返回其索引
+            return m;
+        }
+    }
+    return -1; // 未找到目标元素，返回 -1
+}
+
+/* 二分查找（左闭右开） */
+const binarySearch1 = function (nums: number[], target: number): number {
+    // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+    let i = 0, j = nums.length;
+    // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+    while (i < j) {
+        const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
+        if (nums[m] < target) {        // 此情况说明 target 在区间 [m+1, j) 中
+            i = m + 1;
+        } else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m) 中
+            j = m;
+        } else {                       // 找到目标元素，返回其索引
+            return m;
+        }
+    }
+    return -1; // 未找到目标元素，返回 -1
+}
+
+
+/* Driver Code */
+const target = 6;
+const nums = [ 1, 3, 6, 8, 12, 15, 23, 67, 70, 92 ];
+
+/* 二分查找（双闭区间） */
+let index = binarySearch(nums, target);
+console.info('目标元素 6 的索引 = %d', index);
+
+/* 二分查找（左闭右开） */
+index = binarySearch1(nums, target);
+console.info('目标元素 6 的索引 = %d', index);

From 6264edcadb9af2692ac10c7b61ddf31478a29e43 Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 09:35:08 +1100
Subject: [PATCH 011/158] Removed .editorconfig

---
 .editorconfig | 16 ----------------
 1 file changed, 16 deletions(-)
 delete mode 100644 .editorconfig

diff --git a/.editorconfig b/.editorconfig
deleted file mode 100644
index 53ad327c8..000000000
--- a/.editorconfig
+++ /dev/null
@@ -1,16 +0,0 @@
-# EditorConfig is awesome: https://EditorConfig.org
-
-# Unix-style newlines with a newline ending every file
-[*]
-end_of_line = lf
-insert_final_newline = true
-
-# Matches multiple files with brace expansion notation
-# Set default charset
-[*.{ts,js,py,java,go,c,cpp,cs}]
-charset = utf-8
-
-# 4 space indentation
-[*.{ts,js,py,java,go,c,cpp,cs}]
-indent_style = space
-indent_size = 4
\ No newline at end of file

From e0d3572a47295831ae5445c4f950a41ca4b3c9bb Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 09:45:33 +1100
Subject: [PATCH 012/158] Fixed format of doc

---
 docs/chapter_searching/binary_search.md | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
index 32ae411c0..a059d75da 100644
--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@@ -161,18 +161,18 @@ $$
 === "TypeScript"
 
     ```typescript title="binary_search.ts"
-    /* 二分查找（左闭右开） */
-    const binarySearch1 = function (nums: number[], target: number): number {
-        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
-        let i = 0, j = nums.length;
-        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
-        while (i < j) {
-            let m = Math.floor(i + (j - i) / 2);    // 计算中点索引 m
-            if (nums[m] < target) {                 // 此情况说明 target 在区间 [m+1, j) 中
+    /* 二分查找（双闭区间） */
+    const binarySearch = function (nums: number[], target: number): number {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        let i = 0, j = nums.length - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            let m = Math.floor(i + (j - i) / 2);// 计算中点索引 m
+            if (nums[m] < target) {             // 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1;
-            } else if (nums[m] > target) {          // 此情况说明 target 在区间 [i, m) 中
-                j = m;
-            } else {                                // 找到目标元素，返回其索引
+            } else if (nums[m] > target) {      // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            } else {                            // 找到目标元素，返回其索引
                 return m;
             }
         }

From 88ce287a6f602f38d21c733505e735aeeebaeaca Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 09:47:17 +1100
Subject: [PATCH 013/158] Fixed format of doc

---
 docs/chapter_searching/binary_search.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
index a059d75da..a04b95157 100644
--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@@ -331,12 +331,12 @@ $$
         let i = 0, j = nums.length;
         // 循环，当搜索区间为空时跳出（当 i = j 时为空）
         while (i < j) {
-            let m = Math.floor(i + (j - i) / 2);    // 计算中点索引 m
-            if (nums[m] < target) {                 // 此情况说明 target 在区间 [m+1, j) 中
+            let m = Math.floor(i + (j - i) / 2);// 计算中点索引 m
+            if (nums[m] < target) {             // 此情况说明 target 在区间 [m+1, j) 中
                 i = m + 1;
-            } else if (nums[m] > target) {          // 此情况说明 target 在区间 [i, m) 中
+            } else if (nums[m] > target) {      // 此情况说明 target 在区间 [i, m) 中
                 j = m;
-            } else {                                // 找到目标元素，返回其索引
+            } else {                            // 找到目标元素，返回其索引
                 return m;
             }
         }

From b1be0aab15f2b943ef3ac506e766957479296e67 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BE=9A=E5=9B=BD=E7=8E=AE?= <gongguowei01@gmail.com>
Date: Tue, 27 Dec 2022 11:25:30 +0800
Subject: [PATCH 014/158] docs(array): sample code for golang
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

本次提交包含如下示例代码。
- 遍历数组；
- 初始化数组；
- 扩展数组长度；
- 在数组中查找指定元素；
- 随机返回一个数组元素；
- 删除索引 index 处元素；
- 在数组的索引 index 处插入元素 num。

所有数组约定长度为 5。原因如下：
在 goalng 中，必须声明数组的长度，例如：nums := [5]int{1,2,3,4,5}。如果不声明长度，则被称为切片。

使用的注释没有按照 golang 的编程惯例，而是倾向于使用文档上下文的注释约定。
所以所有函数注释均使用了 `/* ... */`，而不是双斜杠 `//`。
---
 .../go/chapter_array_and_linkedlist/array.go  |  83 ++++++++++
 .../array_test.go                             | 145 ++++++++++++++++++
 docs/chapter_array_and_linkedlist/array.md    |  82 +++++++++-
 3 files changed, 303 insertions(+), 7 deletions(-)
 create mode 100644 codes/go/chapter_array_and_linkedlist/array.go
 create mode 100644 codes/go/chapter_array_and_linkedlist/array_test.go

diff --git a/codes/go/chapter_array_and_linkedlist/array.go b/codes/go/chapter_array_and_linkedlist/array.go
new file mode 100644
index 000000000..26eef2a91
--- /dev/null
+++ b/codes/go/chapter_array_and_linkedlist/array.go
@@ -0,0 +1,83 @@
+package chapter_array_and_linkedlist
+
+import (
+	"fmt"
+	"math/rand"
+)
+
+// ExpectSize 预期大小。 在 Go 中，声明数组长度必须是常量表达式，
+// 所以这里我们约定，扩展后的长度为 6
+const ExpectSize = 6
+
+/* 随机返回一个数组元素 */
+func randomAccess(nums [5]int) (ans int) {
+	// 在区间 [0, nums.length) 中随机抽取一个数字
+	randomIndex := rand.Intn(len(nums))
+	// 获取并返回随机元素
+	ans = nums[randomIndex]
+	return
+}
+
+/* 扩展数组长度 */
+func extend(nums [5]int) [ExpectSize]int {
+	// 初始化一个扩展长度后的数组
+	var res [ExpectSize]int
+	// 将原数组中的所有元素复制到新数组
+	for i := 0; i < len(nums); i++ {
+		res[i] = nums[i]
+	}
+	// 返回扩展后的新数组
+	return res
+}
+
+/* 在数组的索引 index 处插入元素 num */
+func insert(nums *[5]int, num int, index int) {
+	// 把索引 index 以及之后的所有元素向后移动一位
+	// 如果超出了数组长度，会被直接舍弃
+	for i := len(nums) - 1; i > index; i-- {
+		nums[i] = nums[i-1]
+	}
+	// 将 num 赋给 index 处元素
+	nums[index] = num
+}
+
+/* 删除索引 index 处元素 */
+func remove(nums *[5]int, index int) {
+	// 越界检查
+	if index >= len(nums) {
+		return
+	}
+	// 把索引 index 之后的所有元素向前移动一位
+	for i := index; i < len(nums); i++ {
+		if i+1 >= len(nums) {
+			nums[len(nums)-1] = 0
+			break
+		}
+		nums[i] = nums[i+1]
+	}
+}
+
+/* 遍历数组 */
+func traverse(nums [5]int) {
+	var count int
+	// 通过索引遍历数组
+	for i := 0; i < len(nums); i++ {
+		count++
+	}
+	// 直接遍历数组
+	for index, val := range nums {
+		fmt.Printf("index:%v value:%v\n", index, val)
+	}
+}
+
+/* 在数组中查找指定元素 */
+func find(nums [5]int, target int) (ans int) {
+	ans = -1
+	for i := 0; i < len(nums); i++ {
+		if nums[i] == target {
+			ans = i
+			break
+		}
+	}
+	return
+}
diff --git a/codes/go/chapter_array_and_linkedlist/array_test.go b/codes/go/chapter_array_and_linkedlist/array_test.go
new file mode 100644
index 000000000..1f5510345
--- /dev/null
+++ b/codes/go/chapter_array_and_linkedlist/array_test.go
@@ -0,0 +1,145 @@
+package chapter_array_and_linkedlist
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestInitArray(t *testing.T) {
+	t.Parallel()
+	var arr [5]int
+	for _, v := range arr {
+		if v != 0 {
+			t.Fatalf("array init exception")
+		}
+	}
+}
+
+func TestRandomAccess(t *testing.T) {
+	t.Parallel()
+	min, max := 1, 5
+	nums := [5]int{min, 2, 3, 4, max}
+	ans := randomAccess(nums)
+	if ans < min || ans > max {
+		t.Fatalf("Expected range is greater than min: %v and less than max: %v, got ans: %v", min, max, ans)
+	}
+}
+
+func TestExtend(t *testing.T) {
+	t.Parallel()
+	nums := [5]int{1, 2, 3, 4, 5}
+	newNums := extend(nums)
+	if len(newNums) != ExpectSize {
+		t.Fatalf("Expected len: %v, got: %v", ExpectSize, len(nums))
+	}
+}
+
+func TestInsert(t *testing.T) {
+	t.Parallel()
+	nums := [5]int{1, 2, 3, 4, 5}
+	insert(&nums, 5, 0)
+	if nums[0] != 5 {
+		t.Fatalf("Expected index[0] val: 5, got: %v", nums[0])
+	}
+}
+
+func TestRemove(t *testing.T) {
+	t.Parallel()
+	type fields struct {
+		index  int
+		after  [5]int
+		before [5]int
+	}
+
+	tests := []struct {
+		name   string
+		fields fields
+	}{
+		{
+			name: "remove index[0]",
+			fields: struct {
+				index  int
+				after  [5]int
+				before [5]int
+			}{
+				index:  0,
+				after:  [5]int{2, 3, 4, 5, 0},
+				before: [5]int{1, 2, 3, 4, 5},
+			},
+		},
+		{
+			name: "remove end",
+			fields: struct {
+				index  int
+				after  [5]int
+				before [5]int
+			}{
+				index:  4,
+				after:  [5]int{1, 2, 3, 4, 0},
+				before: [5]int{1, 2, 3, 4, 5},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			v := tt.fields
+			remove(&v.before, v.index)
+			if !reflect.DeepEqual(v.before, v.after) {
+				t.Errorf("remove(&v.before, v.index) = %v, want %v", v.before, v.after)
+			}
+		})
+	}
+}
+
+func TestTraverse(t *testing.T) {
+	t.Parallel()
+	nums := [5]int{1, 2, 3, 4, 5}
+	traverse(nums)
+}
+
+func TestFind(t *testing.T) {
+	t.Parallel()
+	type fields struct {
+		target int
+		nums   [5]int
+	}
+
+	tests := []struct {
+		name   string
+		fields fields
+		want   int
+	}{
+		{
+			name: "element exists",
+			fields: struct {
+				target int
+				nums   [5]int
+			}{
+				target: 1,
+				nums:   [5]int{1, 2, 3, 4, 5},
+			},
+			want: 0,
+		},
+		{
+			name: "element does not exist",
+			fields: struct {
+				target int
+				nums   [5]int
+			}{
+				target: 6,
+				nums:   [5]int{1, 2, 3, 4, 5},
+			},
+			want: -1,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			v := tt.fields
+			if got := find(v.nums, v.target); got != tt.want {
+				t.Errorf("find(v.nums, v.target) = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 3228e678f..52d23024f 100644
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -43,7 +43,9 @@ comments: true
 === "Go"
 
     ```go title="array.go"
-
+    /* 初始化数组 */
+    var arr [5]int // {0, 0, 0, 0, 0}
+    nums := [5]int{1, 3, 2, 5, 4}
     ```
 
 === "JavaScript"
@@ -133,7 +135,14 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 随机返回一个数组元素 */
+    func randomAccess(nums [5]int) (ans int) {
+        // 在区间 [0, nums.length) 中随机抽取一个数字
+        randomIndex := rand.Intn(len(nums))
+        // 获取并返回随机元素
+        ans = nums[randomIndex]
+        return
+    }
     ```
 
 === "JavaScript"
@@ -236,7 +245,20 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    // 在 Go 中，声明数组长度必须是常量表达式，
+    // 所以这里我们约定，扩展后的长度为 6
+    const expectSize = 6
+    // 扩展数组长度
+    func extend(nums [5]int) [expectSize]int {
+        // 初始化一个扩展长度后的数组
+        var res [expectSize]int
+        // 将原数组中的所有元素复制到新数组
+        for i := 0; i < len(nums); i++ {
+            res[i] = nums[i]
+        }
+        // 返回扩展后的新数组
+        return res
+    }
     ```
 
 === "JavaScript"
@@ -370,7 +392,32 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 在数组的索引 index 处插入元素 num */
+    func insert(nums [5]int, num int, index int) {
+        // 把索引 index 以及之后的所有元素向后移动一位
+        // 如果超出了数组长度，会被直接舍弃
+        for i := len(nums) - 1; i > index; i-- {
+            nums[i] = nums[i-1]
+        }
+        // 将 num 赋给 index 处元素
+        nums[index] = num
+    }
+
+    /* 删除索引 index 处元素 */
+    func remove(nums [5]int, index int) {
+        // 越界检查
+        if index >= len(nums) {
+            return
+        }
+        // 把索引 index 之后的所有元素向前移动一位
+        for i := index; i < len(nums); i++ {
+            if i+1 >= len(nums) {
+                nums[len(nums)-1] = 0
+                break
+            }
+            nums[i] = nums[i+1]
+        }
+    }
     ```
 
 === "JavaScript"
@@ -499,7 +546,18 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 遍历数组 */
+    func traverse(nums [5]int) {
+        var count int
+        // 通过索引遍历数组
+        for i := 0; i < len(nums); i++ {
+            count++
+        }
+        // 直接遍历数组
+        for index, val := range nums {
+            fmt.Printf("index:%d value:%d\n", index, val)
+        }
+    }
     ```
 
 === "JavaScript"
@@ -604,7 +662,17 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 在数组中查找指定元素 */
+    func find(nums [5]int, target int) (ans int){
+        ans = -1
+        for i := 0; i < len(nums); i++ {
+            if nums[i] == target {
+                ans = i
+                break
+            }
+        }
+        return
+    }
     ```
 
 === "JavaScript"
@@ -660,4 +728,4 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 **二分查找。** 例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的“翻开中间，排除一半”的方式，来实现一个查电子字典的算法。
 
-**深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
+**深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
\ No newline at end of file

From eaa48b6b9f2865c78551c1d865b66147248534ae Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 16:52:19 +1100
Subject: [PATCH 015/158] Fixed wrong parameter of Hash Map Set

---
 docs/chapter_hashing/hash_map.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/chapter_hashing/hash_map.md b/docs/chapter_hashing/hash_map.md
index 2e2e57263..d8244d80a 100644
--- a/docs/chapter_hashing/hash_map.md
+++ b/docs/chapter_hashing/hash_map.md
@@ -646,7 +646,7 @@ $$
         /* 添加操作 */
         public set(key: number, val: string) {
             let index = this.hashFunc(key);
-            this.bucket[index] = new Entry(index, val);
+            this.bucket[index] = new Entry(key, val);
         }
     
         /* 删除操作 */

From 27bad89eeb517e9a50bd664d6477f59e2661db5d Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 16:59:25 +1100
Subject: [PATCH 016/158] Update binary search docs

---
 codes/typescript/chapter_searching/binary_search.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/codes/typescript/chapter_searching/binary_search.ts b/codes/typescript/chapter_searching/binary_search.ts
index 0a96720d9..74f011b78 100644
--- a/codes/typescript/chapter_searching/binary_search.ts
+++ b/codes/typescript/chapter_searching/binary_search.ts
@@ -29,9 +29,9 @@ const binarySearch1 = function (nums: number[], target: number): number {
     // 循环，当搜索区间为空时跳出（当 i = j 时为空）
     while (i < j) {
         const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
-        if (nums[m] < target) {        // 此情况说明 target 在区间 [m+1, j) 中
+        if (nums[m] < target) {        // 此情况说明 target 在区间 [m+1, j] 中
             i = m + 1;
-        } else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m) 中
+        } else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m] 中
             j = m;
         } else {                       // 找到目标元素，返回其索引
             return m;

From f79089d7295505644b73d3c4f7231015aea0a014 Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 17:06:39 +1100
Subject: [PATCH 017/158] Fixed inconsistent brackets

---
 .../chapter_searching/binary_search.ts        |  2 +-
 docs/chapter_searching/binary_search.md       | 40 +++++++++----------
 2 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/codes/typescript/chapter_searching/binary_search.ts b/codes/typescript/chapter_searching/binary_search.ts
index 74f011b78..2a03994b4 100644
--- a/codes/typescript/chapter_searching/binary_search.ts
+++ b/codes/typescript/chapter_searching/binary_search.ts
@@ -10,7 +10,7 @@ const binarySearch = function (nums: number[], target: number): number {
     let i = 0, j = nums.length - 1;
     // 循环，当搜索区间为空时跳出（当 i > j 时为空）
     while (i <= j) {
-        let m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
+        const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
         if (nums[m] < target) {        // 此情况说明 target 在区间 [m+1, j] 中
             i = m + 1;
         } else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m-1] 中
diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
index a04b95157..35d6a3210 100644
--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@@ -167,12 +167,12 @@ $$
         let i = 0, j = nums.length - 1;
         // 循环，当搜索区间为空时跳出（当 i > j 时为空）
         while (i <= j) {
-            let m = Math.floor(i + (j - i) / 2);// 计算中点索引 m
-            if (nums[m] < target) {             // 此情况说明 target 在区间 [m+1, j] 中
+            const m = Math.floor(i + (j - i) / 2);  // 计算中点索引 m
+            if (nums[m] < target) {                 // 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1;
-            } else if (nums[m] > target) {      // 此情况说明 target 在区间 [i, m-1] 中
+            } else if (nums[m] > target) {          // 此情况说明 target 在区间 [i, m-1] 中
                 j = m - 1;
-            } else {                            // 找到目标元素，返回其索引
+            } else {                                // 找到目标元素，返回其索引
                 return m;
             }
         }
@@ -224,9 +224,9 @@ $$
         // 循环，当搜索区间为空时跳出（当 i = j 时为空）
         while (i < j) {
             int m = (i + j) / 2;       // 计算中点索引 m
-            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j) 中
+            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1;
-            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m] 中
                 j = m;
             else                       // 找到目标元素，返回其索引
                 return m;
@@ -246,9 +246,9 @@ $$
         // 循环，当搜索区间为空时跳出（当 i = j 时为空）
         while (i < j) {
             int m = (i + j) / 2;       // 计算中点索引 m
-            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j) 中
+            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1;
-            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m] 中
                 j = m;
             else                       // 找到目标元素，返回其索引
                 return m;
@@ -268,9 +268,9 @@ $$
         # 循环，当搜索区间为空时跳出（当 i = j 时为空）
         while i < j:
             m = (i + j) // 2        # 计算中点索引 m
-            if nums[m] < target:    # 此情况说明 target 在区间 [m+1, j) 中
+            if nums[m] < target:    # 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1
-            elif nums[m] > target:  # 此情况说明 target 在区间 [i, m) 中
+            elif nums[m] > target:  # 此情况说明 target 在区间 [i, m] 中
                 j = m
             else:                   # 找到目标元素，返回其索引
                 return m
@@ -287,9 +287,9 @@ $$
         // 循环，当搜索区间为空时跳出（当 i = j 时为空）
         for i < j {
             m := (i + j) / 2             // 计算中点索引 m
-            if nums[m] < target {        // 此情况说明 target 在区间 [m+1, j) 中
+            if nums[m] < target {        // 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1
-            } else if nums[m] > target { // 此情况说明 target 在区间 [i, m) 中
+            } else if nums[m] > target { // 此情况说明 target 在区间 [i, m] 中
                 j = m
             } else {                     // 找到目标元素，返回其索引
                 return m
@@ -310,9 +310,9 @@ $$
     // 循环，当搜索区间为空时跳出（当 i = j 时为空）
     while (i < j) {
         let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
-        if (nums[m] < target)          // 此情况说明 target 在区间 [m+1, j) 中
+        if (nums[m] < target)          // 此情况说明 target 在区间 [m+1, j] 中
             i = m + 1;
-        else if (nums[m] > target)     // 此情况说明 target 在区间 [i, m) 中
+        else if (nums[m] > target)     // 此情况说明 target 在区间 [i, m] 中
             j = m;
         else                           // 找到目标元素，返回其索引
             return m;
@@ -331,12 +331,12 @@ $$
         let i = 0, j = nums.length;
         // 循环，当搜索区间为空时跳出（当 i = j 时为空）
         while (i < j) {
-            let m = Math.floor(i + (j - i) / 2);// 计算中点索引 m
-            if (nums[m] < target) {             // 此情况说明 target 在区间 [m+1, j) 中
+            const m = Math.floor(i + (j - i) / 2);  // 计算中点索引 m
+            if (nums[m] < target) {                 // 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1;
-            } else if (nums[m] > target) {      // 此情况说明 target 在区间 [i, m) 中
+            } else if (nums[m] > target) {          // 此情况说明 target 在区间 [i, m] 中
                 j = m;
-            } else {                            // 找到目标元素，返回其索引
+            } else {                                // 找到目标元素，返回其索引
                 return m;
             }
         }
@@ -362,9 +362,9 @@ $$
         while (i < j)
         {
             int m = (i + j) / 2;       // 计算中点索引 m
-            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j) 中
+            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1;
-            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m] 中
                 j = m;
             else                       // 找到目标元素，返回其索引
                 return m;

From 8e9bfabae2804568a5ae80b0ea9b35d1aabb4f4e Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Tue, 27 Dec 2022 17:10:23 +0800
Subject: [PATCH 018/158] Fix binary search tree.

---
 docs/chapter_tree/binary_search_tree.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md
index c2551e749..f33294bf5 100644
--- a/docs/chapter_tree/binary_search_tree.md
+++ b/docs/chapter_tree/binary_search_tree.md
@@ -761,14 +761,14 @@ comments: true
 
 - **查找元素：** 由于数组是无序的，因此需要遍历数组来确定，使用 $O(n)$ 时间；
 - **插入元素：** 只需将元素添加至数组尾部即可，使用 $O(1)$ 时间；
-- **删除元素：** 先查找元素，使用 $O(\log n)$ 时间，再在数组中删除该元素，使用 $O(n)$ 时间；
+- **删除元素：** 先查找元素，使用 $O(n)$ 时间，再在数组中删除该元素，使用 $O(n)$ 时间；
 - **获取最小 / 最大元素：** 需要遍历数组来确定，使用 $O(n)$ 时间；
 
 为了得到先验信息，我们也可以预先将数组元素进行排序，得到一个「排序数组」，此时操作效率为：
 
-- **查找元素：** 由于数组已排序，可以使用二分查找，使用 $O(\log n)$ 时间；
-- **插入元素：** 为了保持数组是有序的，需插入到数组某位置，平均使用 $O(n)$ 时间；
-- **删除元素：** 与无序数组中的情况相同，使用 $O(n)$ 时间；
+- **查找元素：** 由于数组已排序，可以使用二分查找，平均使用 $O(\log n)$ 时间；
+- **插入元素：** 先查找插入位置，使用 $O(\log n)$ 时间，再插入到指定位置，使用 $O(n)$ 时间；
+- **删除元素：** 先查找元素，使用 $O(\log n)$ 时间，再在数组中删除该元素，使用 $O(n)$ 时间；
 - **获取最小 / 最大元素：** 数组头部和尾部元素即是最小和最大元素，使用 $O(1)$ 时间；
 
 观察发现，无序数组和有序数组中的各项操作的时间复杂度是“偏科”的，即有的快有的慢；**而二叉搜索树的各项操作的时间复杂度都是对数阶，在数据量 $n$ 很大时有巨大优势**。

From 8b401c2acbd11b637fa0d413b64dc5b07c3b8882 Mon Sep 17 00:00:00 2001
From: a16su <33782391+a16su@users.noreply.github.com>
Date: Tue, 27 Dec 2022 18:34:12 +0800
Subject: [PATCH 019/158] fix format error

---
 codes/python/chapter_tree/avl_tree.py         | 159 +++++---------
 .../python/chapter_tree/binary_search_tree.py |  76 +++----
 codes/python/chapter_tree/binary_tree.py      |   4 +-
 codes/python/chapter_tree/binary_tree_bfs.py  |  21 +-
 codes/python/chapter_tree/binary_tree_dfs.py  |  60 +++---
 codes/python/include/binary_tree.py           |  16 +-
 docs/chapter_tree/avl_tree.md                 | 194 ++++++------------
 docs/chapter_tree/binary_search_tree.md       |  35 ++--
 docs/chapter_tree/binary_tree.md              |  46 +++--
 9 files changed, 248 insertions(+), 363 deletions(-)

diff --git a/codes/python/chapter_tree/avl_tree.py b/codes/python/chapter_tree/avl_tree.py
index 4e6e35727..20cad94bc 100644
--- a/codes/python/chapter_tree/avl_tree.py
+++ b/codes/python/chapter_tree/avl_tree.py
@@ -1,3 +1,9 @@
+"""
+File: avl_tree.py
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
+"""
+
 import sys, os.path as osp
 import typing
 
@@ -5,75 +11,36 @@ sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
 
-class AVLTreeNode:
-    def __init__(
-        self,
-        val=None,
-        height: int = 0,
-        left: typing.Optional["AVLTreeNode"] = None,
-        right: typing.Optional["AVLTreeNode"] = None,
-    ):
-        self.val = val
-        self.height = height
-        self.left = left
-        self.right = right
-
-    def __str__(self):
-        val = self.val
-        left_val = self.left.val if self.left else None
-        right_val = self.right.val if self.right else None
-        return "<AVLTreeNode: {}, leftAVLTreeNode: {}, rightAVLTreeNode: {}>".format(
-            val, left_val, right_val
-        )
-
-
 class AVLTree:
-    def __init__(self, root: typing.Optional[AVLTreeNode] = None):
+    def __init__(self, root: typing.Optional[TreeNode] = None):
         self.root = root
 
-    @staticmethod
-    def height(node: typing.Optional[AVLTreeNode]) -> int:
-        """
-        获取结点高度
-        Args:
-            node:起始结点
+    """ 获取结点高度 """
 
-        Returns: 高度 or -1
-
-        """
+    def height(self, node: typing.Optional[TreeNode]) -> int:
         # 空结点高度为 -1 ，叶结点高度为 0
         if node is not None:
             return node.height
         return -1
 
-    def __update_height(self, node: AVLTreeNode):
-        """
-        更新结点高度
-        Args:
-            node: 要更新高度的结点
+    """ 更新结点高度 """
 
-        Returns: None
-
-        """
+    def __update_height(self, node: TreeNode):
         # 结点高度等于最高子树高度 + 1
         node.height = max([self.height(node.left), self.height(node.right)]) + 1
 
-    def balance_factor(self, node: AVLTreeNode) -> int:
-        """
-        获取结点平衡因子
-        Args:
-            node: 要获取平衡因子的结点
+    """ 获取平衡因子 """
 
-        Returns: 平衡因子
-
-        """
+    def balance_factor(self, node: TreeNode) -> int:
         # 空结点平衡因子为 0
         if node is None:
             return 0
         # 结点平衡因子 = 左子树高度 - 右子树高度
         return self.height(node.left) - self.height(node.right)
 
-    def __right_rotate(self, node: AVLTreeNode) -> AVLTreeNode:
+    """ 右旋操作 """
+
+    def __right_rotate(self, node: TreeNode) -> TreeNode:
         child = node.left
         grand_child = child.right
         # 以 child 为原点，将 node 向右旋转
@@ -85,7 +52,9 @@ class AVLTree:
         # 返回旋转后子树的根节点
         return child
 
-    def __left_rotate(self, node: AVLTreeNode) -> AVLTreeNode:
+    """ 左旋操作 """
+
+    def __left_rotate(self, node: TreeNode) -> TreeNode:
         child = node.right
         grand_child = child.left
         # 以 child 为原点，将 node 向左旋转
@@ -97,15 +66,9 @@ class AVLTree:
         # 返回旋转后子树的根节点
         return child
 
-    def rotate(self, node: AVLTreeNode):
-        """
-        执行旋转操作，使该子树重新恢复平衡
-        Args:
-            node: 要旋转的根结点
+    """ 执行旋转操作，使该子树重新恢复平衡 """
 
-        Returns: 旋转后的根结点
-
-        """
+    def __rotate(self, node: TreeNode) -> TreeNode:
         # 获取结点 node 的平衡因子
         balance_factor = self.balance_factor(node)
         # 左偏树
@@ -129,76 +92,46 @@ class AVLTree:
         # 平衡树，无需旋转，直接返回
         return node
 
-    def insert(self, val) -> AVLTreeNode:
-        """
-        插入结点
-        Args:
-            val: 结点的值
+    """ 插入结点 """
 
-        Returns:
-            node: 插入结点后的根结点
-        """
-        self.root = self.insert_helper(self.root, val)
+    def insert(self, val) -> TreeNode:
+        self.root = self.__insert_helper(self.root, val)
         return self.root
 
-    def insert_helper(
-        self, node: typing.Optional[AVLTreeNode], val: int
-    ) -> AVLTreeNode:
-        """
-        递归插入结点（辅助函数）
-        Args:
-            node: 要插入的根结点
-            val: 要插入的结点的值
+    """ 递归插入结点（辅助函数）"""
 
-        Returns: 插入结点后的根结点
-
-        """
+    def __insert_helper(self, node: typing.Optional[TreeNode], val: int) -> TreeNode:
         if node is None:
-            return AVLTreeNode(val)
+            return TreeNode(val)
         # 1. 查找插入位置，并插入结点
         if val < node.val:
-            node.left = self.insert_helper(node.left, val)
+            node.left = self.__insert_helper(node.left, val)
         elif val > node.val:
-            node.right = self.insert_helper(node.right, val)
+            node.right = self.__insert_helper(node.right, val)
         else:
             # 重复结点不插入，直接返回
             return node
         # 更新结点高度
         self.__update_height(node)
         # 2. 执行旋转操作，使该子树重新恢复平衡
-        return self.rotate(node)
+        return self.__rotate(node)
+
+    """ 删除结点 """
 
     def remove(self, val: int):
-        """
-        删除结点
-        Args:
-            val: 要删除的结点的值
-
-        Returns:
-
-        """
-        root = self.remove_helper(self.root, val)
+        root = self.__remove_helper(self.root, val)
         return root
 
-    def remove_helper(
-        self, node: typing.Optional[AVLTreeNode], val: int
-    ) -> typing.Optional[AVLTreeNode]:
-        """
-        递归删除结点（辅助函数）
-        Args:
-            node:  删除的起始结点
-            val: 要删除的结点的值
+    """ 递归删除结点（辅助函数） """
 
-        Returns: 删除目标结点后的起始结点
-
-        """
+    def __remove_helper(self, node: typing.Optional[TreeNode], val: int) -> typing.Optional[TreeNode]:
         if node is None:
             return None
         # 1. 查找结点，并删除之
         if val < node.val:
-            node.left = self.remove_helper(node.left, val)
+            node.left = self.__remove_helper(node.left, val)
         elif val > node.val:
-            node.right = self.remove_helper(node.right, val)
+            node.right = self.__remove_helper(node.right, val)
         else:
             if node.left is None or node.right is None:
                 child = node.left or node.right
@@ -210,17 +143,16 @@ class AVLTree:
                     node = child
             else:  # 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
                 temp = self.min_node(node.right)
-                node.right = self.remove_helper(node.right, temp.val)
+                node.right = self.__remove_helper(node.right, temp.val)
                 node.val = temp.val
         # 更新结点高度
         self.__update_height(node)
         # 2. 执行旋转操作，使该子树重新恢复平衡
-        return self.rotate(node)
+        return self.__rotate(node)
 
-    def min_node(
-        self, node: typing.Optional[AVLTreeNode]
-    ) -> typing.Optional[AVLTreeNode]:
-        # 获取最小结点
+    """ 获取最小结点 """
+
+    def min_node(self, node: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
         if node is None:
             return None
         # 循环访问左子结点，直到叶结点时为最小结点，跳出
@@ -228,15 +160,22 @@ class AVLTree:
             node = node.left
         return node
 
+    """ 查找结点 """
+
     def search(self, val: int):
         cur = self.root
+        # 循环查找，越过叶结点后跳出
         while cur is not None:
+            # 目标结点在 root 的右子树中
             if cur.val < val:
                 cur = cur.right
+            # 目标结点在 root 的左子树中
             elif cur.val > val:
                 cur = cur.left
+            # 找到目标结点，跳出循环
             else:
                 break
+        # 返回目标结点
         return cur
 
 
diff --git a/codes/python/chapter_tree/binary_search_tree.py b/codes/python/chapter_tree/binary_search_tree.py
index 211e7c0df..2123252c6 100644
--- a/codes/python/chapter_tree/binary_search_tree.py
+++ b/codes/python/chapter_tree/binary_search_tree.py
@@ -1,43 +1,46 @@
 """
 File: binary_search_tree.py
-Created Time: 2022-11-25
-Author: Krahets (krahets@163.com)
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
 """
 
 import sys, os.path as osp
+import typing
 
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
 
+""" 二叉搜索树 """
+
+
 class BinarySearchTree:
-    """
-    二叉搜索树
-    """
-
-    def __init__(self, nums) -> None:
+    def __init__(self, nums: typing.List[int]) -> None:
         nums.sort()
-        self.__root = self.buildTree(nums, 0, len(nums) - 1)
+        self.__root = self.build_tree(nums, 0, len(nums) - 1)
 
-    def buildTree(self, nums, start_index, end_index):
+    """ 构建二叉搜索树 """
+
+    def build_tree(self, nums: typing.List[int], start_index: int, end_index: int) -> typing.Optional[TreeNode]:
         if start_index > end_index:
             return None
+
+        # 将数组中间结点作为根结点
         mid = (start_index + end_index) // 2
         root = TreeNode(nums[mid])
-        root.left = self.buildTree(
-            nums=nums, start_index=start_index, end_index=mid - 1
-        )
-        root.right = self.buildTree(nums=nums, start_index=mid + 1, end_index=end_index)
+        # 递归建立左子树和右子树
+        root.left = self.build_tree(nums=nums, start_index=start_index, end_index=mid - 1)
+        root.right = self.build_tree(nums=nums, start_index=mid + 1, end_index=end_index)
         return root
 
-    def get_root(self):
+    @property
+    def root(self) -> typing.Optional[TreeNode]:
         return self.__root
 
-    def search(self, num):
-        """
-        查找结点
-        """
-        cur = self.get_root()
+    """ 查找结点 """
+
+    def search(self, num: int) -> typing.Optional[TreeNode]:
+        cur = self.root
         # 循环查找，越过叶结点后跳出
         while cur is not None:
             # 目标结点在 root 的右子树中
@@ -51,11 +54,10 @@ class BinarySearchTree:
                 break
         return cur
 
-    def insert(self, num):
-        """
-        插入结点
-        """
-        root = self.get_root()
+    """ 插入结点 """
+
+    def insert(self, num: int) -> typing.Optional[TreeNode]:
+        root = self.root
         # 若树为空，直接提前返回
         if root is None:
             return None
@@ -83,11 +85,10 @@ class BinarySearchTree:
             pre.left = node
         return node
 
-    def remove(self, num):
-        """
-        删除结点
-        """
-        root = self.get_root()
+    """ 删除结点 """
+
+    def remove(self, num: int) -> typing.Optional[TreeNode]:
+        root = self.root
         # 若树为空，直接提前返回
         if root is None:
             return None
@@ -130,10 +131,9 @@ class BinarySearchTree:
             cur.val = tmp
         return cur
 
-    def min(self, root):
-        """
-        获取最小结点
-        """
+    """ 获取最小结点 """
+
+    def min(self, root: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
         if root is None:
             return root
 
@@ -148,7 +148,7 @@ if __name__ == "__main__":
     nums = list(range(1, 16))
     bst = BinarySearchTree(nums=nums)
     print("\n初始化的二叉树为\n")
-    print_tree(bst.get_root())
+    print_tree(bst.root)
 
     # 查找结点
     node = bst.search(5)
@@ -157,17 +157,17 @@ if __name__ == "__main__":
     # 插入结点
     ndoe = bst.insert(16)
     print("\n插入结点 16 后，二叉树为\n")
-    print_tree(bst.get_root())
+    print_tree(bst.root)
 
     # 删除结点
     bst.remove(1)
     print("\n删除结点 1 后，二叉树为\n")
-    print_tree(bst.get_root())
+    print_tree(bst.root)
 
     bst.remove(2)
     print("\n删除结点 2 后，二叉树为\n")
-    print_tree(bst.get_root())
+    print_tree(bst.root)
 
     bst.remove(4)
     print("\n删除结点 4 后，二叉树为\n")
-    print_tree(bst.get_root())
+    print_tree(bst.root)
diff --git a/codes/python/chapter_tree/binary_tree.py b/codes/python/chapter_tree/binary_tree.py
index 2a892fae8..b1d8a13e3 100644
--- a/codes/python/chapter_tree/binary_tree.py
+++ b/codes/python/chapter_tree/binary_tree.py
@@ -1,7 +1,7 @@
 """
 File: binary_tree.py
-Created Time: 2022-11-25
-Author: Krahets (krahets@163.com)
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
 """
 
 import sys, os.path as osp
diff --git a/codes/python/chapter_tree/binary_tree_bfs.py b/codes/python/chapter_tree/binary_tree_bfs.py
index 57d15f919..d7865b6f7 100644
--- a/codes/python/chapter_tree/binary_tree_bfs.py
+++ b/codes/python/chapter_tree/binary_tree_bfs.py
@@ -1,17 +1,22 @@
 """
 File: binary_tree_bfs.py
-Created Time: 2022-11-25
-Author: Krahets (krahets@163.com)
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
 """
 
 import sys, os.path as osp
+import typing
+
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
 
-def hierOrder(root):
+""" 层序遍历 """
+
+
+def hier_order(root: TreeNode):
     # 初始化队列，加入根结点
-    queue = collections.deque()
+    queue: typing.Deque[TreeNode] = collections.deque()
     queue.append(root)
     # 初始化一个列表，用于保存遍历序列
     result = []
@@ -33,13 +38,11 @@ def hierOrder(root):
 if __name__ == "__main__":
     # 初始化二叉树
     # 这里借助了一个从数组直接生成二叉树的函数
-    root = list_to_tree(
-        arr=[1, 2, 3, 4, 5, 6, 7, None, None, None, None, None, None, None, None]
-    )
+    root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7, None, None, None, None, None, None, None, None])
     print("\n初始化二叉树\n")
     print_tree(root)
 
     # 层序遍历
-    result = hierOrder(root)
+    result = hier_order(root)
     print("\n层序遍历的结点打印序列 = ", result)
-    assert result == [1, 2, 3, 4, 5, 6, 7]
\ No newline at end of file
+    assert result == [1, 2, 3, 4, 5, 6, 7]
diff --git a/codes/python/chapter_tree/binary_tree_dfs.py b/codes/python/chapter_tree/binary_tree_dfs.py
index 6c5b92a3f..31b160552 100644
--- a/codes/python/chapter_tree/binary_tree_dfs.py
+++ b/codes/python/chapter_tree/binary_tree_dfs.py
@@ -1,10 +1,12 @@
 """
 File: binary_tree_dfs.py
-Created Time: 2022-11-25
-Author: Krahets (krahets@163.com)
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
 """
 
 import sys, os.path as osp
+import typing
+
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
@@ -12,42 +14,42 @@ from include import *
 result = []
 
 
-def preOrder(root):
-    """
-    前序遍历二叉树
-    """
+""" 前序遍历二叉树 """
+
+
+def pre_order(root: typing.Optional[TreeNode]):
     if root is None:
         return
 
     # 访问优先级：根结点 -> 左子树 -> 右子树
     result.append(root.val)
-    preOrder(root=root.left)
-    preOrder(root=root.right)
+    pre_order(root=root.left)
+    pre_order(root=root.right)
 
 
-def inOrder(root):
-    """
-    中序遍历二叉树
-    """
+""" 中序遍历二叉树 """
+
+
+def in_order(root: typing.Optional[TreeNode]):
     if root is None:
         return
 
     # 访问优先级：左子树 -> 根结点 -> 右子树
-    inOrder(root=root.left)
+    in_order(root=root.left)
     result.append(root.val)
-    inOrder(root=root.right)
+    in_order(root=root.right)
 
 
-def postOrder(root):
-    """
-    后序遍历二叉树
-    """
+""" 后序遍历二叉树 """
+
+
+def post_order(root: typing.Optional[TreeNode]):
     if root is None:
         return
 
     # 访问优先级：左子树 -> 右子树 -> 根结点
-    postOrder(root=root.left)
-    postOrder(root=root.right)
+    post_order(root=root.left)
+    post_order(root=root.right)
     result.append(root.val)
 
 
@@ -55,26 +57,24 @@ def postOrder(root):
 if __name__ == "__main__":
     # 初始化二叉树
     # 这里借助了一个从数组直接生成二叉树的函数
-    root = list_to_tree(
-        arr=[1, 2, 3, 4, 5, 6, 7, None, None, None, None, None, None, None, None]
-    )
+    root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7, None, None, None, None, None, None, None, None])
     print("\n初始化二叉树\n")
     print_tree(root)
 
     # 前序遍历
-    result = []
-    preOrder(root)
+    result.clear()
+    pre_order(root)
     print("\n前序遍历的结点打印序列 = ", result)
     assert result == [1, 2, 4, 5, 3, 6, 7]
 
     # 中序遍历
-    result = []
-    inOrder(root)
+    result.clear()
+    in_order(root)
     print("\n中序遍历的结点打印序列 = ", result)
     assert result == [4, 2, 5, 1, 6, 3, 7]
 
     # 后序遍历
-    result = []
-    postOrder(root)
+    result.clear()
+    post_order(root)
     print("\n后序遍历的结点打印序列 = ", result)
-    assert result == [4, 5, 2, 6, 7, 3, 1]
\ No newline at end of file
+    assert result == [4, 5, 2, 6, 7, 3, 1]
diff --git a/codes/python/include/binary_tree.py b/codes/python/include/binary_tree.py
index bfe5b5f27..fe96f5046 100644
--- a/codes/python/include/binary_tree.py
+++ b/codes/python/include/binary_tree.py
@@ -10,9 +10,19 @@ class TreeNode:
     """Definition for a binary tree node
     """    
     def __init__(self, val=None, left=None, right=None):
-        self.val = val
-        self.left = left
-        self.right = right
+        self.val = val  # 结点值
+        self.height = 0  # 结点高度, avl 树会用到
+        self.left = left  # 左子结点引用
+        self.right = right  # 右子结点引用
+
+    def __str__(self):  # 直接print时会好看一点
+        val = self.val
+        left_node_val = self.left.val if self.left else None
+        right_node_val = self.right.val if self.right else None
+        return "<TreeNode: {}, leftTreeNode: {}, rightTreeNode: {}>".format(val, left_node_val, right_node_val)
+
+    __repr__ = __str__
+
 
 def list_to_tree(arr):
     """Generate a binary tree with a list
diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md
index ef88975b2..5f2cfb185 100644
--- a/docs/chapter_tree/avl_tree.md
+++ b/docs/chapter_tree/avl_tree.md
@@ -48,24 +48,21 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "Python"
 
     ```python title="avl_tree.py"
-    class AVLTreeNode:
-        def __init__(
-                self,
-                val=None,
-                height: int = 0,
-                left: typing.Optional["AVLTreeNode"] = None,
-                right: typing.Optional["AVLTreeNode"] = None
-        ):
-            self.val = val
-            self.height = height
-            self.left = left
-            self.right = right
+    """ AVL 树结点类 """
+    class TreeNode:
+        def __init__(self, val=None, left=None, right=None):
+            self.val = val  # 结点值
+            self.height = 0  # 结点高度, avl 树会用到
+            self.left = left  # 左子结点引用
+            self.right = right  # 右子结点引用
 
-        def __str__(self):
+        def __str__(self):  # 直接print时会好看一点
             val = self.val
-            left_val = self.left.val if self.left else None
-            right_val = self.right.val if self.right else None
-            return "<AVLTreeNode: {}, leftAVLTreeNode: {}, rightAVLTreeNode: {}>".format(val, left_val, right_val)
+            left_node_val = self.left.val if self.left else None
+            right_node_val = self.right.val if self.right else None
+            return "<TreeNode: {}, leftTreeNode: {}, rightTreeNode: {}>".format(val, left_node_val, right_node_val)
+
+        __repr__ = __str__
     ```
 
 === "Go"
@@ -125,31 +122,17 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "Python"
 
     ```python title="avl_tree.py"
-    def height(node: typing.Optional[AVLTreeNode]) -> int:
-        """
-        获取结点高度
-        Args:
-            node:起始结点 
-
-        Returns: 高度 or -1
-
-        """
+    """ 获取结点高度 """
+    def height(self, node: typing.Optional[TreeNode]) -> int:
         # 空结点高度为 -1 ，叶结点高度为 0
         if node is not None:
             return node.height
         return -1
 
-    def update_height(node: AVLTreeNode):
-        """
-        更新结点高度
-        Args:
-            node: 要更新高度的结点
-
-        Returns: None
-
-        """
+    """ 更新结点高度 """
+    def __update_height(self, node: TreeNode):
         # 结点高度等于最高子树高度 + 1
-        node.height = max([height(node.left), height(node.right)]) + 1
+        node.height = max([self.height(node.left), self.height(node.right)]) + 1
     ```
 
 === "Go"
@@ -207,20 +190,13 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "Python"
 
     ```python title="avl_tree.py"
-    def balance_factor(node: AVLTreeNode) -> int:
-        """
-        获取结点平衡因子
-        Args:
-            node: 要获取平衡因子的结点
-
-        Returns: 平衡因子
-
-        """
+    """ 获取平衡因子 """
+    def balance_factor(self, node: TreeNode) -> int:
         # 空结点平衡因子为 0
         if node is None:
             return 0
         # 结点平衡因子 = 左子树高度 - 右子树高度
-        return height(node.left) - height(node.right)
+        return self.height(node.left) - self.height(node.right)
     ```
 
 === "Go"
@@ -309,15 +285,16 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Python"
 
     ```python title="avl_tree.py"
-    def rightRotate(node: AVLTreeNode):
+    """ 右旋操作 """
+    def __right_rotate(self, node: TreeNode) -> TreeNode:
         child = node.left
         grand_child = child.right
         # 以 child 为原点，将 node 向右旋转
         child.right = node
         node.left = grand_child
         # 更新结点高度
-        update_height(node)
-        update_height(child)
+        self.__update_height(node)
+        self.__update_height(child)
         # 返回旋转后子树的根节点
         return child
     ```
@@ -387,15 +364,16 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Python"
 
     ```python title="avl_tree.py"
-    def leftRotate(node: AVLTreeNode):
+    """ 左旋操作 """
+    def __left_rotate(self, node: TreeNode) -> TreeNode:
         child = node.right
         grand_child = child.left
         # 以 child 为原点，将 node 向左旋转
         child.left = node
         node.right = grand_child
         # 更新结点高度
-        update_height(node)
-        update_height(child)
+        self.__update_height(node)
+        self.__update_height(child)
         # 返回旋转后子树的根节点
         return child
     ```
@@ -506,35 +484,28 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Python"
 
     ```python title="avl_tree.py"
-    def rotate(node: AVLTreeNode):
-        """
-        执行旋转操作，使该子树重新恢复平衡
-        Args:
-            node: 要旋转的根结点
-
-        Returns: 旋转后的根结点
-
-        """
+    """ 执行旋转操作，使该子树重新恢复平衡 """
+    def __rotate(self, node: TreeNode) -> TreeNode:
         # 获取结点 node 的平衡因子
-        factor = balance_factor(node)
+        balance_factor = self.balance_factor(node)
         # 左偏树
-        if factor > 1:
-            if balance_factor(node.left) >= 0:
+        if balance_factor > 1:
+            if self.balance_factor(node.left) >= 0:
                 # 右旋
-                return right_rotate(node)
+                return self.__right_rotate(node)
             else:
                 # 先左旋后右旋
-                node.left = left_rotate(node.left)
-                return right_rotate(node)
+                node.left = self.__left_rotate(node.left)
+                return self.__right_rotate(node)
         # 右偏树
-        elif factor < -1:
-            if balance_factor(node.right) <= 0:
+        elif balance_factor < -1:
+            if self.balance_factor(node.right) <= 0:
                 # 左旋
-                return left_rotate(node)
+                return self.__left_rotate(node)
             else:
                 # 先右旋后左旋
-                node.right = right_rotate(node.right)
-                return left_rotate(node)
+                node.right = self.__right_rotate(node.right)
+                return self.__left_rotate(node)
         # 平衡树，无需旋转，直接返回
         return node
     ```
@@ -611,42 +582,27 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Python"
 
     ```python title="avl_tree.py"
-    def insert(val) -> AVLTreeNode:
-        """
-        插入结点
-        Args:
-            val: 结点的值 
+    """ 插入结点 """
+    def insert(self, val) -> TreeNode:
+        self.root = self.__insert_helper(self.root, val)
+        return self.root
 
-        Returns:
-            node: 插入结点后的根结点
-        """
-        root = insert_helper(root, val)
-        return root
-
-    def insert_helper(node: typing.Optional[AVLTreeNode], val: int) -> AVLTreeNode:
-        """
-        递归插入结点（辅助函数）
-        Args:
-            node: 要插入的根结点
-            val: 要插入的结点的值
-
-        Returns: 插入结点后的根结点
-
-        """
+    """ 递归插入结点（辅助函数）"""
+    def __insert_helper(self, node: typing.Optional[TreeNode], val: int) -> TreeNode:
         if node is None:
-            return AVLTreeNode(val)
+            return TreeNode(val)
         # 1. 查找插入位置，并插入结点
         if val < node.val:
-            node.left = insert_helper(node.left, val)
+            node.left = self.__insert_helper(node.left, val)
         elif val > node.val:
-            node.right = insert_helper(node.right, val)
+            node.right = self.__insert_helper(node.right, val)
         else:
             # 重复结点不插入，直接返回
             return node
         # 更新结点高度
-        update_height(node)
+        self.__update_height(node)
         # 2. 执行旋转操作，使该子树重新恢复平衡
-        return rotate(node)
+        return self.__rotate(node)
     ```
 
 === "Go"
@@ -743,35 +699,20 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Python"
 
     ```python title="avl_tree.py"
-    def remove(val: int):
-        """
-        删除结点
-        Args:
-            val: 要删除的结点的值
-
-        Returns:
-
-        """
-        root = remove_helper(root, val)
+    """ 删除结点 """
+    def remove(self, val: int):
+        root = self.__remove_helper(self.root, val)
         return root
 
-    def remove_helper(node: typing.Optional[AVLTreeNode], val: int) -> typing.Optional[AVLTreeNode]:
-        """
-        递归删除结点（辅助函数）
-        Args:
-            node:  删除的起始结点
-            val: 要删除的结点的值
-
-        Returns: 删除目标结点后的起始结点
-
-        """
+    """ 递归删除结点（辅助函数） """
+    def __remove_helper(self, node: typing.Optional[TreeNode], val: int) -> typing.Optional[TreeNode]:
         if node is None:
             return None
         # 1. 查找结点，并删除之
         if val < node.val:
-            node.left = remove_helper(node.left, val)
+            node.left = self.__remove_helper(node.left, val)
         elif val > node.val:
-            node.right = remove_helper(node.right, val)
+            node.right = self.__remove_helper(node.right, val)
         else:
             if node.left is None or node.right is None:
                 child = node.left or node.right
@@ -781,18 +722,17 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
                 # 子结点数量 = 1 ，直接删除 node
                 else:
                     node = child
-            else: # 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
-                temp = min_node(node.right)
-                node.right = remove_helper(node.right, temp.val)
+            else:  # 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+                temp = self.min_node(node.right)
+                node.right = self.__remove_helper(node.right, temp.val)
                 node.val = temp.val
         # 更新结点高度
-        update_height(node)
+        self.__update_height(node)
         # 2. 执行旋转操作，使该子树重新恢复平衡
-        return rotate(node)
+        return self.__rotate(node)
 
-
-    def min_node(node: typing.Optional[AVLTreeNode]) -> typing.Optional[AVLTreeNode]:
-        # 获取最小结点
+    """ 获取最小结点 """
+    def min_node(self, node: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
         if node is None:
             return None
         # 循环访问左子结点，直到叶结点时为最小结点，跳出
diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md
index a9328ddc6..08d16e4e4 100644
--- a/docs/chapter_tree/binary_search_tree.md
+++ b/docs/chapter_tree/binary_search_tree.md
@@ -82,11 +82,9 @@ comments: true
 === "Python"
 
     ```python title="binary_search_tree.py"
-    def search(self, num):
-        """
-        查找结点
-        """
-        cur = self.get_root()
+    """ 查找结点 """
+    def search(self, num: int) -> typing.Optional[TreeNode]:
+        cur = self.root
         # 循环查找，越过叶结点后跳出
         while cur is not None:
             # 目标结点在 root 的右子树中
@@ -99,7 +97,6 @@ comments: true
             else:
                 break
         return cur
-
     ```
 
 === "Go"
@@ -245,11 +242,9 @@ comments: true
 === "Python"
 
     ```python title="binary_search_tree.py"
-    def insert(self, num):
-        """
-        插入结点
-        """
-        root = self.get_root()
+    """ 插入结点 """
+    def insert(self, num: int) -> typing.Optional[TreeNode]:
+        root = self.root
         # 若树为空，直接提前返回
         if root is None:
             return None
@@ -530,15 +525,13 @@ comments: true
 === "Python"
 
     ```python title="binary_search_tree.py"
-    def remove(self, num):
-        """
-        删除结点
-        """
-        root = self.get_root()
+    """ 删除结点 """
+    def remove(self, num: int) -> typing.Optional[TreeNode]:
+        root = self.root
         # 若树为空，直接提前返回
         if root is None:
             return None
-        
+
         cur = root
         pre = None
 
@@ -574,13 +567,11 @@ comments: true
             # 递归删除结点 nex
             self.remove(nex.val)
             # 将 nex 的值复制给 cur
-            cur.val =  tmp
+            cur.val = tmp
         return cur
 
-    def min(self, root):
-        """
-        获取最小结点
-        """
+    """ 获取最小结点 """
+    def min(self, root: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
         if root is None:
             return root
 
diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md
index ab67e6f80..d1e7774ad 100644
--- a/docs/chapter_tree/binary_tree.md
+++ b/docs/chapter_tree/binary_tree.md
@@ -33,12 +33,19 @@ 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 __str__(self):
+            val = self.val
+            left_node_val = self.left.val if self.left else None
+            right_node_val = self.right.val if self.right else None
+            return "<TreeNode: {}, leftTreeNode: {}, rightTreeNode: {}>".format(val, left_node_val, right_node_val)
+
     ```
 
 === "Go"
@@ -423,7 +430,8 @@ comments: true
 === "Python"
 
     ```python title="binary_tree_bfs.py"
-    def hierOrder(root):
+    """ 层序遍历 """
+    def hier_order(root):
         # 初始化队列，加入根结点
         queue = collections.deque()
         queue.append(root)
@@ -612,42 +620,36 @@ comments: true
 === "Python"
 
     ```python title="binary_tree_dfs.py"
-    def preOrder(root):
-        """
-        前序遍历二叉树
-        """
+    """ 前序遍历二叉树 """
+    def pre_order(root: typing.Optional[TreeNode]):
         if root is None:
             return
-        
+
         # 访问优先级：根结点 -> 左子树 -> 右子树
         result.append(root.val)
-        preOrder(root=root.left)
-        preOrder(root=root.right)
+        pre_order(root=root.left)
+        pre_order(root=root.right)
 
 
-    def inOrder(root):
-        """
-        中序遍历二叉树
-        """
+    """ 中序遍历二叉树 """
+    def in_order(root: typing.Optional[TreeNode]):
         if root is None:
             return
 
         # 访问优先级：左子树 -> 根结点 -> 右子树
-        inOrder(root=root.left)
+        in_order(root=root.left)
         result.append(root.val)
-        inOrder(root=root.right)
+        in_order(root=root.right)
 
 
-    def postOrder(root):
-        """
-        后序遍历二叉树
-        """
+    """ 后序遍历二叉树 """
+    def post_order(root: typing.Optional[TreeNode]):
         if root is None:
             return
-        
+
         # 访问优先级：左子树 -> 右子树 -> 根结点
-        postOrder(root=root.left)
-        postOrder(root=root.right)
+        post_order(root=root.left)
+        post_order(root=root.right)
         result.append(root.val)
     ```
 

From dbb25003ec9fec74e015a9019be0588df67523db Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Tue, 27 Dec 2022 19:24:43 +0800
Subject: [PATCH 020/158] Fine tune

---
 codes/python/chapter_tree/avl_tree.py          | 18 +++---------------
 .../python/chapter_tree/binary_search_tree.py  |  8 +-------
 codes/python/chapter_tree/binary_tree.py       |  3 +++
 codes/python/chapter_tree/binary_tree_bfs.py   |  2 --
 codes/python/chapter_tree/binary_tree_dfs.py   |  6 ------
 5 files changed, 7 insertions(+), 30 deletions(-)

diff --git a/codes/python/chapter_tree/avl_tree.py b/codes/python/chapter_tree/avl_tree.py
index 20cad94bc..d0ff48cba 100644
--- a/codes/python/chapter_tree/avl_tree.py
+++ b/codes/python/chapter_tree/avl_tree.py
@@ -16,7 +16,6 @@ class AVLTree:
         self.root = root
 
     """ 获取结点高度 """
-
     def height(self, node: typing.Optional[TreeNode]) -> int:
         # 空结点高度为 -1 ，叶结点高度为 0
         if node is not None:
@@ -24,13 +23,11 @@ class AVLTree:
         return -1
 
     """ 更新结点高度 """
-
     def __update_height(self, node: TreeNode):
         # 结点高度等于最高子树高度 + 1
         node.height = max([self.height(node.left), self.height(node.right)]) + 1
 
     """ 获取平衡因子 """
-
     def balance_factor(self, node: TreeNode) -> int:
         # 空结点平衡因子为 0
         if node is None:
@@ -39,7 +36,6 @@ class AVLTree:
         return self.height(node.left) - self.height(node.right)
 
     """ 右旋操作 """
-
     def __right_rotate(self, node: TreeNode) -> TreeNode:
         child = node.left
         grand_child = child.right
@@ -53,7 +49,6 @@ class AVLTree:
         return child
 
     """ 左旋操作 """
-
     def __left_rotate(self, node: TreeNode) -> TreeNode:
         child = node.right
         grand_child = child.left
@@ -67,7 +62,6 @@ class AVLTree:
         return child
 
     """ 执行旋转操作，使该子树重新恢复平衡 """
-
     def __rotate(self, node: TreeNode) -> TreeNode:
         # 获取结点 node 的平衡因子
         balance_factor = self.balance_factor(node)
@@ -93,13 +87,11 @@ class AVLTree:
         return node
 
     """ 插入结点 """
-
     def insert(self, val) -> TreeNode:
         self.root = self.__insert_helper(self.root, val)
         return self.root
 
     """ 递归插入结点（辅助函数）"""
-
     def __insert_helper(self, node: typing.Optional[TreeNode], val: int) -> TreeNode:
         if node is None:
             return TreeNode(val)
@@ -117,13 +109,11 @@ class AVLTree:
         return self.__rotate(node)
 
     """ 删除结点 """
-
     def remove(self, val: int):
         root = self.__remove_helper(self.root, val)
         return root
 
     """ 递归删除结点（辅助函数） """
-
     def __remove_helper(self, node: typing.Optional[TreeNode], val: int) -> typing.Optional[TreeNode]:
         if node is None:
             return None
@@ -142,7 +132,7 @@ class AVLTree:
                 else:
                     node = child
             else:  # 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
-                temp = self.min_node(node.right)
+                temp = self.__min_node(node.right)
                 node.right = self.__remove_helper(node.right, temp.val)
                 node.val = temp.val
         # 更新结点高度
@@ -151,8 +141,7 @@ class AVLTree:
         return self.__rotate(node)
 
     """ 获取最小结点 """
-
-    def min_node(self, node: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
+    def __min_node(self, node: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
         if node is None:
             return None
         # 循环访问左子结点，直到叶结点时为最小结点，跳出
@@ -161,7 +150,6 @@ class AVLTree:
         return node
 
     """ 查找结点 """
-
     def search(self, val: int):
         cur = self.root
         # 循环查找，越过叶结点后跳出
@@ -179,8 +167,8 @@ class AVLTree:
         return cur
 
 
+""" Driver Code """
 if __name__ == "__main__":
-
     def test_insert(tree: AVLTree, val: int):
         tree.insert(val)
         print("\n插入结点 {} 后，AVL 树为".format(val))
diff --git a/codes/python/chapter_tree/binary_search_tree.py b/codes/python/chapter_tree/binary_search_tree.py
index 2123252c6..23e341854 100644
--- a/codes/python/chapter_tree/binary_search_tree.py
+++ b/codes/python/chapter_tree/binary_search_tree.py
@@ -12,15 +12,12 @@ from include import *
 
 
 """ 二叉搜索树 """
-
-
 class BinarySearchTree:
     def __init__(self, nums: typing.List[int]) -> None:
         nums.sort()
         self.__root = self.build_tree(nums, 0, len(nums) - 1)
 
     """ 构建二叉搜索树 """
-
     def build_tree(self, nums: typing.List[int], start_index: int, end_index: int) -> typing.Optional[TreeNode]:
         if start_index > end_index:
             return None
@@ -38,7 +35,6 @@ class BinarySearchTree:
         return self.__root
 
     """ 查找结点 """
-
     def search(self, num: int) -> typing.Optional[TreeNode]:
         cur = self.root
         # 循环查找，越过叶结点后跳出
@@ -55,7 +51,6 @@ class BinarySearchTree:
         return cur
 
     """ 插入结点 """
-
     def insert(self, num: int) -> typing.Optional[TreeNode]:
         root = self.root
         # 若树为空，直接提前返回
@@ -86,7 +81,6 @@ class BinarySearchTree:
         return node
 
     """ 删除结点 """
-
     def remove(self, num: int) -> typing.Optional[TreeNode]:
         root = self.root
         # 若树为空，直接提前返回
@@ -132,7 +126,6 @@ class BinarySearchTree:
         return cur
 
     """ 获取最小结点 """
-
     def min(self, root: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
         if root is None:
             return root
@@ -143,6 +136,7 @@ class BinarySearchTree:
         return root
 
 
+""" Driver Code """
 if __name__ == "__main__":
     # 初始化二叉搜索树
     nums = list(range(1, 16))
diff --git a/codes/python/chapter_tree/binary_tree.py b/codes/python/chapter_tree/binary_tree.py
index b1d8a13e3..2b25e4724 100644
--- a/codes/python/chapter_tree/binary_tree.py
+++ b/codes/python/chapter_tree/binary_tree.py
@@ -23,6 +23,7 @@ if __name__ == "__main__":
     n1.right = n3
     n2.left = n4
     n2.right = n5
+    print("\n初始化二叉树\n")
     print_tree(n1)
 
     # 插入与删除结点
@@ -31,8 +32,10 @@ if __name__ == "__main__":
     # 在 n1 -> n2 中间插入节点 P
     n1.left = P
     P.left = n2
+    print("\n插入结点 P 后\n")
     print_tree(n1)
 
     # 删除结点
     n1.left = n2
+    print("\n删除结点 P 后\n");
     print_tree(n1)
diff --git a/codes/python/chapter_tree/binary_tree_bfs.py b/codes/python/chapter_tree/binary_tree_bfs.py
index d7865b6f7..c6a73013b 100644
--- a/codes/python/chapter_tree/binary_tree_bfs.py
+++ b/codes/python/chapter_tree/binary_tree_bfs.py
@@ -12,8 +12,6 @@ from include import *
 
 
 """ 层序遍历 """
-
-
 def hier_order(root: TreeNode):
     # 初始化队列，加入根结点
     queue: typing.Deque[TreeNode] = collections.deque()
diff --git a/codes/python/chapter_tree/binary_tree_dfs.py b/codes/python/chapter_tree/binary_tree_dfs.py
index 31b160552..b5dc9c9f3 100644
--- a/codes/python/chapter_tree/binary_tree_dfs.py
+++ b/codes/python/chapter_tree/binary_tree_dfs.py
@@ -15,8 +15,6 @@ result = []
 
 
 """ 前序遍历二叉树 """
-
-
 def pre_order(root: typing.Optional[TreeNode]):
     if root is None:
         return
@@ -28,8 +26,6 @@ def pre_order(root: typing.Optional[TreeNode]):
 
 
 """ 中序遍历二叉树 """
-
-
 def in_order(root: typing.Optional[TreeNode]):
     if root is None:
         return
@@ -41,8 +37,6 @@ def in_order(root: typing.Optional[TreeNode]):
 
 
 """ 后序遍历二叉树 """
-
-
 def post_order(root: typing.Optional[TreeNode]):
     if root is None:
         return

From 449258f0b06fcb666f73bf4d6488f0de9be46942 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Tue, 27 Dec 2022 19:33:58 +0800
Subject: [PATCH 021/158] Add the code to the docs.

---
 codes/cpp/chapter_tree/binary_tree_bfs.cpp   |  8 +--
 codes/python/chapter_tree/binary_tree.py     |  7 ++-
 codes/python/chapter_tree/binary_tree_bfs.py | 24 ++++-----
 codes/python/chapter_tree/binary_tree_dfs.py | 38 ++++++--------
 docs/chapter_tree/binary_tree.md             |  6 +--
 docs/chapter_tree/binary_tree_traversal.md   | 52 +++++++++++++++++---
 6 files changed, 81 insertions(+), 54 deletions(-)

diff --git a/codes/cpp/chapter_tree/binary_tree_bfs.cpp b/codes/cpp/chapter_tree/binary_tree_bfs.cpp
index eeec2a18e..30c2d6007 100644
--- a/codes/cpp/chapter_tree/binary_tree_bfs.cpp
+++ b/codes/cpp/chapter_tree/binary_tree_bfs.cpp
@@ -15,12 +15,12 @@ vector<int> hierOrder(TreeNode* root) {
     vector<int> vec;
     while (!queue.empty()) {
         TreeNode* node = queue.front();
-        queue.pop();  // 队列出队
-        vec.push_back(node->val);            // 保存结点
+        queue.pop();                 // 队列出队
+        vec.push_back(node->val);    // 保存结点
         if (node->left != nullptr)
-            queue.push(node->left);    // 左子结点入队
+            queue.push(node->left);  // 左子结点入队
         if (node->right != nullptr)
-            queue.push(node->right);   // 右子结点入队
+            queue.push(node->right); // 右子结点入队
     }
     return vec;
 }
diff --git a/codes/python/chapter_tree/binary_tree.py b/codes/python/chapter_tree/binary_tree.py
index 2b25e4724..d99026352 100644
--- a/codes/python/chapter_tree/binary_tree.py
+++ b/codes/python/chapter_tree/binary_tree.py
@@ -12,13 +12,14 @@ from include import *
 
 """ Driver Code """
 if __name__ == "__main__":
-    # 初始化二叉树
+    """ 初始化二叉树 """
     # 初始化节点
     n1 = TreeNode(val=1)
     n2 = TreeNode(val=2)
     n3 = TreeNode(val=3)
     n4 = TreeNode(val=4)
     n5 = TreeNode(val=5)
+    # 构建引用指向（即指针）
     n1.left = n2
     n1.right = n3
     n2.left = n4
@@ -26,15 +27,13 @@ if __name__ == "__main__":
     print("\n初始化二叉树\n")
     print_tree(n1)
 
-    # 插入与删除结点
+    """ 插入与删除结点 """
     P = TreeNode(0)
-
     # 在 n1 -> n2 中间插入节点 P
     n1.left = P
     P.left = n2
     print("\n插入结点 P 后\n")
     print_tree(n1)
-
     # 删除结点
     n1.left = n2
     print("\n删除结点 P 后\n");
diff --git a/codes/python/chapter_tree/binary_tree_bfs.py b/codes/python/chapter_tree/binary_tree_bfs.py
index c6a73013b..0320a08dd 100644
--- a/codes/python/chapter_tree/binary_tree_bfs.py
+++ b/codes/python/chapter_tree/binary_tree_bfs.py
@@ -14,22 +14,18 @@ from include import *
 """ 层序遍历 """
 def hier_order(root: TreeNode):
     # 初始化队列，加入根结点
-    queue: typing.Deque[TreeNode] = collections.deque()
+    queue = collections.deque()
     queue.append(root)
     # 初始化一个列表，用于保存遍历序列
-    result = []
+    res = []
     while queue:
-        # 队列出队
-        node = queue.popleft()
-        # 保存节点值
-        result.append(node.val)
+        node = 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)
-    return result
+            queue.append(node.right) # 右子结点入队
+    return res
 
 
 """ Driver Code """
@@ -41,6 +37,6 @@ if __name__ == "__main__":
     print_tree(root)
 
     # 层序遍历
-    result = hier_order(root)
-    print("\n层序遍历的结点打印序列 = ", result)
-    assert result == [1, 2, 3, 4, 5, 6, 7]
+    res = hier_order(root)
+    print("\n层序遍历的结点打印序列 = ", res)
+    assert res == [1, 2, 3, 4, 5, 6, 7]
diff --git a/codes/python/chapter_tree/binary_tree_dfs.py b/codes/python/chapter_tree/binary_tree_dfs.py
index b5dc9c9f3..11ee8339c 100644
--- a/codes/python/chapter_tree/binary_tree_dfs.py
+++ b/codes/python/chapter_tree/binary_tree_dfs.py
@@ -11,40 +11,34 @@ sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
 
-result = []
+res = []
 
-
-""" 前序遍历二叉树 """
+""" 前序遍历 """
 def pre_order(root: typing.Optional[TreeNode]):
     if root is None:
         return
-
     # 访问优先级：根结点 -> 左子树 -> 右子树
-    result.append(root.val)
+    res.append(root.val)
     pre_order(root=root.left)
     pre_order(root=root.right)
 
-
-""" 中序遍历二叉树 """
+""" 中序遍历 """
 def in_order(root: typing.Optional[TreeNode]):
     if root is None:
         return
-
     # 访问优先级：左子树 -> 根结点 -> 右子树
     in_order(root=root.left)
-    result.append(root.val)
+    res.append(root.val)
     in_order(root=root.right)
 
-
-""" 后序遍历二叉树 """
+""" 后序遍历 """
 def post_order(root: typing.Optional[TreeNode]):
     if root is None:
         return
-
     # 访问优先级：左子树 -> 右子树 -> 根结点
     post_order(root=root.left)
     post_order(root=root.right)
-    result.append(root.val)
+    res.append(root.val)
 
 
 """ Driver Code """
@@ -56,19 +50,19 @@ if __name__ == "__main__":
     print_tree(root)
 
     # 前序遍历
-    result.clear()
+    res.clear()
     pre_order(root)
-    print("\n前序遍历的结点打印序列 = ", result)
-    assert result == [1, 2, 4, 5, 3, 6, 7]
+    print("\n前序遍历的结点打印序列 = ", res)
+    assert res == [1, 2, 4, 5, 3, 6, 7]
 
     # 中序遍历
-    result.clear()
+    res.clear()
     in_order(root)
-    print("\n中序遍历的结点打印序列 = ", result)
-    assert result == [4, 2, 5, 1, 6, 3, 7]
+    print("\n中序遍历的结点打印序列 = ", res)
+    assert res == [4, 2, 5, 1, 6, 3, 7]
 
     # 后序遍历
-    result.clear()
+    res.clear()
     post_order(root)
-    print("\n后序遍历的结点打印序列 = ", result)
-    assert result == [4, 5, 2, 6, 7, 3, 1]
+    print("\n后序遍历的结点打印序列 = ", res)
+    assert res == [4, 5, 2, 6, 7, 3, 1]
diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md
index 92539cc80..262b170be 100644
--- a/docs/chapter_tree/binary_tree.md
+++ b/docs/chapter_tree/binary_tree.md
@@ -182,7 +182,7 @@ comments: true
 === "Python"
 
     ```python title="binary_tree.py"
-    # 初始化二叉树
+    """ 初始化二叉树 """
     # 初始化节点
     n1 = TreeNode(val=1)
     n2 = TreeNode(val=2)
@@ -302,7 +302,7 @@ comments: true
 === "Python"
 
     ```python title="binary_tree.py"
-    # 插入与删除结点
+    """ 插入与删除结点 """
     p = TreeNode(0)
     # 在 n1 -> n2 中间插入结点 P
     n1.left = p
@@ -461,7 +461,7 @@ comments: true
 === "Python"
 
     ```python title=""
-    “”“ 二叉树的数组表示 ”“”
+    """ 二叉树的数组表示 """
     # 直接使用 None 来表示空位
     tree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
     ```
diff --git a/docs/chapter_tree/binary_tree_traversal.md b/docs/chapter_tree/binary_tree_traversal.md
index 971d24cc5..f46348412 100644
--- a/docs/chapter_tree/binary_tree_traversal.md
+++ b/docs/chapter_tree/binary_tree_traversal.md
@@ -51,12 +51,12 @@ comments: true
         vector<int> vec;
         while (!queue.empty()) {
             TreeNode* node = queue.front();
-            queue.pop();  // 队列出队
-            vec.push_back(node->val);            // 保存结点
+            queue.pop();                 // 队列出队
+            vec.push_back(node->val);    // 保存结点
             if (node->left != nullptr)
-                queue.push(node->left);    // 左子结点入队
+                queue.push(node->left);  // 左子结点入队
             if (node->right != nullptr)
-                queue.push(node->right);   // 右子结点入队
+                queue.push(node->right); // 右子结点入队
         }
         return vec;
     }
@@ -65,7 +65,21 @@ comments: true
 === "Python"
 
     ```python title="binary_tree_bfs.py"
-    
+    """ 层序遍历 """
+    def hier_order(root: TreeNode):
+        # 初始化队列，加入根结点
+        queue = collections.deque()
+        queue.append(root)
+        # 初始化一个列表，用于保存遍历序列
+        res = []
+        while queue:
+            node = queue.popleft()       # 队列出队
+            res.append(node.val)         # 保存节点值
+            if node.left is not None:
+                queue.append(node.left)  # 左子结点入队
+            if node.right is not None:
+                queue.append(node.right) # 右子结点入队
+        return res
     ```
 
 === "Go"
@@ -256,7 +270,32 @@ comments: true
 === "Python"
 
     ```python title="binary_tree_dfs.py"
-    
+    """ 前序遍历 """
+    def pre_order(root: typing.Optional[TreeNode]):
+        if root is None:
+            return
+        # 访问优先级：根结点 -> 左子树 -> 右子树
+        res.append(root.val)
+        pre_order(root=root.left)
+        pre_order(root=root.right)
+
+    """ 中序遍历 """
+    def in_order(root: typing.Optional[TreeNode]):
+        if root is None:
+            return
+        # 访问优先级：左子树 -> 根结点 -> 右子树
+        in_order(root=root.left)
+        res.append(root.val)
+        in_order(root=root.right)
+
+    """ 后序遍历 """
+    def post_order(root: typing.Optional[TreeNode]):
+        if root is None:
+            return
+        # 访问优先级：左子树 -> 右子树 -> 根结点
+        post_order(root=root.left)
+        post_order(root=root.right)
+        res.append(root.val)
     ```
 
 === "Go"
@@ -402,7 +441,6 @@ comments: true
         postOrder(root.right);
         list.Add(root.val);
     }
-    
     ```
 
 !!! note

From f9cc3a50cff45451eea9b973f4ffe06f232ce4a1 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Tue, 27 Dec 2022 19:38:14 +0800
Subject: [PATCH 022/158] Fine tune

---
 codes/python/include/binary_tree.py | 10 +++++-----
 docs/chapter_tree/binary_tree.md    |  7 -------
 2 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/codes/python/include/binary_tree.py b/codes/python/include/binary_tree.py
index 1e2eb0346..670fd18ce 100644
--- a/codes/python/include/binary_tree.py
+++ b/codes/python/include/binary_tree.py
@@ -9,13 +9,13 @@ import collections
 class TreeNode:
     """Definition for a binary tree node
     """    
-    def __init__(self, val=None, left=None, right=None):
-        self.val = val  # 结点值
-        self.height = 0  # 结点高度, avl 树会用到
-        self.left = left  # 左子结点引用
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val      # 结点值
+        self.height = 0     # 结点高度
+        self.left = left    # 左子结点引用
         self.right = right  # 右子结点引用
 
-    def __str__(self):  # 直接print时会好看一点
+    def __str__(self):
         val = self.val
         left_node_val = self.left.val if self.left else None
         right_node_val = self.right.val if self.right else None
diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md
index 262b170be..4de1e4c1b 100644
--- a/docs/chapter_tree/binary_tree.md
+++ b/docs/chapter_tree/binary_tree.md
@@ -39,13 +39,6 @@ comments: true
             self.val = val      # 结点值
             self.left = left    # 左子结点指针
             self.right = right  # 右子结点指针
-
-        def __str__(self):
-            val = self.val
-            left_node_val = self.left.val if self.left else None
-            right_node_val = self.right.val if self.right else None
-            return "<TreeNode: {}, leftTreeNode: {}, rightTreeNode: {}>".format(val, left_node_val, right_node_val)
-
     ```
 
 === "Go"

From 466fdd494bab4ec95d2fd172e598d560d78adfed Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Tue, 27 Dec 2022 19:42:39 +0800
Subject: [PATCH 023/158] Update the chapter tree.

---
 docs/chapter_tree/avl_tree.md    | 14 +++-----------
 docs/chapter_tree/binary_tree.md |  4 ++--
 2 files changed, 5 insertions(+), 13 deletions(-)

diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md
index bc4493520..e9a656bed 100644
--- a/docs/chapter_tree/avl_tree.md
+++ b/docs/chapter_tree/avl_tree.md
@@ -51,18 +51,10 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
     """ AVL 树结点类 """
     class TreeNode:
         def __init__(self, val=None, left=None, right=None):
-            self.val = val  # 结点值
-            self.height = 0  # 结点高度, avl 树会用到
-            self.left = left  # 左子结点引用
+            self.val = val      # 结点值
+            self.height = 0     # 结点高度
+            self.left = left    # 左子结点引用
             self.right = right  # 右子结点引用
-
-        def __str__(self):  # 直接print时会好看一点
-            val = self.val
-            left_node_val = self.left.val if self.left else None
-            right_node_val = self.right.val if self.right else None
-            return "<TreeNode: {}, leftTreeNode: {}, rightTreeNode: {}>".format(val, left_node_val, right_node_val)
-
-        __repr__ = __str__
     ```
 
 === "Go"
diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md
index 4de1e4c1b..07e311551 100644
--- a/docs/chapter_tree/binary_tree.md
+++ b/docs/chapter_tree/binary_tree.md
@@ -44,13 +44,13 @@ comments: true
 === "Go"
 
     ```go title=""
-    """ 链表结点类 """
+    // 链表结点类
     type TreeNode struct {
         Val   int
         Left  *TreeNode
         Right *TreeNode
     }
-    """ 结点初始化方法 """
+    // 结点初始化方法
     func NewTreeNode(v int) *TreeNode {
         return &TreeNode{
             Left:  nil,

From 34ad07bfed3b09accc30b5328a82e74865b5b7d5 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Tue, 27 Dec 2022 20:11:22 +0800
Subject: [PATCH 024/158] Fine tune

---
 codes/c/chapter_sorting/bubble_sort.c     |  2 ++
 codes/cpp/chapter_sorting/bubble_sort.cpp | 10 ++++------
 docs/chapter_sorting/bubble_sort.md       |  6 ++++--
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/codes/c/chapter_sorting/bubble_sort.c b/codes/c/chapter_sorting/bubble_sort.c
index f59b81d00..6b67bd727 100644
--- a/codes/c/chapter_sorting/bubble_sort.c
+++ b/codes/c/chapter_sorting/bubble_sort.c
@@ -48,6 +48,8 @@ void bubble_sort_with_flag(int nums[], int size)
     }
 }
 
+
+/* Driver Code */
 int main()
 {
     int nums[6] = {4, 1, 3, 1, 5, 2};
diff --git a/codes/cpp/chapter_sorting/bubble_sort.cpp b/codes/cpp/chapter_sorting/bubble_sort.cpp
index 071827455..87ca305d1 100644
--- a/codes/cpp/chapter_sorting/bubble_sort.cpp
+++ b/codes/cpp/chapter_sorting/bubble_sort.cpp
@@ -14,9 +14,8 @@ void bubbleSort(vector<int>& nums) {
         for (int j = 0; j < i; j++) {
             if (nums[j] > nums[j + 1]) {
                 // 交换 nums[j] 与 nums[j + 1]
-                int tmp = nums[j];
-                nums[j] = nums[j + 1];
-                nums[j + 1] = tmp;
+                // 这里使用了 std::swap() 函数
+                swap(nums[j], nums[j + 1]);
             }
         }
     }
@@ -31,9 +30,8 @@ void bubbleSortWithFlag(vector<int>& nums) {
         for (int j = 0; j < i; j++) {
             if (nums[j] > nums[j + 1]) {
                 // 交换 nums[j] 与 nums[j + 1]
-                int tmp = nums[j];
-                nums[j] = nums[j + 1];
-                nums[j + 1] = tmp;
+                // 这里使用了 std::swap() 函数
+                swap(nums[j], nums[j + 1]);
                 flag = true;  // 记录交换元素
             }
         }
diff --git a/docs/chapter_sorting/bubble_sort.md b/docs/chapter_sorting/bubble_sort.md
index f71dce77d..336f3c2d5 100644
--- a/docs/chapter_sorting/bubble_sort.md
+++ b/docs/chapter_sorting/bubble_sort.md
@@ -85,7 +85,8 @@ comments: true
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
-                    std::swap(nums[j], nums[j+1]);
+                    // 这里使用了 std::swap() 函数
+                    swap(nums[j], nums[j + 1]);
                 }
             }
         }
@@ -265,7 +266,8 @@ comments: true
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // 交换 nums[j] 与 nums[j + 1]
-                    std::swap(nums[j], nums[j+1]);
+                    // 这里使用了 std::swap() 函数
+                    swap(nums[j], nums[j + 1]);
                     flag = true;  // 记录交换元素
                 }
             }

From f0c3bf57663c7cab0e6d4d6b847a67fc1a01d75e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BE=9A=E5=9B=BD=E7=8E=AE?= <gongguowei01@gmail.com>
Date: Wed, 28 Dec 2022 10:46:12 +0800
Subject: [PATCH 025/158] docs(array): reduce understanding cost
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 去除了并行测试；
- 基于 Java 代码样例，统一了命名风格；
- 基于 Go link 模块代码样例，统一了测试用例风格；
- 我们将 Go 中的 Slice 切片看作 Array 数组。因为这样可以降低理解成本，利于我们将关注点放在数据结构与算法上。
---
 .../go/chapter_array_and_linkedlist/array.go  |  31 ++--
 .../array_test.go                             | 162 ++++--------------
 docs/chapter_array_and_linkedlist/array.md    |  35 ++--
 3 files changed, 58 insertions(+), 170 deletions(-)

diff --git a/codes/go/chapter_array_and_linkedlist/array.go b/codes/go/chapter_array_and_linkedlist/array.go
index 26eef2a91..ccc5db19b 100644
--- a/codes/go/chapter_array_and_linkedlist/array.go
+++ b/codes/go/chapter_array_and_linkedlist/array.go
@@ -5,23 +5,24 @@ import (
 	"math/rand"
 )
 
-// ExpectSize 预期大小。 在 Go 中，声明数组长度必须是常量表达式，
-// 所以这里我们约定，扩展后的长度为 6
-const ExpectSize = 6
+/**
+我们将 Go 中的 Slice 切片看作 Array 数组，降低理解成本，
+有利于我们将关注点放在数据结构与算法上。
+*/
 
 /* 随机返回一个数组元素 */
-func randomAccess(nums [5]int) (ans int) {
+func randomAccess(nums []int) (randomNum int) {
 	// 在区间 [0, nums.length) 中随机抽取一个数字
 	randomIndex := rand.Intn(len(nums))
 	// 获取并返回随机元素
-	ans = nums[randomIndex]
+	randomNum = nums[randomIndex]
 	return
 }
 
 /* 扩展数组长度 */
-func extend(nums [5]int) [ExpectSize]int {
+func extend(nums []int, enlarge int) []int {
 	// 初始化一个扩展长度后的数组
-	var res [ExpectSize]int
+	res := make([]int, len(nums)+enlarge)
 	// 将原数组中的所有元素复制到新数组
 	for i := 0; i < len(nums); i++ {
 		res[i] = nums[i]
@@ -31,7 +32,7 @@ func extend(nums [5]int) [ExpectSize]int {
 }
 
 /* 在数组的索引 index 处插入元素 num */
-func insert(nums *[5]int, num int, index int) {
+func insert(nums []int, num int, index int) {
 	// 把索引 index 以及之后的所有元素向后移动一位
 	// 如果超出了数组长度，会被直接舍弃
 	for i := len(nums) - 1; i > index; i-- {
@@ -42,11 +43,7 @@ func insert(nums *[5]int, num int, index int) {
 }
 
 /* 删除索引 index 处元素 */
-func remove(nums *[5]int, index int) {
-	// 越界检查
-	if index >= len(nums) {
-		return
-	}
+func remove(nums []int, index int) {
 	// 把索引 index 之后的所有元素向前移动一位
 	for i := index; i < len(nums); i++ {
 		if i+1 >= len(nums) {
@@ -58,7 +55,7 @@ func remove(nums *[5]int, index int) {
 }
 
 /* 遍历数组 */
-func traverse(nums [5]int) {
+func traverse(nums []int) {
 	var count int
 	// 通过索引遍历数组
 	for i := 0; i < len(nums); i++ {
@@ -71,11 +68,11 @@ func traverse(nums [5]int) {
 }
 
 /* 在数组中查找指定元素 */
-func find(nums [5]int, target int) (ans int) {
-	ans = -1
+func find(nums []int, target int) (index int) {
+	index = -1
 	for i := 0; i < len(nums); i++ {
 		if nums[i] == target {
-			ans = i
+			index = i
 			break
 		}
 	}
diff --git a/codes/go/chapter_array_and_linkedlist/array_test.go b/codes/go/chapter_array_and_linkedlist/array_test.go
index 1f5510345..3f9882a9d 100644
--- a/codes/go/chapter_array_and_linkedlist/array_test.go
+++ b/codes/go/chapter_array_and_linkedlist/array_test.go
@@ -1,145 +1,43 @@
 package chapter_array_and_linkedlist
 
+/**
+我们将 Go 中的 Slice 切片看作 Array 数组。因为这样可以
+降低理解成本，利于我们将关注点放在数据结构与算法上。
+*/
+
 import (
-	"reflect"
+	"fmt"
 	"testing"
 )
 
-func TestInitArray(t *testing.T) {
-	t.Parallel()
-	var arr [5]int
-	for _, v := range arr {
-		if v != 0 {
-			t.Fatalf("array init exception")
-		}
-	}
-}
+/* Driver Code */
+func TestArray(t *testing.T) {
+	/* 初始化数组 */
+	var arr []int
+	fmt.Println("数组 arr = ", arr)
+	nums := []int{1, 3, 2, 5, 4}
+	fmt.Println("数组 nums = ", nums)
 
-func TestRandomAccess(t *testing.T) {
-	t.Parallel()
-	min, max := 1, 5
-	nums := [5]int{min, 2, 3, 4, max}
-	ans := randomAccess(nums)
-	if ans < min || ans > max {
-		t.Fatalf("Expected range is greater than min: %v and less than max: %v, got ans: %v", min, max, ans)
-	}
-}
+	/* 随机访问 */
+	randomNum := randomAccess(nums)
+	fmt.Println("在 nums 中获取随机元素 ", randomNum)
 
-func TestExtend(t *testing.T) {
-	t.Parallel()
-	nums := [5]int{1, 2, 3, 4, 5}
-	newNums := extend(nums)
-	if len(newNums) != ExpectSize {
-		t.Fatalf("Expected len: %v, got: %v", ExpectSize, len(nums))
-	}
-}
+	/* 长度扩展 */
+	nums = extend(nums, 3)
+	fmt.Println("将数组长度扩展至 8 ，得到 nums = ", nums)
 
-func TestInsert(t *testing.T) {
-	t.Parallel()
-	nums := [5]int{1, 2, 3, 4, 5}
-	insert(&nums, 5, 0)
-	if nums[0] != 5 {
-		t.Fatalf("Expected index[0] val: 5, got: %v", nums[0])
-	}
-}
+	/* 插入元素 */
+	insert(nums, 6, 3)
+	fmt.Println("在索引 3 处插入数字 6 ，得到 nums = ", nums)
 
-func TestRemove(t *testing.T) {
-	t.Parallel()
-	type fields struct {
-		index  int
-		after  [5]int
-		before [5]int
-	}
+	/* 删除元素 */
+	remove(nums, 2)
+	fmt.Println("删除索引 2 处的元素，得到 nums = ", nums)
 
-	tests := []struct {
-		name   string
-		fields fields
-	}{
-		{
-			name: "remove index[0]",
-			fields: struct {
-				index  int
-				after  [5]int
-				before [5]int
-			}{
-				index:  0,
-				after:  [5]int{2, 3, 4, 5, 0},
-				before: [5]int{1, 2, 3, 4, 5},
-			},
-		},
-		{
-			name: "remove end",
-			fields: struct {
-				index  int
-				after  [5]int
-				before [5]int
-			}{
-				index:  4,
-				after:  [5]int{1, 2, 3, 4, 0},
-				before: [5]int{1, 2, 3, 4, 5},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			v := tt.fields
-			remove(&v.before, v.index)
-			if !reflect.DeepEqual(v.before, v.after) {
-				t.Errorf("remove(&v.before, v.index) = %v, want %v", v.before, v.after)
-			}
-		})
-	}
-}
-
-func TestTraverse(t *testing.T) {
-	t.Parallel()
-	nums := [5]int{1, 2, 3, 4, 5}
+	/* 遍历数组 */
 	traverse(nums)
-}
-
-func TestFind(t *testing.T) {
-	t.Parallel()
-	type fields struct {
-		target int
-		nums   [5]int
-	}
-
-	tests := []struct {
-		name   string
-		fields fields
-		want   int
-	}{
-		{
-			name: "element exists",
-			fields: struct {
-				target int
-				nums   [5]int
-			}{
-				target: 1,
-				nums:   [5]int{1, 2, 3, 4, 5},
-			},
-			want: 0,
-		},
-		{
-			name: "element does not exist",
-			fields: struct {
-				target int
-				nums   [5]int
-			}{
-				target: 6,
-				nums:   [5]int{1, 2, 3, 4, 5},
-			},
-			want: -1,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			v := tt.fields
-			if got := find(v.nums, v.target); got != tt.want {
-				t.Errorf("find(v.nums, v.target) = %v, want %v", got, tt.want)
-			}
-		})
-	}
+
+	/* 查找元素 */
+	index := find(nums, 3)
+	fmt.Println("在 nums 中查找元素 3 ，得到索引 = ", index)
 }
diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 52d23024f..643b16a23 100644
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -44,8 +44,8 @@ comments: true
 
     ```go title="array.go"
     /* 初始化数组 */
-    var arr [5]int // {0, 0, 0, 0, 0}
-    nums := [5]int{1, 3, 2, 5, 4}
+    var arr []int
+    nums := []int{1, 3, 2, 5, 4}
     ```
 
 === "JavaScript"
@@ -136,11 +136,11 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
     ```go title="array.go"
     /* 随机返回一个数组元素 */
-    func randomAccess(nums [5]int) (ans int) {
+    func randomAccess(nums [5]int) (randomNum int) {
         // 在区间 [0, nums.length) 中随机抽取一个数字
         randomIndex := rand.Intn(len(nums))
         // 获取并返回随机元素
-        ans = nums[randomIndex]
+        randomNum = nums[randomIndex]
         return
     }
     ```
@@ -245,13 +245,10 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    // 在 Go 中，声明数组长度必须是常量表达式，
-    // 所以这里我们约定，扩展后的长度为 6
-    const expectSize = 6
-    // 扩展数组长度
-    func extend(nums [5]int) [expectSize]int {
+    /* 扩展数组长度 */
+    func extend(nums []int, enlarge int) []int {
         // 初始化一个扩展长度后的数组
-        var res [expectSize]int
+        res := make([]int, len(nums)+enlarge)
         // 将原数组中的所有元素复制到新数组
         for i := 0; i < len(nums); i++ {
             res[i] = nums[i]
@@ -393,7 +390,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
     ```go title="array.go"
     /* 在数组的索引 index 处插入元素 num */
-    func insert(nums [5]int, num int, index int) {
+    func insert(nums []int, num int, index int) {
         // 把索引 index 以及之后的所有元素向后移动一位
         // 如果超出了数组长度，会被直接舍弃
         for i := len(nums) - 1; i > index; i-- {
@@ -404,11 +401,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     }
 
     /* 删除索引 index 处元素 */
-    func remove(nums [5]int, index int) {
-        // 越界检查
-        if index >= len(nums) {
-            return
-        }
+    func remove(nums []int, index int) {
         // 把索引 index 之后的所有元素向前移动一位
         for i := index; i < len(nums); i++ {
             if i+1 >= len(nums) {
@@ -547,7 +540,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
     ```go title="array.go"
     /* 遍历数组 */
-    func traverse(nums [5]int) {
+    func traverse(nums []int) {
         var count int
         // 通过索引遍历数组
         for i := 0; i < len(nums); i++ {
@@ -555,7 +548,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
         }
         // 直接遍历数组
         for index, val := range nums {
-            fmt.Printf("index:%d value:%d\n", index, val)
+            fmt.Printf("index:%v value:%v\n", index, val)
         }
     }
     ```
@@ -663,11 +656,11 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
     ```go title="array.go"
     /* 在数组中查找指定元素 */
-    func find(nums [5]int, target int) (ans int){
-        ans = -1
+    func find(nums []int, target int) (index int) {
+        index = -1
         for i := 0; i < len(nums); i++ {
             if nums[i] == target {
-                ans = i
+                index = i
                 break
             }
         }

From bd5cfb1117e52e8b81d1a29de454041df7388c9b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BE=9A=E5=9B=BD=E7=8E=AE?= <gongguowei01@gmail.com>
Date: Wed, 28 Dec 2022 12:29:29 +0800
Subject: [PATCH 026/158] docs(binary_tree): fix comment style and punctuation

---
 docs/chapter_tree/binary_tree.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md
index 07e311551..0c858fd3a 100644
--- a/docs/chapter_tree/binary_tree.md
+++ b/docs/chapter_tree/binary_tree.md
@@ -44,13 +44,13 @@ comments: true
 === "Go"
 
     ```go title=""
-    // 链表结点类
+    /* 链表结点类 */
     type TreeNode struct {
         Val   int
         Left  *TreeNode
         Right *TreeNode
     }
-    // 结点初始化方法
+    /* 结点初始化方法 */
     func NewTreeNode(v int) *TreeNode {
         return &TreeNode{
             Left:  nil,
@@ -121,7 +121,7 @@ comments: true
 - 「根结点 Root Node」：二叉树最顶层的结点，其没有父结点；
 - 「叶结点 Leaf Node」：没有子结点的结点，其两个指针都指向 $\text{null}$ ；
 - 结点所处「层 Level」：从顶置底依次增加，根结点所处层为 1 ；
-- 结点「度 Degree」：结点的子结点数量，二叉树中度的范围是 0, 1, 2 ；
+- 结点「度 Degree」：结点的子结点数量。二叉树中，度的范围是 0, 1, 2 ；
 - 「边 Edge」：连接两个结点的边，即结点指针；
 - 二叉树「高度」：二叉树中根结点到最远叶结点走过边的数量；
 - 结点「深度 Depth」 ：根结点到该结点走过边的数量；

From af5497e70bae154f295ba1d6ff7c02af34b765c9 Mon Sep 17 00:00:00 2001
From: XC-Zero <55583209+XC-Zero@users.noreply.github.com>
Date: Wed, 28 Dec 2022 14:11:36 +0800
Subject: [PATCH 027/158] Update data_and_memory.md

add code for go
---
 docs/chapter_data_structure/data_and_memory.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/docs/chapter_data_structure/data_and_memory.md b/docs/chapter_data_structure/data_and_memory.md
index 78fcac857..b4c8fbe56 100644
--- a/docs/chapter_data_structure/data_and_memory.md
+++ b/docs/chapter_data_structure/data_and_memory.md
@@ -74,7 +74,11 @@ comments: true
 === "Go"
 
     ```go title=""
-
+    var numbers =[5]int{}
+	var decimals =[5]float64{}
+	// go 里没有char ,但有 rune/byte 代替 char
+	var characters =[5]byte{}
+	var booleans =[5]bool{}
     ```
 
 === "JavaScript"

From a4161b5fa2747be17be932d1b5d9227b08a8fad9 Mon Sep 17 00:00:00 2001
From: XC-Zero <55583209+XC-Zero@users.noreply.github.com>
Date: Wed, 28 Dec 2022 14:27:28 +0800
Subject: [PATCH 028/158] Update data_and_memory.md

update tab to space
---
 docs/chapter_data_structure/data_and_memory.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/chapter_data_structure/data_and_memory.md b/docs/chapter_data_structure/data_and_memory.md
index b4c8fbe56..0a4787845 100644
--- a/docs/chapter_data_structure/data_and_memory.md
+++ b/docs/chapter_data_structure/data_and_memory.md
@@ -74,11 +74,11 @@ comments: true
 === "Go"
 
     ```go title=""
-    var numbers =[5]int{}
-	var decimals =[5]float64{}
-	// go 里没有char ,但有 rune/byte 代替 char
-	var characters =[5]byte{}
-	var booleans =[5]bool{}
+    var numbers = [5]int{}
+    var decimals = [5]float64{}
+    // go 里没有char ,但有 rune/byte 用以代替 char
+    var characters = [5]byte{}
+    var booleans = [5]bool{}
     ```
 
 === "JavaScript"

From debcc984e1cc339f92c036b12cadbea7c65822ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BE=9A=E5=9B=BD=E7=8E=AE?= <gongguowei01@gmail.com>
Date: Wed, 28 Dec 2022 17:07:59 +0800
Subject: [PATCH 029/158] docs(binary_search_tree): variable name error

Combining Context, Compare 'cur.val' and 'num', not 'cur.val' and 'val`.
---
 docs/chapter_tree/binary_search_tree.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md
index b341e3dc4..629c051f1 100644
--- a/docs/chapter_tree/binary_search_tree.md
+++ b/docs/chapter_tree/binary_search_tree.md
@@ -17,9 +17,9 @@ comments: true
 
 给定目标结点值 `num` ，可以根据二叉搜索树的性质来查找。我们声明一个结点 `cur` ，从二叉树的根结点 `root` 出发，循环比较结点值 `cur.val` 和 `num` 之间的大小关系
 
-- 若 `cur.val < val` ，说明目标结点在 `cur` 的右子树中，因此执行 `cur = cur.right` ；
-- 若 `cur.val > val` ，说明目标结点在 `cur` 的左子树中，因此执行 `cur = cur.left` ；
-- 若 `cur.val = val` ，说明找到目标结点，跳出循环并返回该结点即可；
+- 若 `cur.val < num` ，说明目标结点在 `cur` 的右子树中，因此执行 `cur = cur.right` ；
+- 若 `cur.val > num` ，说明目标结点在 `cur` 的左子树中，因此执行 `cur = cur.left` ；
+- 若 `cur.val = num` ，说明找到目标结点，跳出循环并返回该结点即可；
 
 === "Step 1"
 

From 678e1a025b4a1050c0897372d5ddc0c6d4e9d332 Mon Sep 17 00:00:00 2001
From: sjinzh <99076655+sjinzh@users.noreply.github.com>
Date: Wed, 28 Dec 2022 20:04:39 +0800
Subject: [PATCH 030/158] add zig language support

---
 .../time_complexity.zig                       | 179 ++++++++++++++++++
 .../worst_best_time_complexity.zig            |  42 ++++
 2 files changed, 221 insertions(+)
 create mode 100644 codes/zig/chapter_computational_complexity/time_complexity.zig
 create mode 100644 codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig

diff --git a/codes/zig/chapter_computational_complexity/time_complexity.zig b/codes/zig/chapter_computational_complexity/time_complexity.zig
new file mode 100644
index 000000000..dab17034a
--- /dev/null
+++ b/codes/zig/chapter_computational_complexity/time_complexity.zig
@@ -0,0 +1,179 @@
+// File: time_complexity.zig
+// Created Time: 2022-12-28
+// Author: sjinzh (sjinzh@gmail.com)
+
+const std = @import("std");
+
+// 常数阶
+fn constant(n: i32) i32 {
+    _ = n;
+    var count: i32 = 0;
+    const size: i32 = 100_000;
+    var i: i32 = 0;
+    while(i<size) : (i += 1) {
+        count += 1;
+    }
+    return count;
+}
+
+// 线性阶
+fn linear(n: i32) i32 {
+    var count: i32 = 0;
+    var i: i32 = 0;
+    while (i < n) : (i += 1) {
+        count += 1;
+    }
+    return count;
+}
+
+// 线性阶（遍历数组）
+fn arrayTraversal(nums: []i32) i32 {
+    var count: i32 = 0;
+    // 循环次数与数组长度成正比
+    for (nums) |_| {
+        count += 1;
+    }
+    return count;
+}
+
+// 平方阶
+fn quadratic(n: i32) i32 {
+    var count: i32 = 0;
+    var i: i32 = 0;
+    // 循环次数与数组长度成平方关系
+    while (i < n) : (i += 1) {
+        var j: i32 = 0;
+        while (j < n) : (j += 1) {
+            count += 1;
+        }
+    }
+    return count;
+}
+
+// 平方阶（冒泡排序）
+fn bubbleSort(nums: []i32) i32 {
+    var count: i32 = 0;  // 计数器 
+    // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+    var i: i32 = @intCast(i32, nums.len ) - 1;
+    while (i > 0) : (i -= 1) {
+        var j: usize = 0;
+        // 内循环：冒泡操作
+        while (j < i) : (j += 1) {
+            // 交换 nums[j] 与 nums[j + 1]
+            var tmp = nums[j];
+            nums[j] = nums[j + 1];
+            nums[j + 1] = tmp;
+            count += 3;  // 元素交换包含 3 个单元操作
+        }
+    }
+    return count;
+}
+
+// 指数阶（循环实现）
+fn exponential(n: i32) i32{
+    var count: i32 = 0;
+    var bas: i32 = 1;
+    var i: i32 = 0;
+    // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+    while (i < n) : (i += 1) {
+        var j: i32 = 0;
+        while (j < bas) : (j += 1) {
+            count += 1;
+        }
+        bas *= 2;
+    }
+    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+    return count;
+}
+
+// 指数阶（递归实现）
+fn expRecur(n: i32) i32{
+    if (n == 1) return 1;
+    return expRecur(n - 1) + expRecur(n - 1) + 1;
+}
+
+// 对数阶（循环实现）
+fn logarithmic(n: f32) i32
+{
+    var count: i32 = 0;
+    var n_var = n;
+    while (n_var > 1)
+    {
+        n_var = n_var / 2;
+        count +=1;
+    }
+    return count;
+}
+
+// 对数阶（递归实现）
+fn logRecur(n: f32) i32
+{
+    if (n <= 1) return 0;
+    return logRecur(n / 2) + 1;
+}
+
+// 线性对数阶
+fn linearLogRecur(n: f32) i32
+{
+    if (n <= 1) return 1;
+    var count: i32 = linearLogRecur(n / 2) +
+                linearLogRecur(n / 2);
+    var i: f32 = 0;
+    while (i < n) : (i += 1) {
+        count += 1;
+    }
+    return count;
+}
+
+// 阶乘阶（递归实现）
+fn factorialRecur(n: i32) i32 {
+    if (n == 0) return 1;
+    var count: i32 = 0;
+    var i: i32 = 0;
+    // 从 1 个分裂出 n 个
+    while (i < n) : (i += 1) {
+        count += factorialRecur(n - 1);
+    }
+    return count;
+}
+
+// Driver Code
+pub fn main() void {
+    // 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
+    const n: i32 = 8;
+    std.debug.print("输入数据大小 n = {}\n", .{n});
+
+    var count = constant(n);
+    std.debug.print("常数阶的计算操作数量 = {}\n", .{count});
+
+    count = linear(n);
+    std.debug.print("线性阶的计算操作数量 = {}\n", .{count});
+    var nums = [_]i32{0}**n;
+    count = arrayTraversal(&nums);
+    std.debug.print("线性阶（遍历数组）的计算操作数量 = {}\n", .{count});
+
+    count = quadratic(n);
+    std.debug.print("平方阶的计算操作数量 = {}\n", .{count});
+    for (nums) |*num, i| {
+        num.* = n - @intCast(i32, i);  // [n,n-1,...,2,1]
+    }
+    count = bubbleSort(&nums);
+    std.debug.print("平方阶（冒泡排序）的计算操作数量 = {}\n", .{count});
+
+    count = exponential(n);
+    std.debug.print("指数阶（循环实现）的计算操作数量 = {}\n", .{count});
+    count = expRecur(n);
+    std.debug.print("指数阶（递归实现）的计算操作数量 = {}\n", .{count});
+
+    count = logarithmic(@as(f32, n));
+    std.debug.print("对数阶（循环实现）的计算操作数量 = {}\n", .{count});
+    count = logRecur(@as(f32, n));
+    std.debug.print("对数阶（递归实现）的计算操作数量 = {}\n", .{count});
+
+    count = linearLogRecur(@as(f32, n));
+    std.debug.print("线性对数阶（递归实现）的计算操作数量 = {}\n", .{count});
+
+    count = factorialRecur(n);
+    std.debug.print("阶乘阶（递归实现）的计算操作数量 = {}\n", .{count});
+}
+
diff --git a/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig b/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig
new file mode 100644
index 000000000..dacf45952
--- /dev/null
+++ b/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig
@@ -0,0 +1,42 @@
+// File: worst_best_time_complexity.zig
+// Created Time: 2022-12-28
+// Author: sjinzh (sjinzh@gmail.com)
+
+const std = @import("std");
+
+// 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱
+pub fn randomNumbers(comptime n: usize) [n]i32 {
+    var nums: [n]i32 = undefined;
+    // 生成数组 nums = { 1, 2, 3, ..., n }
+    for (nums) |*num, i| {
+        num.* = @intCast(i32, i) + 1;
+    }
+    // 随机打乱数组元素
+    const rand = std.crypto.random;
+    rand.shuffle(i32, &nums);
+    return nums;
+}
+
+// 查找数组 nums 中数字 1 所在索引
+pub fn findOne(nums: []i32) i32 {
+    for (nums) |num, i| {
+        if (num == 1) return @intCast(i32, i);
+    }
+    return -1;
+}
+
+// Driver Code
+pub fn main() !void {
+    var i: i32 = 0;
+    while (i < 10) : (i += 1) {
+        const n: usize = 100;
+        var nums = randomNumbers(n);
+        var index = findOne(&nums);
+        std.debug.print("\n数组 [ 1, 2, ..., n ] 被打乱后 = ", .{});
+        for (nums) |num, j| {
+            std.debug.print("{}{s}", .{num, if (j == nums.len-1) "" else "," });
+        }
+        std.debug.print("\n数字 1 的索引为 {}\n", .{index});
+    }
+}
+

From 78c2b94422818e7c0bcc2dcedec12ce8306a2b49 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 29 Dec 2022 00:49:50 +0800
Subject: [PATCH 031/158] Update data_and_memory.md

---
 docs/chapter_data_structure/data_and_memory.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/chapter_data_structure/data_and_memory.md b/docs/chapter_data_structure/data_and_memory.md
index 0a4787845..3e1e2167c 100644
--- a/docs/chapter_data_structure/data_and_memory.md
+++ b/docs/chapter_data_structure/data_and_memory.md
@@ -74,9 +74,9 @@ comments: true
 === "Go"
 
     ```go title=""
+    // 使用多种「基本数据类型」来初始化「数组」
     var numbers = [5]int{}
     var decimals = [5]float64{}
-    // go 里没有char ,但有 rune/byte 用以代替 char
     var characters = [5]byte{}
     var booleans = [5]bool{}
     ```

From 4fb267918b6047b946f4eaebb193d44929e4419a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BE=9A=E5=9B=BD=E7=8E=AE?= <gongguowei01@gmail.com>
Date: Thu, 29 Dec 2022 10:06:11 +0800
Subject: [PATCH 032/158] docs(array): add file author, created time

---
 codes/go/chapter_array_and_linkedlist/array.go      | 4 ++++
 codes/go/chapter_array_and_linkedlist/array_test.go | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/codes/go/chapter_array_and_linkedlist/array.go b/codes/go/chapter_array_and_linkedlist/array.go
index ccc5db19b..26c056763 100644
--- a/codes/go/chapter_array_and_linkedlist/array.go
+++ b/codes/go/chapter_array_and_linkedlist/array.go
@@ -1,3 +1,7 @@
+// File: array.go
+// Created Time: 2022-12-29
+// Author: GuoWei (gongguowei01@gmail.com)
+
 package chapter_array_and_linkedlist
 
 import (
diff --git a/codes/go/chapter_array_and_linkedlist/array_test.go b/codes/go/chapter_array_and_linkedlist/array_test.go
index 3f9882a9d..384cc34d9 100644
--- a/codes/go/chapter_array_and_linkedlist/array_test.go
+++ b/codes/go/chapter_array_and_linkedlist/array_test.go
@@ -1,3 +1,7 @@
+// File: array_test.go
+// Created Time: 2022-12-29
+// Author: GuoWei (gongguowei01@gmail.com)
+
 package chapter_array_and_linkedlist
 
 /**

From c0e8b75bfd323b9dd304301b28969dc7d9d6cb75 Mon Sep 17 00:00:00 2001
From: Cathay <cathaycchen@gmail.com>
Date: Thu, 29 Dec 2022 13:26:09 +0800
Subject: [PATCH 033/158] feat(array): add the Go code to array docs (Chapter
 of Array and LinkedList)

---
 .../go/chapter_array_and_linkedlist/array.go  | 78 +++++++++++++++++++
 .../array_test.go                             | 28 +++++++
 docs/chapter_array_and_linkedlist/array.md    | 63 +++++++++++++--
 3 files changed, 163 insertions(+), 6 deletions(-)
 create mode 100644 codes/go/chapter_array_and_linkedlist/array.go
 create mode 100644 codes/go/chapter_array_and_linkedlist/array_test.go

diff --git a/codes/go/chapter_array_and_linkedlist/array.go b/codes/go/chapter_array_and_linkedlist/array.go
new file mode 100644
index 000000000..416957ff3
--- /dev/null
+++ b/codes/go/chapter_array_and_linkedlist/array.go
@@ -0,0 +1,78 @@
+// File: array.go
+// Created Time: 2022-12-29
+// Author: cathay (cathaycchen@gmail.com)
+
+package chapter_array_and_linkedlist
+
+import (
+	"fmt"
+	"math/rand"
+)
+
+/* 初始化数组 */
+var arr = [5]int{}
+var nums = []int{1, 3, 2, 5, 4}
+
+/* 随机返回一个数组元素 */
+func randomAccess(nums []int) int {
+	randomIndex := rand.Intn(len(nums))
+	randomNum := nums[randomIndex]
+	return randomNum
+}
+
+/* 扩展数组长度 */
+func extend(nums []int, enlarge int) []int {
+	// 初始化一个扩展长度后的数组
+	res := make([]int, len(nums)+enlarge)
+	// 将原数组中的所有元素复制到新数组
+	for i, num := range nums {
+		res[i] = num
+	}
+	// 返回扩展后的新数组
+	return res
+}
+
+/* 在数组的索引 index 处插入元素 num */
+func insert(nums []int, size int, num int, index int) {
+	// 把索引 index 以及之后的所有元素向后移动一位
+	for i := size - 1; i > index; i-- {
+		nums[i] = nums[i-1]
+	}
+	// 将 num 赋给 index 处元素
+	nums[index] = num
+}
+
+/* 删除索引 index 处元素 */
+func remove(nums []int, size int, index int) {
+	// 把索引 index 之后的所有元素向前移动一位
+	for i := index; i < size-1; i++ {
+		nums[i] = nums[i+1]
+	}
+}
+
+/* 遍历数组 */
+func traverse(nums []int) {
+	count := 0
+	// 通过索引遍历数组
+	for i := 0; i < len(nums); i++ {
+		count++
+	}
+	fmt.Println(count)
+
+	count = 0
+	// 直接遍历数组
+	for range nums {
+		count++
+	}
+	fmt.Println(count)
+}
+
+/* 在数组中查找指定元素，返回第一个索引位置，未查找到则返回 -1 */
+func find(nums []int, target int) int {
+	for i := 0; i < len(nums); i++ {
+		if nums[i] == target {
+			return i
+		}
+	}
+	return -1
+}
diff --git a/codes/go/chapter_array_and_linkedlist/array_test.go b/codes/go/chapter_array_and_linkedlist/array_test.go
new file mode 100644
index 000000000..37f75a55d
--- /dev/null
+++ b/codes/go/chapter_array_and_linkedlist/array_test.go
@@ -0,0 +1,28 @@
+// File: array_test.go
+// Created Time: 2022-12-29
+// Author: cathay (cathaycchen@gmail.com)
+
+package chapter_array_and_linkedlist
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestArray(t *testing.T) {
+	nums := make([]int, 5)
+	fmt.Println("randomAccess:", randomAccess(nums))
+
+	fmt.Println("extend:", extend(nums, 5))
+
+	insert(nums, 5, 2, 2)
+	fmt.Println("after insert:", nums)
+
+	remove(nums, 5, 2)
+	fmt.Println("after remove:", nums)
+
+	fmt.Println("traverse nums:")
+	traverse(nums)
+
+	fmt.Println("find value 2 key:", find(nums, 2))
+}
diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 70e30129a..bae5c2772 100644
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -43,7 +43,8 @@ comments: true
 === "Go"
 
     ```go title="array.go"
-
+    var arr = [5]int{}
+    var nums = [5]int{1, 3, 2, 5, 4}
     ```
 
 === "JavaScript"
@@ -136,7 +137,12 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 随机返回一个数组元素 */
+    func randomAccess(nums []int) int {
+        randomIndex := rand.Intn(len(nums))
+        randomNum := nums[randomIndex]
+        return randomNum
+    }
     ```
 
 === "JavaScript"
@@ -239,7 +245,17 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 扩展数组长度 */
+    func extend(nums []int, enlarge int) []int {
+        // 初始化一个扩展长度后的数组
+        res := make([]int, len(nums)+enlarge)
+        // 将原数组中的所有元素复制到新数组
+        for i, num := range nums {
+            res[i] = num
+        }
+        // 返回扩展后的新数组
+        return res
+    }
     ```
 
 === "JavaScript"
@@ -373,7 +389,23 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 在数组的索引 index 处插入元素 num */
+    func insert(nums []int, size int, num int, index int) {
+        // 把索引 index 以及之后的所有元素向后移动一位
+        for i := size - 1; i > index; i-- {
+            nums[i] = nums[i-1]
+        }
+        // 将 num 赋给 index 处元素
+        nums[index] = num
+    }
+
+    /* 删除索引 index 处元素 */
+    func remove(nums []int, size int, index int) {
+        // 把索引 index 之后的所有元素向前移动一位
+        for i := index; i < size-1; i++ {
+            nums[i] = nums[i+1]
+        }
+    }
     ```
 
 === "JavaScript"
@@ -502,7 +534,18 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 遍历数组 */
+    func traverse(nums []int) {
+        count := 0
+        // 通过索引遍历数组
+        for i := 0; i < len(nums); i++ {
+            count++
+        }
+        // 直接遍历数组
+        for range nums {
+            count++
+        }
+    }
     ```
 
 === "JavaScript"
@@ -607,7 +650,15 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 在数组中查找指定元素，返回第一个索引位置，未查找到则返回 -1 */
+    func find(nums []int, target int) int {
+        for i := 0; i < len(nums); i++ {
+            if nums[i] == target {
+                return i
+            }
+        }
+        return -1
+    }
     ```
 
 === "JavaScript"

From a5e923a387f8380ede28b0b7a4bf0983e02b6705 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BE=9A=E5=9B=BD=E7=8E=AE?= <gongguowei01@gmail.com>
Date: Thu, 29 Dec 2022 14:44:15 +0800
Subject: [PATCH 034/158] test(binary_search_tree): update test param

use param value 7, not 5, function test param value with param value in example picture as same.
---
 codes/go/chapter_tree/binary_search_tree_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/codes/go/chapter_tree/binary_search_tree_test.go b/codes/go/chapter_tree/binary_search_tree_test.go
index 0d0369a78..d98e5d661 100644
--- a/codes/go/chapter_tree/binary_search_tree_test.go
+++ b/codes/go/chapter_tree/binary_search_tree_test.go
@@ -23,7 +23,7 @@ func TestBinarySearchTree(t *testing.T) {
 	fmt.Println("二叉树的最小结点为:", node.Val)
 
 	// 查找结点
-	node = bst.Search(5)
+	node = bst.Search(7)
 	fmt.Println("查找到的结点对象为", node, "，结点值 =", node.Val)
 
 	// 插入结点

From 1062fe64a398aacb8c4e00e17c03e57289dd9ae9 Mon Sep 17 00:00:00 2001
From: Cathay <cathaycchen@gmail.com>
Date: Thu, 29 Dec 2022 17:43:16 +0800
Subject: [PATCH 035/158] feat(linked_list): add the Go code to linked_list
 docs (Chapter of Array and LinkedList)

---
 .../linked_list.go                            | 105 ++++++++++++++++++
 .../linked_list_test.go                       |  47 ++++++++
 .../linked_list.md                            |  82 +++++++++++++-
 3 files changed, 230 insertions(+), 4 deletions(-)
 create mode 100644 codes/go/chapter_array_and_linkedlist/linked_list.go
 create mode 100644 codes/go/chapter_array_and_linkedlist/linked_list_test.go

diff --git a/codes/go/chapter_array_and_linkedlist/linked_list.go b/codes/go/chapter_array_and_linkedlist/linked_list.go
new file mode 100644
index 000000000..3129a0eaf
--- /dev/null
+++ b/codes/go/chapter_array_and_linkedlist/linked_list.go
@@ -0,0 +1,105 @@
+// File: linked_list.go
+// Created Time: 2022-12-29
+// Author: cathay (cathaycchen@gmail.com)
+
+package chapter_array_and_linkedlist
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+/* 链表结点结构体 */
+type ListNode struct {
+	Val  int       // 结点值
+	Next *ListNode // 指向下一结点的指针（引用）
+}
+
+// NewListNode 构造函数，创建一个新的链表
+func NewListNode(val int) *ListNode {
+	return &ListNode{
+		Val:  val,
+		Next: nil,
+	}
+}
+
+// PrintLinkedList Print a linked list
+func PrintLinkedList(node *ListNode) {
+	if node == nil {
+		return
+	}
+	var builder strings.Builder
+	for node.Next != nil {
+		builder.WriteString(strconv.Itoa(node.Val) + " -> ")
+		node = node.Next
+	}
+	builder.WriteString(strconv.Itoa(node.Val))
+	fmt.Println(builder.String())
+}
+
+/* 在链表的结点 n0 之后插入结点 P */
+func insertNode(n0 *ListNode, P *ListNode) {
+	n1 := n0.Next
+	n0.Next = P
+	P.Next = n1
+}
+
+/* 删除链表的结点 n0 之后的首个结点 */
+func removeNode(n0 *ListNode) {
+	if n0.Next == nil {
+		return
+	}
+	// n0 -> P -> n1
+	P := n0.Next
+	n1 := P.Next
+	n0.Next = n1
+}
+
+/* 访问链表中索引为 index 的结点 */
+func access(head *ListNode, index int) *ListNode {
+	for i := 0; i < index; i++ {
+		head = head.Next
+		if head == nil {
+			return nil
+		}
+	}
+	return head
+}
+
+/* 在链表中查找值为 target 的首个结点 */
+func findNode(head *ListNode, target int) int {
+	index := 0
+	for head != nil {
+		if head.Val == target {
+			return index
+		}
+		head = head.Next
+		index++
+	}
+	return -1
+}
+
+/* 双向链表结点结构体 */
+type DoublyListNode struct {
+	Val  int             // 结点值
+	Next *DoublyListNode // 指向后继结点的指针（引用）
+	Prev *DoublyListNode // 指向前驱结点的指针（引用）
+}
+
+// NewDoublyListNode 初始化
+func NewDoublyListNode(val int, nodes ...*DoublyListNode) *DoublyListNode {
+	var next, prev *DoublyListNode
+	length := len(nodes)
+	if length > 0 {
+		next = nodes[0]
+	}
+	if length > 1 {
+		prev = nodes[1]
+	}
+	return &DoublyListNode{
+		Val:  val,
+		Next: next,
+		Prev: prev,
+	}
+}
diff --git a/codes/go/chapter_array_and_linkedlist/linked_list_test.go b/codes/go/chapter_array_and_linkedlist/linked_list_test.go
new file mode 100644
index 000000000..5deabff88
--- /dev/null
+++ b/codes/go/chapter_array_and_linkedlist/linked_list_test.go
@@ -0,0 +1,47 @@
+// File: linked_list_test.go
+// Created Time: 2022-12-29
+// Author: cathay (cathaycchen@gmail.com)
+
+package chapter_array_and_linkedlist
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestLikedList(t *testing.T) {
+	/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+	// 初始化各个结点
+	n0 := NewListNode(1)
+	n1 := NewListNode(3)
+	n2 := NewListNode(2)
+	n3 := NewListNode(5)
+	n4 := NewListNode(4)
+
+	// 构建引用指向
+	n0.Next = n1
+	n1.Next = n2
+	n2.Next = n3
+	n3.Next = n4
+
+	fmt.Println("链表结构：")
+	PrintLinkedList(n0)
+
+	P := NewListNode(6)
+
+	/* 在链表的结点 n0 之后插入结点 P */
+	insertNode(n0, P)
+	fmt.Println("在链表的结点 n0 之后插入结点 P 后，链表结构：")
+	PrintLinkedList(n0)
+
+	/* 删除链表的结点 n0 之后的首个结点 */
+	removeNode(n0)
+	fmt.Println("删除链表的结点 n0 之后的首个结点后，链表结构：")
+	PrintLinkedList(n0)
+
+	/* 访问链表中索引为 index 的结点 */
+	fmt.Println("访问链表中索引为 2 的结点：", access(n0, 2))
+
+	/* 在链表中查找值为 target 的首个结点 */
+	fmt.Println("在链表中查找 5 的首个节点索引值：", findNode(n0, 5))
+}
diff --git a/docs/chapter_array_and_linkedlist/linked_list.md b/docs/chapter_array_and_linkedlist/linked_list.md
index 6ad1d5658..83c8db64e 100644
--- a/docs/chapter_array_and_linkedlist/linked_list.md
+++ b/docs/chapter_array_and_linkedlist/linked_list.md
@@ -51,7 +51,19 @@ comments: true
 === "Go"
 
     ```go title=""
-
+    /* 链表结点结构体 */
+    type ListNode struct {
+        Val  int       // 结点值
+        Next *ListNode // 指向下一结点的指针（引用）
+    }
+    
+    // NewListNode 构造函数，创建一个新的链表
+    func NewListNode(val int) *ListNode {
+        return &ListNode{
+            Val:  val,
+            Next: nil,
+        }
+    }
     ```
 
 === "JavaScript"
@@ -162,7 +174,19 @@ comments: true
 === "Go"
 
     ```go title=""
+	/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+	// 初始化各个结点
+	n0 := NewListNode(1)
+	n1 := NewListNode(3)
+	n2 := NewListNode(2)
+	n3 := NewListNode(5)
+	n4 := NewListNode(4)
 
+	// 构建引用指向
+	n0.Next = n1
+	n1.Next = n2
+	n2.Next = n3
+	n3.Next = n4
     ```
 
 === "JavaScript"
@@ -294,7 +318,23 @@ comments: true
 === "Go"
 
     ```go title=""
+    /* 在链表的结点 n0 之后插入结点 P */
+    func insert(n0 *ListNode, P *ListNode) {
+        n1 := n0.Next
+        n0.Next = P
+        P.Next = n1
+    }
 
+    /* 删除链表的结点 n0 之后的首个结点 */
+    func removeNode(n0 *ListNode) {
+        if n0.Next == nil {
+            return
+        }
+        // n0 -> P -> n1
+        P := n0.Next
+        n1 := P.Next
+        n0.Next = n1
+    }
     ```
 
 === "JavaScript"
@@ -415,7 +455,16 @@ comments: true
 === "Go"
 
     ```go title=""
-
+    /* 访问链表中索引为 index 的结点 */
+    func access(head *ListNode, index int) *ListNode {
+        for i := 0; i < index; i++ {
+            head = head.Next
+            if head == nil {
+                return nil
+            }
+        }
+        return head
+    }
     ```
 
 === "JavaScript"
@@ -524,7 +573,18 @@ comments: true
 === "Go"
 
     ```go title=""
-
+    /* 在链表中查找值为 target 的首个结点 */
+    func find(head *ListNode, target int) int {
+        index := 0
+        for head != nil {
+            if head.Val == target {
+                return index
+            }
+            head = head.Next
+            index++
+        }
+        return -1
+    }
     ```
 
 === "JavaScript"
@@ -631,7 +691,21 @@ comments: true
 === "Go"
 
     ```go title=""
-
+    /* 双向链表结点结构体 */
+    type DoublyListNode struct {
+        Val  int             // 结点值
+        Next *DoublyListNode // 指向后继结点的指针（引用）
+        Prev *DoublyListNode // 指向前驱结点的指针（引用）
+    }
+    
+    // NewDoublyListNode 初始化
+    func NewDoublyListNode(val int) *DoublyListNode {
+        return &DoublyListNode{
+            Val:  val,
+            Next: nil,
+            Prev: nil,
+        }
+    }
     ```
 
 === "JavaScript"

From cd9f4fc35d48cbb0547622d40fcef2d01e814d28 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=99=88=E5=9B=BD=E5=A4=AA?= <cathaycchen@gmail.com>
Date: Thu, 29 Dec 2022 21:49:46 +0800
Subject: [PATCH 036/158] fix(array and linkedlist): fix that the printing in
 the test function is the same as that in other languages

---
 .../go/chapter_array_and_linkedlist/array.go  | 12 ++--
 .../array_test.go                             | 33 +++++++---
 .../linked_list.go                            | 64 ++-----------------
 .../linked_list_test.go                       | 42 ++++++------
 4 files changed, 54 insertions(+), 97 deletions(-)

diff --git a/codes/go/chapter_array_and_linkedlist/array.go b/codes/go/chapter_array_and_linkedlist/array.go
index 416957ff3..1a02bea47 100644
--- a/codes/go/chapter_array_and_linkedlist/array.go
+++ b/codes/go/chapter_array_and_linkedlist/array.go
@@ -9,10 +9,6 @@ import (
 	"math/rand"
 )
 
-/* 初始化数组 */
-var arr = [5]int{}
-var nums = []int{1, 3, 2, 5, 4}
-
 /* 随机返回一个数组元素 */
 func randomAccess(nums []int) int {
 	randomIndex := rand.Intn(len(nums))
@@ -33,9 +29,9 @@ func extend(nums []int, enlarge int) []int {
 }
 
 /* 在数组的索引 index 处插入元素 num */
-func insert(nums []int, size int, num int, index int) {
+func insert(nums []int, num int, index int) {
 	// 把索引 index 以及之后的所有元素向后移动一位
-	for i := size - 1; i > index; i-- {
+	for i := len(nums) - 1; i > index; i-- {
 		nums[i] = nums[i-1]
 	}
 	// 将 num 赋给 index 处元素
@@ -43,9 +39,9 @@ func insert(nums []int, size int, num int, index int) {
 }
 
 /* 删除索引 index 处元素 */
-func remove(nums []int, size int, index int) {
+func remove(nums []int, index int) {
 	// 把索引 index 之后的所有元素向前移动一位
-	for i := index; i < size-1; i++ {
+	for i := index; i < len(nums)-1; i++ {
 		nums[i] = nums[i+1]
 	}
 }
diff --git a/codes/go/chapter_array_and_linkedlist/array_test.go b/codes/go/chapter_array_and_linkedlist/array_test.go
index 37f75a55d..4938ac509 100644
--- a/codes/go/chapter_array_and_linkedlist/array_test.go
+++ b/codes/go/chapter_array_and_linkedlist/array_test.go
@@ -9,20 +9,35 @@ import (
 	"testing"
 )
 
+/* Driver Code */
 func TestArray(t *testing.T) {
-	nums := make([]int, 5)
-	fmt.Println("randomAccess:", randomAccess(nums))
+	/* 初始化数组 */
+	var arr = [5]int{}
+	fmt.Println("数组 arr =", arr)
 
-	fmt.Println("extend:", extend(nums, 5))
+	var nums = []int{1, 3, 2, 5, 4}
+	fmt.Println("数组 nums =", nums)
 
-	insert(nums, 5, 2, 2)
-	fmt.Println("after insert:", nums)
+	/* 随机访问 */
+	randomNum := randomAccess(nums)
+	fmt.Println("在 nums 中获取随机元素", randomNum)
 
-	remove(nums, 5, 2)
-	fmt.Println("after remove:", nums)
+	/* 长度扩展 */
+	nums = extend(nums, 3)
+	fmt.Println("将数组长度扩展至 8 ，得到 nums =", nums)
 
-	fmt.Println("traverse nums:")
+	/* 插入元素 */
+	insert(nums, 6, 3)
+	fmt.Println("在索引 3 处插入数字 6 ，得到 nums =", nums)
+
+	/* 删除元素 */
+	remove(nums, 2)
+	fmt.Println("删除索引 2 处的元素，得到 nums = ", nums)
+
+	/* 遍历数组 */
 	traverse(nums)
 
-	fmt.Println("find value 2 key:", find(nums, 2))
+	/* 查找元素 */
+	index := find(nums, 3)
+	fmt.Println("在 nums 中查找元素 3 ，得到索引 =", index)
 }
diff --git a/codes/go/chapter_array_and_linkedlist/linked_list.go b/codes/go/chapter_array_and_linkedlist/linked_list.go
index 3129a0eaf..e7fdb35ca 100644
--- a/codes/go/chapter_array_and_linkedlist/linked_list.go
+++ b/codes/go/chapter_array_and_linkedlist/linked_list.go
@@ -5,48 +5,18 @@
 package chapter_array_and_linkedlist
 
 import (
-	"fmt"
-	"strconv"
-	"strings"
+	"github.com/krahets/hello-algo/pkg"
 )
 
-/* 链表结点结构体 */
-type ListNode struct {
-	Val  int       // 结点值
-	Next *ListNode // 指向下一结点的指针（引用）
-}
-
-// NewListNode 构造函数，创建一个新的链表
-func NewListNode(val int) *ListNode {
-	return &ListNode{
-		Val:  val,
-		Next: nil,
-	}
-}
-
-// PrintLinkedList Print a linked list
-func PrintLinkedList(node *ListNode) {
-	if node == nil {
-		return
-	}
-	var builder strings.Builder
-	for node.Next != nil {
-		builder.WriteString(strconv.Itoa(node.Val) + " -> ")
-		node = node.Next
-	}
-	builder.WriteString(strconv.Itoa(node.Val))
-	fmt.Println(builder.String())
-}
-
 /* 在链表的结点 n0 之后插入结点 P */
-func insertNode(n0 *ListNode, P *ListNode) {
+func insertNode(n0 *pkg.ListNode, P *pkg.ListNode) {
 	n1 := n0.Next
 	n0.Next = P
 	P.Next = n1
 }
 
 /* 删除链表的结点 n0 之后的首个结点 */
-func removeNode(n0 *ListNode) {
+func removeNode(n0 *pkg.ListNode) {
 	if n0.Next == nil {
 		return
 	}
@@ -57,7 +27,7 @@ func removeNode(n0 *ListNode) {
 }
 
 /* 访问链表中索引为 index 的结点 */
-func access(head *ListNode, index int) *ListNode {
+func access(head *pkg.ListNode, index int) *pkg.ListNode {
 	for i := 0; i < index; i++ {
 		head = head.Next
 		if head == nil {
@@ -68,7 +38,7 @@ func access(head *ListNode, index int) *ListNode {
 }
 
 /* 在链表中查找值为 target 的首个结点 */
-func findNode(head *ListNode, target int) int {
+func findNode(head *pkg.ListNode, target int) int {
 	index := 0
 	for head != nil {
 		if head.Val == target {
@@ -79,27 +49,3 @@ func findNode(head *ListNode, target int) int {
 	}
 	return -1
 }
-
-/* 双向链表结点结构体 */
-type DoublyListNode struct {
-	Val  int             // 结点值
-	Next *DoublyListNode // 指向后继结点的指针（引用）
-	Prev *DoublyListNode // 指向前驱结点的指针（引用）
-}
-
-// NewDoublyListNode 初始化
-func NewDoublyListNode(val int, nodes ...*DoublyListNode) *DoublyListNode {
-	var next, prev *DoublyListNode
-	length := len(nodes)
-	if length > 0 {
-		next = nodes[0]
-	}
-	if length > 1 {
-		prev = nodes[1]
-	}
-	return &DoublyListNode{
-		Val:  val,
-		Next: next,
-		Prev: prev,
-	}
-}
diff --git a/codes/go/chapter_array_and_linkedlist/linked_list_test.go b/codes/go/chapter_array_and_linkedlist/linked_list_test.go
index 5deabff88..18061efff 100644
--- a/codes/go/chapter_array_and_linkedlist/linked_list_test.go
+++ b/codes/go/chapter_array_and_linkedlist/linked_list_test.go
@@ -6,42 +6,42 @@ package chapter_array_and_linkedlist
 
 import (
 	"fmt"
+	"github.com/krahets/hello-algo/pkg"
 	"testing"
 )
 
 func TestLikedList(t *testing.T) {
 	/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
 	// 初始化各个结点
-	n0 := NewListNode(1)
-	n1 := NewListNode(3)
-	n2 := NewListNode(2)
-	n3 := NewListNode(5)
-	n4 := NewListNode(4)
+	n0 := pkg.NewListNode(1)
+	n1 := pkg.NewListNode(3)
+	n2 := pkg.NewListNode(2)
+	n3 := pkg.NewListNode(5)
+	n4 := pkg.NewListNode(4)
 
 	// 构建引用指向
 	n0.Next = n1
 	n1.Next = n2
 	n2.Next = n3
 	n3.Next = n4
+	fmt.Println("初始化的链表为")
+	pkg.PrintLinkedList(n0)
 
-	fmt.Println("链表结构：")
-	PrintLinkedList(n0)
+	/* 插入结点 */
+	insertNode(n0, pkg.NewListNode(0))
+	fmt.Println("插入结点后的链表为")
+	pkg.PrintLinkedList(n0)
 
-	P := NewListNode(6)
-
-	/* 在链表的结点 n0 之后插入结点 P */
-	insertNode(n0, P)
-	fmt.Println("在链表的结点 n0 之后插入结点 P 后，链表结构：")
-	PrintLinkedList(n0)
-
-	/* 删除链表的结点 n0 之后的首个结点 */
+	/* 删除结点 */
 	removeNode(n0)
-	fmt.Println("删除链表的结点 n0 之后的首个结点后，链表结构：")
-	PrintLinkedList(n0)
+	fmt.Println("删除结点后的链表为")
+	pkg.PrintLinkedList(n0)
 
-	/* 访问链表中索引为 index 的结点 */
-	fmt.Println("访问链表中索引为 2 的结点：", access(n0, 2))
+	/* 访问结点 */
+	node := access(n0, 3)
+	fmt.Println("链表中索引 3 处的结点的值 =", node)
 
-	/* 在链表中查找值为 target 的首个结点 */
-	fmt.Println("在链表中查找 5 的首个节点索引值：", findNode(n0, 5))
+	/* 查找结点 */
+	index := findNode(n0, 2)
+	fmt.Println("链表中值为 2 的结点的索引 =", index)
 }

From 4ca09c1015ccd8af6f0592728facaccb3c83b0dc Mon Sep 17 00:00:00 2001
From: GN-Yu <58758623+GN-Yu@users.noreply.github.com>
Date: Thu, 29 Dec 2022 17:50:02 -0500
Subject: [PATCH 037/158] Update merge_sort.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

修改了代码注释使其表述更严谨，如C++中：

for (int k = left; k <= right; k++) {
            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
            if (i > leftEnd)
                nums[k] = tmp[j++];
            // 否则，若“右子数组已全部合并完”或“左子数组元素 <ins> <= </ins> 右子数组元素”，则选取左子数组元素，并且 i++
            else if (j > rightEnd || tmp[i] <= tmp[j])
                nums[k] = tmp[i++];
            // 否则，若<ins>“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”</ins>，则选取右子数组元素，并且 j++
            else
                nums[k] = tmp[j++];
        }
---
 docs/chapter_sorting/merge_sort.md | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/docs/chapter_sorting/merge_sort.md b/docs/chapter_sorting/merge_sort.md
index 9ee984271..48a5046c7 100644
--- a/docs/chapter_sorting/merge_sort.md
+++ b/docs/chapter_sorting/merge_sort.md
@@ -81,10 +81,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++];
         }
@@ -125,10 +125,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++];
         }
@@ -170,11 +170,11 @@ comments: true
             if i > left_end:
                 nums[k] = tmp[j]
                 j += 1
-            # 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+            # 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
             elif j > right_end or tmp[i] <= tmp[j]:
                 nums[k] = tmp[i]
                 i += 1
-            # 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            # 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
             else:
                 nums[k] = tmp[j]
                 j += 1
@@ -218,11 +218,11 @@ comments: true
             if i > left_end {
                 nums[k] = tmp[j]
                 j++
-            // 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
             } else if j > right_end || tmp[i] <= tmp[j] {
                 nums[k] = tmp[i]
                 i++
-            // 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
             } else {
                 nums[k] = tmp[j]
                 j++
@@ -267,10 +267,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++];
             }
@@ -312,10 +312,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++];
             }
@@ -365,10 +365,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++];
         }

From 0dda12e0ab44c0e330f43533e6c13751f2e812b5 Mon Sep 17 00:00:00 2001
From: Listening <120311070@qq.com>
Date: Fri, 30 Dec 2022 09:26:26 +0800
Subject: [PATCH 038/158] add insertion sort content

---
 codes/c/chapter_sorting/insertion_sort.c | 41 ++++++++++++++++++++++++
 docs/chapter_sorting/insertion_sort.md   | 19 ++++++++++-
 2 files changed, 59 insertions(+), 1 deletion(-)
 create mode 100644 codes/c/chapter_sorting/insertion_sort.c

diff --git a/codes/c/chapter_sorting/insertion_sort.c b/codes/c/chapter_sorting/insertion_sort.c
new file mode 100644
index 000000000..ae1f6e7de
--- /dev/null
+++ b/codes/c/chapter_sorting/insertion_sort.c
@@ -0,0 +1,41 @@
+/*
+ * File: insertion_sort.c
+ * Created Time: 2022-12-29
+ * Author: Listening (https://github.com/L-Super)
+ */
+
+#include "../include/include.h"
+
+/* 插入排序 */
+void insertionSort(int nums[], int size)
+{
+    // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+    for (int i = 1; i < size; i++)
+    {
+        int base = nums[i], j = i - 1;
+        // 内循环：将 base 插入到左边的正确位置
+        while (j >= 0 && nums[j] > base)
+        {
+            // 1. 将 nums[j] 向右移动一位
+            nums[j + 1] = nums[j]; 
+            j--;
+        }
+        // 2. 将 base 赋值到正确位置
+        nums[j + 1] = base; 
+    }
+}
+
+/* Driver Code */
+int main()
+{
+    int nums[] = {4, 1, 3, 1, 5, 2};
+    insertionSort(nums, 6);
+    printf("插入排序完成后 nums = \n");
+    for (int i = 0; i < 6; i++)
+    {
+        printf("%d ", nums[i]);
+    }
+    printf("\n");
+
+    return 0;
+}
diff --git a/docs/chapter_sorting/insertion_sort.md b/docs/chapter_sorting/insertion_sort.md
index 1614b5c35..faaf38358 100644
--- a/docs/chapter_sorting/insertion_sort.md
+++ b/docs/chapter_sorting/insertion_sort.md
@@ -135,7 +135,24 @@ comments: true
 === "C"
 
     ```c title="insertion_sort.c"
-
+    /* 插入排序 */
+    void insertionSort(int nums[], int size)
+    {
+        // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+        for (int i = 1; i < size; i++)
+        {
+            int base = nums[i], j = i - 1;
+            // 内循环：将 base 插入到左边的正确位置
+            while (j >= 0 && nums[j] > base)
+            {
+                // 1. 将 nums[j] 向右移动一位
+                nums[j + 1] = nums[j]; 
+                j--;
+            }
+            // 2. 将 base 赋值到正确位置
+            nums[j + 1] = base; 
+        }
+    }
     ```
 
 === "C#"

From d8bf0b02d163bde9b3ae90640a63fd0d66b8a1dd Mon Sep 17 00:00:00 2001
From: moonache <476681765@qq.com>
Date: Fri, 30 Dec 2022 14:28:39 +0800
Subject: [PATCH 039/158] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20C#=20=E5=86=85?=
 =?UTF-8?q?=E7=BD=AE=E7=9A=84=E5=8F=8C=E5=90=91=E9=98=9F=E5=88=97=E7=A4=BA?=
 =?UTF-8?q?=E4=BE=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

RT
---
 docs/chapter_stack_and_queue/deque.md | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/docs/chapter_stack_and_queue/deque.md b/docs/chapter_stack_and_queue/deque.md
index ca55f8223..41d9f4498 100644
--- a/docs/chapter_stack_and_queue/deque.md
+++ b/docs/chapter_stack_and_queue/deque.md
@@ -167,5 +167,28 @@ comments: true
 === "C#"
 
     ```csharp title="deque.cs"
+    /* 初始化双向队列 */
+    /* LinkedList 是 C# 中使用双向链表实现的双向队列 */
+    LinkedList<int> deque = new LinkedList<int>();
 
+    /* 元素入队 */
+    deque.AddLast(2);   // 添加至队尾
+    deque.AddLast(5);
+    deque.AddLast(4);
+    deque.AddFirst(3);  // 添加至队首
+    deque.AddFirst(1);
+
+    /* 访问元素 */
+    int peekFirst = deque.First.Value;  // 队首元素
+    int peekLast = deque.Last.Value;    // 队尾元素
+
+    /* 元素出队 */
+    deque.RemoveFirst();  // 队首元素出队
+    deque.RemoveLast();   // 队尾元素出队
+
+    /* 获取双向队列的长度 */
+    int size = deque.Count;
+
+    /* 判断双向队列是否为空 */
+    bool isEmpty = deque.Count == 0;
     ```

From 0cf37e3f8eaeadb4c9c054828359e582e743d068 Mon Sep 17 00:00:00 2001
From: moonache <476681765@qq.com>
Date: Fri, 30 Dec 2022 14:35:54 +0800
Subject: [PATCH 040/158] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20deque.cs?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

以 C# 内置的双向队列 LinkedList 为基础，编写了 C# 版本的 deque
---
 codes/csharp/chapter_stack_and_queue/deque.cs | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 codes/csharp/chapter_stack_and_queue/deque.cs

diff --git a/codes/csharp/chapter_stack_and_queue/deque.cs b/codes/csharp/chapter_stack_and_queue/deque.cs
new file mode 100644
index 000000000..b1360e283
--- /dev/null
+++ b/codes/csharp/chapter_stack_and_queue/deque.cs
@@ -0,0 +1,48 @@
+/**
+ * File: deque.cs
+ * Created Time: 2022-12-30
+ * Author: moonache (microin1301@outlook.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_stack_and_queue
+{
+    public class deque
+    {
+        [Test]
+        public void Test()
+        {
+            /* 初始化双向队列 */
+            LinkedList<int> deque = new LinkedList<int>();
+
+            /* 元素入队 */
+            deque.AddLast(2);   // 添加至队尾
+            deque.AddLast(5);
+            deque.AddLast(4);
+            deque.AddFirst(3);  // 添加至队首
+            deque.AddFirst(1);
+            Console.WriteLine("双向队列 deque = " + String.Join(",", deque.ToArray()));
+
+            /* 访问元素 */
+            int peekFirst = deque.First.Value;  // 队首元素
+            Console.WriteLine("队首元素 peekFirst = " + peekFirst);
+            int peekLast = deque.Last.Value;    // 队尾元素
+            Console.WriteLine("队尾元素 peekLast = " + peekLast);
+
+            /* 元素出队 */
+            deque.RemoveFirst();  // 队首元素出队
+            Console.WriteLine("队首元素出队后 deque = " + String.Join(",", deque.ToArray()));
+            deque.RemoveLast();   // 队尾元素出队
+            Console.WriteLine("队尾元素出队后 deque = " + String.Join(",", deque.ToArray()));
+
+            /* 获取双向队列的长度 */
+            int size = deque.Count;
+            Console.WriteLine("双向队列长度 size = " + size);
+
+            /* 判断双向队列是否为空 */
+            bool isEmpty = deque.Count == 0;
+            Console.WriteLine("双向队列是否为空 = " + isEmpty);
+        }
+    }
+}

From 2465db1eff7d1f7298cf9ca610d2d8722428407f Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 30 Dec 2022 15:57:15 +0800
Subject: [PATCH 041/158] Update space_complexity.md

Fix the Go code.
---
 docs/chapter_computational_complexity/space_complexity.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/chapter_computational_complexity/space_complexity.md b/docs/chapter_computational_complexity/space_complexity.md
index df5d98f34..e96c97209 100644
--- a/docs/chapter_computational_complexity/space_complexity.md
+++ b/docs/chapter_computational_complexity/space_complexity.md
@@ -219,11 +219,11 @@ comments: true
 
     ```go title=""
     func algorithm(n int) {
-        a := 0                         // O(1)
-        b := make([]int, 10000)        // O(1)
+        a := 0                      // O(1)
+        b := make([]int, 10000)     // O(1)
         var nums []int
         if n > 10 {
-            nums = make([]int, 10000)  // O(n)
+            nums := make([]int, n)  // O(n)
         }
         fmt.Println(a, b, nums)
     }

From c67363a78e84148c1ae44b258d6ae3aa4bc4086a Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 30 Dec 2022 16:10:22 +0800
Subject: [PATCH 042/158] Update deque.cs

---
 codes/csharp/chapter_stack_and_queue/deque.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/codes/csharp/chapter_stack_and_queue/deque.cs b/codes/csharp/chapter_stack_and_queue/deque.cs
index b1360e283..d9f7a5098 100644
--- a/codes/csharp/chapter_stack_and_queue/deque.cs
+++ b/codes/csharp/chapter_stack_and_queue/deque.cs
@@ -14,6 +14,7 @@ namespace hello_algo.chapter_stack_and_queue
         public void Test()
         {
             /* 初始化双向队列 */
+            // 在 C# 中，将链表 LinkedList 看作双向队列来使用
             LinkedList<int> deque = new LinkedList<int>();
 
             /* 元素入队 */

From 56b6bf10f84d420fa70e74d995337ced04295110 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 30 Dec 2022 16:11:47 +0800
Subject: [PATCH 043/158] Update deque.md

---
 docs/chapter_stack_and_queue/deque.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/chapter_stack_and_queue/deque.md b/docs/chapter_stack_and_queue/deque.md
index 41d9f4498..72106360f 100644
--- a/docs/chapter_stack_and_queue/deque.md
+++ b/docs/chapter_stack_and_queue/deque.md
@@ -168,7 +168,7 @@ comments: true
 
     ```csharp title="deque.cs"
     /* 初始化双向队列 */
-    /* LinkedList 是 C# 中使用双向链表实现的双向队列 */
+    // 在 C# 中，将链表 LinkedList 看作双向队列来使用
     LinkedList<int> deque = new LinkedList<int>();
 
     /* 元素入队 */

From ae78126d8055edba6df8899601830b881d00b781 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 30 Dec 2022 16:44:09 +0800
Subject: [PATCH 044/158] Update array.go

---
 codes/go/chapter_array_and_linkedlist/array.go | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/codes/go/chapter_array_and_linkedlist/array.go b/codes/go/chapter_array_and_linkedlist/array.go
index 26c056763..eb21143fe 100644
--- a/codes/go/chapter_array_and_linkedlist/array.go
+++ b/codes/go/chapter_array_and_linkedlist/array.go
@@ -49,11 +49,7 @@ func insert(nums []int, num int, index int) {
 /* 删除索引 index 处元素 */
 func remove(nums []int, index int) {
 	// 把索引 index 之后的所有元素向前移动一位
-	for i := index; i < len(nums); i++ {
-		if i+1 >= len(nums) {
-			nums[len(nums)-1] = 0
-			break
-		}
+	for i := index; i < len(nums) - 1; i++ {
 		nums[i] = nums[i+1]
 	}
 }

From e5497496f9d69ead975cb48078145d7d3c2bc956 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 30 Dec 2022 16:45:40 +0800
Subject: [PATCH 045/158] Update array.md

---
 docs/chapter_array_and_linkedlist/array.md | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 643b16a23..095960563 100644
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -403,11 +403,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     /* 删除索引 index 处元素 */
     func remove(nums []int, index int) {
         // 把索引 index 之后的所有元素向前移动一位
-        for i := index; i < len(nums); i++ {
-            if i+1 >= len(nums) {
-                nums[len(nums)-1] = 0
-                break
-            }
+        for i := index; i < len(nums) - 1; i++ {
             nums[i] = nums[i+1]
         }
     }
@@ -721,4 +717,4 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 **二分查找。** 例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的“翻开中间，排除一半”的方式，来实现一个查电子字典的算法。
 
-**深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
\ No newline at end of file
+**深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。

From 507f07ac4b8dace4219793ad22debb6e079b6384 Mon Sep 17 00:00:00 2001
From: Zhizhen He <hezhizhen.yi@gmail.com>
Date: Fri, 30 Dec 2022 18:37:12 +0800
Subject: [PATCH 046/158] fix typo

---
 .../space_complexity.md                             |   2 +-
 .../time_complexity.md                              |   2 +-
 .../classification_logic_structure.png              | Bin
 .../classification_phisical_structure.png           | Bin
 ...uture.md => classification_of_data_structure.md} |   4 ++--
 mkdocs.yml                                          |   2 +-
 6 files changed, 5 insertions(+), 5 deletions(-)
 rename docs/chapter_data_structure/{classification_of_data_strcuture.assets => classification_of_data_structure.assets}/classification_logic_structure.png (100%)
 rename docs/chapter_data_structure/{classification_of_data_strcuture.assets => classification_of_data_structure.assets}/classification_phisical_structure.png (100%)
 rename docs/chapter_data_structure/{classification_of_data_strcuture.md => classification_of_data_structure.md} (93%)

diff --git a/docs/chapter_computational_complexity/space_complexity.md b/docs/chapter_computational_complexity/space_complexity.md
index e96c97209..4c0d2d1bf 100644
--- a/docs/chapter_computational_complexity/space_complexity.md
+++ b/docs/chapter_computational_complexity/space_complexity.md
@@ -838,7 +838,7 @@ $$
 
     ```
 
-在以下递归函数中，同时存在 $n$ 个未返回的 `algorihtm()` ，并且每个函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $\frac{n}{2}$ ，因此总体使用 $O(n^2)$ 空间。
+在以下递归函数中，同时存在 $n$ 个未返回的 `algorithm()` ，并且每个函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $\frac{n}{2}$ ，因此总体使用 $O(n^2)$ 空间。
 
 === "Java"
 
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index aafb0d893..539c9b5cb 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -1442,7 +1442,7 @@ $$
 
 ### 对数阶 $O(\log n)$
 
-对数阶与指数阶正好相反，后者反映“每轮增加到两倍的情况”，而前者反映“每轮缩减到一半的情况”。对数阶仅次于常数阶，时间增长的很慢，是理想的时间复杂度。
+对数阶与指数阶正好相反，后者反映“每轮增加到两倍的情况”，而前者反映“每轮缩减到一半的情况”。对数阶仅次于常数阶，时间增长得很慢，是理想的时间复杂度。
 
 对数阶常出现于「二分查找」和「分治算法」中，体现“一分为多”、“化繁为简”的算法思想。
 
diff --git a/docs/chapter_data_structure/classification_of_data_strcuture.assets/classification_logic_structure.png b/docs/chapter_data_structure/classification_of_data_structure.assets/classification_logic_structure.png
similarity index 100%
rename from docs/chapter_data_structure/classification_of_data_strcuture.assets/classification_logic_structure.png
rename to docs/chapter_data_structure/classification_of_data_structure.assets/classification_logic_structure.png
diff --git a/docs/chapter_data_structure/classification_of_data_strcuture.assets/classification_phisical_structure.png b/docs/chapter_data_structure/classification_of_data_structure.assets/classification_phisical_structure.png
similarity index 100%
rename from docs/chapter_data_structure/classification_of_data_strcuture.assets/classification_phisical_structure.png
rename to docs/chapter_data_structure/classification_of_data_structure.assets/classification_phisical_structure.png
diff --git a/docs/chapter_data_structure/classification_of_data_strcuture.md b/docs/chapter_data_structure/classification_of_data_structure.md
similarity index 93%
rename from docs/chapter_data_structure/classification_of_data_strcuture.md
rename to docs/chapter_data_structure/classification_of_data_structure.md
index b41266bb8..d4397c5da 100644
--- a/docs/chapter_data_structure/classification_of_data_strcuture.md
+++ b/docs/chapter_data_structure/classification_of_data_structure.md
@@ -15,7 +15,7 @@ comments: true
 - **线性数据结构：** 数组、链表、栈、队列、哈希表；
 - **非线性数据结构：** 树、图、堆、哈希表；
 
-![classification_logic_structure](classification_of_data_strcuture.assets/classification_logic_structure.png)
+![classification_logic_structure](classification_of_data_structure.assets/classification_logic_structure.png)
 
 <p align="center"> Fig. 线性与非线性数据结构 </p>
 
@@ -27,7 +27,7 @@ comments: true
 
 **「物理结构」反映了数据在计算机内存中的存储方式。** 从本质上看，分别是 **数组的连续空间存储** 和 **链表的离散空间存储** 。物理结构从底层上决定了数据的访问、更新、增删等操作方法，在时间效率和空间效率方面呈现出此消彼长的特性。
 
-![classification_phisical_structure](classification_of_data_strcuture.assets/classification_phisical_structure.png)
+![classification_phisical_structure](classification_of_data_structure.assets/classification_phisical_structure.png)
 
 <p align="center"> Fig. 连续空间存储与离散空间存储 </p>
 
diff --git a/mkdocs.yml b/mkdocs.yml
index 4334382f4..4aca74c24 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -139,7 +139,7 @@ nav:
     - 小结: chapter_computational_complexity/summary.md
   - 数据结构简介: 
     - 数据与内存: chapter_data_structure/data_and_memory.md
-    - 数据结构分类: chapter_data_structure/classification_of_data_strcuture.md
+    - 数据结构分类: chapter_data_structure/classification_of_data_structure.md
     - 小结: chapter_data_structure/summary.md
   - 数组与链表: 
     - 数组（Array）: chapter_array_and_linkedlist/array.md

From a03353f8e2bbde2583bbfe65f8e0f9c1c04ec4ee Mon Sep 17 00:00:00 2001
From: GN-Yu <58758623+GN-Yu@users.noreply.github.com>
Date: Fri, 30 Dec 2022 13:20:25 -0500
Subject: [PATCH 047/158] Update merge_sort.cpp

---
 codes/cpp/chapter_sorting/merge_sort.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/codes/cpp/chapter_sorting/merge_sort.cpp b/codes/cpp/chapter_sorting/merge_sort.cpp
index 7c9a41c8e..b406529a3 100644
--- a/codes/cpp/chapter_sorting/merge_sort.cpp
+++ b/codes/cpp/chapter_sorting/merge_sort.cpp
@@ -25,10 +25,10 @@ void merge(vector<int>& nums, int left, int mid, int right) {
         // 若“左子数组已全部合并完”，则选取右子数组元素，并且 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++];
     }

From 1b71e74baac5f79073a7179d509b78a42962a59a Mon Sep 17 00:00:00 2001
From: GN-Yu <58758623+GN-Yu@users.noreply.github.com>
Date: Fri, 30 Dec 2022 13:21:03 -0500
Subject: [PATCH 048/158] Update merge_sort.cs

---
 codes/csharp/chapter_sorting/merge_sort.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/codes/csharp/chapter_sorting/merge_sort.cs b/codes/csharp/chapter_sorting/merge_sort.cs
index 04ac8acdd..e66ae5e23 100644
--- a/codes/csharp/chapter_sorting/merge_sort.cs
+++ b/codes/csharp/chapter_sorting/merge_sort.cs
@@ -31,10 +31,10 @@ namespace hello_algo.chapter_sorting
                 // 若“左子数组已全部合并完”，则选取右子数组元素，并且 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++];
             }

From 5d45f7116716be00be72ae3a611b1a0597319254 Mon Sep 17 00:00:00 2001
From: GN-Yu <58758623+GN-Yu@users.noreply.github.com>
Date: Fri, 30 Dec 2022 13:21:40 -0500
Subject: [PATCH 049/158] Update merge_sort.go

---
 codes/go/chapter_sorting/merge_sort/merge_sort.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/codes/go/chapter_sorting/merge_sort/merge_sort.go b/codes/go/chapter_sorting/merge_sort/merge_sort.go
index 830e2dfa4..f2910600a 100644
--- a/codes/go/chapter_sorting/merge_sort/merge_sort.go
+++ b/codes/go/chapter_sorting/merge_sort/merge_sort.go
@@ -25,11 +25,11 @@ func merge(nums []int, left, mid, right int) {
 		if i > left_end {
 			nums[k] = tmp[j]
 			j++
-			// 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+			// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
 		} else if j > right_end || tmp[i] <= tmp[j] {
 			nums[k] = tmp[i]
 			i++
-			// 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+			// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
 		} else {
 			nums[k] = tmp[j]
 			j++

From 6ba808ed3631c01e320ebe24e4fbe78c43f58eaf Mon Sep 17 00:00:00 2001
From: GN-Yu <58758623+GN-Yu@users.noreply.github.com>
Date: Fri, 30 Dec 2022 13:22:07 -0500
Subject: [PATCH 050/158] Update merge_sort.java

---
 codes/java/chapter_sorting/merge_sort.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/codes/java/chapter_sorting/merge_sort.java b/codes/java/chapter_sorting/merge_sort.java
index 498a6fd81..fe9f183a5 100644
--- a/codes/java/chapter_sorting/merge_sort.java
+++ b/codes/java/chapter_sorting/merge_sort.java
@@ -28,10 +28,10 @@ public class merge_sort {
             // 若“左子数组已全部合并完”，则选取右子数组元素，并且 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++];
         }

From 96355afb1ce236fb19dfda07a96ebe865a766734 Mon Sep 17 00:00:00 2001
From: GN-Yu <58758623+GN-Yu@users.noreply.github.com>
Date: Fri, 30 Dec 2022 13:22:31 -0500
Subject: [PATCH 051/158] Update merge_sort.js

---
 codes/javascript/chapter_sorting/merge_sort.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/codes/javascript/chapter_sorting/merge_sort.js b/codes/javascript/chapter_sorting/merge_sort.js
index 31860ce1d..b00c17bcd 100644
--- a/codes/javascript/chapter_sorting/merge_sort.js
+++ b/codes/javascript/chapter_sorting/merge_sort.js
@@ -23,10 +23,10 @@ function merge(nums, left, mid, right) {
         // 若“左子数组已全部合并完”，则选取右子数组元素，并且 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++];
         }

From 506bc009c7c9d51f97fbfb617aa8d303093f2d08 Mon Sep 17 00:00:00 2001
From: GN-Yu <58758623+GN-Yu@users.noreply.github.com>
Date: Fri, 30 Dec 2022 13:22:59 -0500
Subject: [PATCH 052/158] Update merge_sort.py

---
 codes/python/chapter_sorting/merge_sort.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/codes/python/chapter_sorting/merge_sort.py b/codes/python/chapter_sorting/merge_sort.py
index f3fb538ae..5fa7d83a9 100644
--- a/codes/python/chapter_sorting/merge_sort.py
+++ b/codes/python/chapter_sorting/merge_sort.py
@@ -28,11 +28,11 @@ def merge(nums, left, mid, right):
         if i > left_end:
             nums[k] = tmp[j]
             j += 1
-        # 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+        # 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
         elif j > right_end or tmp[i] <= tmp[j]:
             nums[k] = tmp[i]
             i += 1
-        # 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+        # 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
         else:
             nums[k] = tmp[j]
             j += 1

From 327b566ff936db1114be40a928cc1e6b11632c05 Mon Sep 17 00:00:00 2001
From: GN-Yu <58758623+GN-Yu@users.noreply.github.com>
Date: Fri, 30 Dec 2022 13:23:26 -0500
Subject: [PATCH 053/158] Update merge_sort.ts

---
 codes/typescript/chapter_sorting/merge_sort.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/codes/typescript/chapter_sorting/merge_sort.ts b/codes/typescript/chapter_sorting/merge_sort.ts
index 44fb4b8d0..a4cb5e1cb 100644
--- a/codes/typescript/chapter_sorting/merge_sort.ts
+++ b/codes/typescript/chapter_sorting/merge_sort.ts
@@ -23,10 +23,10 @@ function merge(nums: number[], left: number, mid: number, right: number): void {
         // 若“左子数组已全部合并完”，则选取右子数组元素，并且 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++];
         }

From c94101a365a7b22f9457c9d18dccd29290adbc1e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ren=C3=A9=20Wang?=
 <52880665+RiverTwilight@users.noreply.github.com>
Date: Sun, 1 Jan 2023 19:29:45 +0800
Subject: [PATCH 054/158] docs: added Typescript and Javascript examples

Not sure whether these formats meet the requirement. If everything is okay I will continue to transcribe more:-)
---
 .../time_complexity.md                        | 51 +++++++++++++++++--
 1 file changed, 48 insertions(+), 3 deletions(-)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 539c9b5cb..75f2dd31e 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -79,13 +79,27 @@ $$
 === "JavaScript"
 
     ```js title=""
-
+    function algorithm(n) {
+        var a = 2; // 1 ns
+        a = a + 1; // 1 ns
+        a = a * 2; // 10 ns
+        for(var i = 0; i < n; i++) { // 1 ns ，每轮都要执行 i++
+            console.log(0); // 5 ns
+        }
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title=""
-
+    function algorithm(n: number): void {
+        var a: number = 2; // 1 ns
+        a = a + 1; // 1 ns
+        a = a * 2; // 10 ns
+        for(var i = 0; i < n; i++) { // 1 ns ，每轮都要执行 i++
+            console.log(0); // 5 ns
+        }
+    }
     ```
 
 === "C"
@@ -220,13 +234,44 @@ $$
 === "JavaScript"
 
     ```js title=""
+    // 算法 A 时间复杂度：常数阶
+    function algorithm_A(n) {
+        console.log(0);
+    }
+    // 算法 B 时间复杂度：线性阶
+    function algorithm_B(n) {
+        for (var i = 0; i < n; i++) {
+            console.log(0);
+        }
+    }
+    // 算法 C 时间复杂度：常数阶
+    function algorithm_C(n) {
+        for (var i = 0; i < 1000000; i++) {
+            console.log(0);
+        }
+    }
 
     ```
 
 === "TypeScript"
 
     ```typescript title=""
-
+    // 算法 A 时间复杂度：常数阶
+    function algorithm_A(n: number): void {
+        console.log(0);
+    }
+    // 算法 B 时间复杂度：线性阶
+    function algorithm_B(n: number): void {
+        for (var i = 0; i < n; i++) {
+            console.log(0);
+        }
+    }
+    // 算法 C 时间复杂度：常数阶
+    function algorithm_C(n: number): void {
+        for (var i = 0; i < 1000000; i++) {
+            console.log(0);
+        }
+    }
     ```
 
 === "C"

From 57bd711779ab91eda6705180b15a12ce634cc90f Mon Sep 17 00:00:00 2001
From: nuomi1 <nuomi1@qq.com>
Date: Sun, 1 Jan 2023 21:29:45 +0800
Subject: [PATCH 055/158] feat: add Swift codes for space complexity article

---
 .../space_complexity.swift                    | 172 ++++++++++++++++++
 .../space_complexity.md                       | 152 ++++++++++++++++
 2 files changed, 324 insertions(+)
 create mode 100644 codes/swift/chapter_computational_complexity/space_complexity.swift

diff --git a/codes/swift/chapter_computational_complexity/space_complexity.swift b/codes/swift/chapter_computational_complexity/space_complexity.swift
new file mode 100644
index 000000000..7326c82b4
--- /dev/null
+++ b/codes/swift/chapter_computational_complexity/space_complexity.swift
@@ -0,0 +1,172 @@
+/*
+ * File: space_complexity.swift
+ * Created Time: 2023-01-01
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+class ListNode {
+    var val: Int
+    var next: ListNode?
+
+    init(x: Int) {
+        val = x
+    }
+}
+
+class TreeNode {
+    var val: Int // 结点值
+    var height: Int // 结点高度
+    var left: TreeNode? // 左子结点引用
+    var right: TreeNode? // 右子结点引用
+
+    init(x: Int) {
+        val = x
+        height = 0
+    }
+}
+
+enum PrintUtil {
+    private class Trunk {
+        var prev: Trunk?
+        var str: String
+
+        init(prev: Trunk?, str: String) {
+            self.prev = prev
+            self.str = str
+        }
+    }
+
+    static func printTree(root: TreeNode?) {
+        printTree(root: root, prev: nil, isLeft: false)
+    }
+
+    private static func printTree(root: TreeNode?, prev: Trunk?, isLeft: Bool) {
+        if root == nil {
+            return
+        }
+
+        var prevStr = "    "
+        let trunk = Trunk(prev: prev, str: prevStr)
+
+        printTree(root: root?.right, prev: trunk, isLeft: true)
+
+        if prev == nil {
+            trunk.str = "———"
+        } else if isLeft {
+            trunk.str = "/———"
+            prevStr = "   |"
+        } else {
+            trunk.str = "\\———"
+            prev?.str = prevStr
+        }
+
+        showTrunks(p: trunk)
+        print(" \(root!.val)")
+
+        if prev != nil {
+            prev?.str = prevStr
+        }
+        trunk.str = "   |"
+
+        printTree(root: root?.left, prev: trunk, isLeft: false)
+    }
+
+    private static func showTrunks(p: Trunk?) {
+        if p == nil {
+            return
+        }
+
+        showTrunks(p: p?.prev)
+        print(p!.str, terminator: "")
+    }
+}
+
+// 函数
+@discardableResult
+func function() -> Int {
+    // do something
+    return 0
+}
+
+// 常数阶
+func constant(n: Int) {
+    // 常量、变量、对象占用 O(1) 空间
+    let a = 0
+    var b = 0
+    let nums = Array(repeating: 0, count: 10000)
+    let node = ListNode(x: 0)
+    // 循环中的变量占用 O(1) 空间
+    for _ in 0 ..< n {
+        let c = 0
+    }
+    // 循环中的函数占用 O(1) 空间
+    for _ in 0 ..< n {
+        function()
+    }
+}
+
+// 线性阶
+func linear(n: Int) {
+    // 长度为 n 的数组占用 O(n) 空间
+    let nums = Array(repeating: 0, count: n)
+    // 长度为 n 的列表占用 O(n) 空间
+    let nodes = (0 ..< n).map { ListNode(x: $0) }
+    // 长度为 n 的哈希表占用 O(n) 空间
+    let map = Dictionary(uniqueKeysWithValues: (0 ..< n).map { ($0, "\($0)") })
+}
+
+// 线性阶（递归实现）
+func linearRecur(n: Int) {
+    print("递归 n = \(n)")
+    if n == 1 {
+        return
+    }
+    linearRecur(n: n - 1)
+}
+
+// 平方阶
+func quadratic(n: Int) {
+    // 二维列表占用 O(n^2) 空间
+    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)
+}
+
+// 平方阶（递归实现）
+@discardableResult
+func quadraticRecur(n: Int) -> Int {
+    if n <= 0 {
+        return 0
+    }
+    // 数组 nums 长度为 n, n-1, ..., 2, 1
+    let nums = Array(repeating: 0, count: n)
+    print("递归 n = \(n) 中的 nums 长度 = \(nums.count)")
+    return quadraticRecur(n: n - 1)
+}
+
+// 指数阶（建立满二叉树）
+func buildTree(n: Int) -> TreeNode? {
+    if n == 0 {
+        return nil
+    }
+    let root = TreeNode(x: 0)
+    root.left = buildTree(n: n - 1)
+    root.right = buildTree(n: n - 1)
+    return root
+}
+
+// Driver Code
+func main() {
+    let n = 5
+    // 常数阶
+    constant(n: n)
+    // 线性阶
+    linear(n: n)
+    linearRecur(n: n)
+    // 平方阶
+    quadratic(n: n)
+    quadraticRecur(n: n)
+    // 指数阶
+    let root = buildTree(n: n)
+    PrintUtil.printTree(root: root)
+}
+
+main()
diff --git a/docs/chapter_computational_complexity/space_complexity.md b/docs/chapter_computational_complexity/space_complexity.md
index 4c0d2d1bf..1d561792b 100644
--- a/docs/chapter_computational_complexity/space_complexity.md
+++ b/docs/chapter_computational_complexity/space_complexity.md
@@ -174,6 +174,34 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    // 类
+    class Node {
+        var val: Int
+        var next: Node?
+
+        init(x: Int) {
+            val = x
+        }
+    }
+
+    // 函数
+    func function() -> Int {
+        // do something...
+        return 0
+    }
+
+    func algorithm(n: Int) -> Int { // 输入数据
+        let a = 0 // 暂存数据（常量）
+        var b = 0 // 暂存数据（变量）
+        let node = Node(x: 0) // 暂存数据（对象）
+        let c = function() // 栈帧空间（调用函数）
+        return a + b + c // 输出数据
+    }
+    ```
+
 ## 推算方法
 
 空间复杂度的推算方法和时间复杂度总体类似，只是从统计“计算操作数量”变为统计“使用空间大小”。与时间复杂度不同的是，**我们一般只关注「最差空间复杂度」**。这是因为内存空间是一个硬性要求，我们必须保证在所有输入数据下都有足够的内存空间预留。
@@ -261,6 +289,18 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    func algorithm(n: Int) {
+        let a = 0 // O(1)
+        let b = Array(repeating: 0, count: 10000) // O(1)
+        if n > 10 {
+            let nums = Array(repeating: 0, count: n) // O(n)
+        }
+    }
+    ```
+
 **在递归函数中，需要注意统计栈帧空间。** 例如函数 `loop()`，在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行中会同时存在 $n$ 个未返回的 `recur()` ，从而使用 $O(n)$ 的栈帧空间。
 
 === "Java"
@@ -387,6 +427,31 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    @discardableResult
+    func function() -> Int {
+        // do something
+        return 0
+    }
+
+    // 循环 O(1)
+    func loop(n: Int) {
+        for _ in 0 ..< n {
+            function()
+        }
+    }
+
+    // 递归 O(n)
+    func recur(n: Int) {
+        if n == 1 {
+            return
+        }
+        recur(n: n - 1)
+    }
+    ```
+
 ## 常见类型
 
 设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）
@@ -536,6 +601,27 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="space_complexity.swift"
+    // 常数阶
+    func constant(n: Int) {
+        // 常量、变量、对象占用 O(1) 空间
+        let a = 0
+        var b = 0
+        let nums = Array(repeating: 0, count: 10000)
+        let node = ListNode(x: 0)
+        // 循环中的变量占用 O(1) 空间
+        for _ in 0 ..< n {
+            let c = 0
+        }
+        // 循环中的函数占用 O(1) 空间
+        for _ in 0 ..< n {
+            function()
+        }
+    }
+    ```
+
 ### 线性阶 $O(n)$
 
 线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等。
@@ -654,6 +740,20 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="space_complexity.swift"
+    // 线性阶
+    func linear(n: Int) {
+        // 长度为 n 的数组占用 O(n) 空间
+        let nums = Array(repeating: 0, count: n)
+        // 长度为 n 的列表占用 O(n) 空间
+        let nodes = (0 ..< n).map { ListNode(x: $0) }
+        // 长度为 n 的哈希表占用 O(n) 空间
+        let map = Dictionary(uniqueKeysWithValues: (0 ..< n).map { ($0, "\($0)") })
+    }
+    ```
+
 以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间。
 
 === "Java"
@@ -731,6 +831,19 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="space_complexity.swift"
+    // 线性阶（递归实现）
+    func linearRecur(n: Int) {
+        print("递归 n = \(n)")
+        if n == 1 {
+            return
+        }
+        linearRecur(n: n - 1)
+    }
+    ```
+
 ![space_complexity_recursive_linear](space_complexity.assets/space_complexity_recursive_linear.png)
 
 <p align="center"> Fig. 递归函数产生的线性阶空间复杂度 </p>
@@ -838,6 +951,16 @@ $$
 
     ```
 
+=== "Swift"
+
+    ```swift title="space_complexity.swift"
+    // 平方阶
+    func quadratic(n: Int) {
+        // 二维列表占用 O(n^2) 空间
+        let numList = Array(repeating: Array(repeating: 0, count: n), count: n)
+    }
+    ```
+
 在以下递归函数中，同时存在 $n$ 个未返回的 `algorithm()` ，并且每个函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $\frac{n}{2}$ ，因此总体使用 $O(n^2)$ 空间。
 
 === "Java"
@@ -921,6 +1044,20 @@ $$
 
     ```
 
+=== "Swift"
+
+    ```swift title="space_complexity.swift"
+    // 平方阶（递归实现）
+    func quadraticRecur(n: Int) -> Int {
+        if n <= 0 {
+            return 0
+        }
+        // 数组 nums 长度为 n, n-1, ..., 2, 1
+        let nums = Array(repeating: 0, count: n)
+        return quadraticRecur(n: n - 1)
+    }
+    ```
+
 ![space_complexity_recursive_quadratic](space_complexity.assets/space_complexity_recursive_quadratic.png)
 
 <p align="center"> Fig. 递归函数产生的平方阶空间复杂度 </p>
@@ -1014,6 +1151,21 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="space_complexity.swift"
+    // 指数阶（建立满二叉树）
+    func buildTree(n: Int) -> TreeNode? {
+        if n == 0 {
+            return nil
+        }
+        let root = TreeNode(x: 0)
+        root.left = buildTree(n: n - 1)
+        root.right = buildTree(n: n - 1)
+        return root
+    }
+    ```
+
 ![space_complexity_exponential](space_complexity.assets/space_complexity_exponential.png)
 
 <p align="center"> Fig. 满二叉树下的指数阶空间复杂度 </p>

From 679d5314d9df578d0555fba67b28bb3983f3c999 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Mon, 2 Jan 2023 18:41:21 +0800
Subject: [PATCH 056/158] Update linked_list.md

---
 .../linked_list.md                            | 26 +++++++++----------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/docs/chapter_array_and_linkedlist/linked_list.md b/docs/chapter_array_and_linkedlist/linked_list.md
index 6627fb930..a55d68028 100644
--- a/docs/chapter_array_and_linkedlist/linked_list.md
+++ b/docs/chapter_array_and_linkedlist/linked_list.md
@@ -174,19 +174,19 @@ comments: true
 === "Go"
 
     ```go title=""
-	/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
-	// 初始化各个结点
-	n0 := NewListNode(1)
-	n1 := NewListNode(3)
-	n2 := NewListNode(2)
-	n3 := NewListNode(5)
-	n4 := NewListNode(4)
-
-	// 构建引用指向
-	n0.Next = n1
-	n1.Next = n2
-	n2.Next = n3
-	n3.Next = n4
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各个结点
+    n0 := NewListNode(1)
+    n1 := NewListNode(3)
+    n2 := NewListNode(2)
+    n3 := NewListNode(5)
+    n4 := NewListNode(4)
+    
+    // 构建引用指向
+    n0.Next = n1
+    n1.Next = n2
+    n2.Next = n3
+    n3.Next = n4
     ```
 
 === "JavaScript"

From bacf8553c5527d9f14c4093aa789c8f6c900ebdc Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Mon, 2 Jan 2023 18:42:58 +0800
Subject: [PATCH 057/158] Update linked_list.go

---
 codes/go/chapter_array_and_linkedlist/linked_list.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/codes/go/chapter_array_and_linkedlist/linked_list.go b/codes/go/chapter_array_and_linkedlist/linked_list.go
index e7fdb35ca..106e49f4c 100644
--- a/codes/go/chapter_array_and_linkedlist/linked_list.go
+++ b/codes/go/chapter_array_and_linkedlist/linked_list.go
@@ -5,7 +5,7 @@
 package chapter_array_and_linkedlist
 
 import (
-	"github.com/krahets/hello-algo/pkg"
+	. "github.com/krahets/hello-algo/pkg"
 )
 
 /* 在链表的结点 n0 之后插入结点 P */

From 3f00aa39fb69198901728cceec66fcfe69e57850 Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Mon, 2 Jan 2023 18:47:36 +0800
Subject: [PATCH 058/158] code: added code for time complexity chapter

---
 .../time_complexity.js                        | 21 +++++++++++++
 .../time_complexity.ts                        | 22 ++++++++++++++
 .../time_complexity.md                        | 30 +++++++++----------
 3 files changed, 58 insertions(+), 15 deletions(-)
 create mode 100644 codes/javascript/chapter_computational_complexity/time_complexity.js
 create mode 100644 codes/typescript/chapter_computational_complexity/time_complexity.ts

diff --git a/codes/javascript/chapter_computational_complexity/time_complexity.js b/codes/javascript/chapter_computational_complexity/time_complexity.js
new file mode 100644
index 000000000..1ce3ffbf0
--- /dev/null
+++ b/codes/javascript/chapter_computational_complexity/time_complexity.js
@@ -0,0 +1,21 @@
+/**
+ * File: time_complexity.js
+ * Created Time: 2023-01-02
+ * Author: RiverTwilight (contact@rene.wang)
+ */
+
+function algorithm_A(n) {
+	console.log(0);
+}
+// 算法 B 时间复杂度：线性阶
+function algorithm_B(n) {
+	for (var i = 0; i < n; i++) {
+		console.log(0);
+	}
+}
+// 算法 C 时间复杂度：常数阶
+function algorithm_C(n) {
+	for (var i = 0; i < 1000000; i++) {
+		console.log(0);
+	}
+}
diff --git a/codes/typescript/chapter_computational_complexity/time_complexity.ts b/codes/typescript/chapter_computational_complexity/time_complexity.ts
new file mode 100644
index 000000000..cc183265b
--- /dev/null
+++ b/codes/typescript/chapter_computational_complexity/time_complexity.ts
@@ -0,0 +1,22 @@
+/**
+ * File: time_complexity.ts
+ * Created Time: 2023-01-02
+ * Author: RiverTwilight (contact@rene.wang)
+ */
+
+// 算法 A 时间复杂度：常数阶
+function algorithm_A(n: number): void {
+	console.log(0);
+}
+// 算法 B 时间复杂度：线性阶
+function algorithm_B(n: number): void {
+	for (var i = 0; i < n; i++) {
+		console.log(0);
+	}
+}
+// 算法 C 时间复杂度：常数阶
+function algorithm_C(n: number): void {
+	for (var i = 0; i < 1000000; i++) {
+		console.log(0);
+	}
+}
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 75f2dd31e..dd82b6a2a 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -148,9 +148,9 @@ $$
 
 “时间增长趋势”这个概念比较抽象，我们借助一个例子来理解。设输入数据大小为 $n$ ，给定三个算法 `A` , `B` , `C` 。
 
-- 算法 `A` 只有 $1$ 个打印操作，算法运行时间不随着 $n$ 增大而增长。我们称此算法的时间复杂度为「常数阶」。
-- 算法 `B` 中的打印操作需要循环 $n$ 次，算法运行时间随着 $n$ 增大成线性增长。此算法的时间复杂度被称为「线性阶」。
-- 算法 `C` 中的打印操作需要循环 $1000000$ 次，但运行时间仍与输入数据大小 $n$ 无关。因此 `C` 的时间复杂度和 `A` 相同，仍为「常数阶」。
+-   算法 `A` 只有 $1$ 个打印操作，算法运行时间不随着 $n$ 增大而增长。我们称此算法的时间复杂度为「常数阶」。
+-   算法 `B` 中的打印操作需要循环 $n$ 次，算法运行时间随着 $n$ 增大成线性增长。此算法的时间复杂度被称为「线性阶」。
+-   算法 `C` 中的打印操作需要循环 $1000000$ 次，但运行时间仍与输入数据大小 $n$ 无关。因此 `C` 的时间复杂度和 `A` 相同，仍为「常数阶」。
 
 === "Java"
 
@@ -233,7 +233,7 @@ $$
 
 === "JavaScript"
 
-    ```js title=""
+    ```js title="time_complexity.js"
     // 算法 A 时间复杂度：常数阶
     function algorithm_A(n) {
         console.log(0);
@@ -255,7 +255,7 @@ $$
 
 === "TypeScript"
 
-    ```typescript title=""
+    ```typescript title="time_complexity.ts"
     // 算法 A 时间复杂度：常数阶
     function algorithm_A(n: number): void {
         console.log(0);
@@ -343,7 +343,7 @@ $$
 
 ## 函数渐近上界
 
-设算法「计算操作数量」为 $T(n)$  ，其是一个关于输入数据大小 $n$ 的函数。例如，以下算法的操作数量为
+设算法「计算操作数量」为 $T(n)$ ，其是一个关于输入数据大小 $n$ 的函数。例如，以下算法的操作数量为
 
 $$
 T(n) = 3 + 2n
@@ -399,7 +399,7 @@ $$
         // 循环 n 次
         for i := 0; i < n; i++ {	// +1
             fmt.Println(a)	        // +1
-        }	
+        }
     }
     ```
 
@@ -640,7 +640,7 @@ $$
 
 <div class="center-table" markdown>
 
-| 操作数量 $T(n)$         | 时间复杂度 $O(f(n))$   |
+| 操作数量 $T(n)$        | 时间复杂度 $O(f(n))$ |
 | ---------------------- | -------------------- |
 | $100000$               | $O(1)$               |
 | $3n + 2$               | $O(n)$               |
@@ -1696,7 +1696,7 @@ $$
     /* 线性对数阶 */
     int linearLogRecur(float n) {
         if (n <= 1) return 1;
-        int count = linearLogRecur(n / 2) + 
+        int count = linearLogRecur(n / 2) +
                     linearLogRecur(n / 2);
         for (int i = 0; i < n; i++) {
             count++;
@@ -1711,7 +1711,7 @@ $$
     /* 线性对数阶 */
     int linearLogRecur(float n) {
         if (n <= 1) return 1;
-        int count = linearLogRecur(n / 2) + 
+        int count = linearLogRecur(n / 2) +
                     linearLogRecur(n / 2);
         for (int i = 0; i < n; i++) {
             count++;
@@ -1935,8 +1935,8 @@ $$
 
 **某些算法的时间复杂度不是恒定的，而是与输入数据的分布有关。** 举一个例子，输入一个长度为 $n$ 数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的；算法的任务是返回元素 $1$ 的索引。我们可以得出以下结论：
 
-- 当 `nums = [?, ?, ..., 1]`，即当末尾元素是 $1$ 时，则需完整遍历数组，此时达到 **最差时间复杂度 $O(n)$** ；
-- 当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，此时达到 **最佳时间复杂度 $\Omega(1)$** ；
+-   当 `nums = [?, ?, ..., 1]`，即当末尾元素是 $1$ 时，则需完整遍历数组，此时达到 **最差时间复杂度 $O(n)$** ；
+-   当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，此时达到 **最佳时间复杂度 $\Omega(1)$** ；
 
 「函数渐近上界」使用大 $O$ 记号表示，代表「最差时间复杂度」。与之对应，「函数渐近下界」用 $\Omega$ 记号（Omega Notation）来表示，代表「最佳时间复杂度」。
 
@@ -1960,7 +1960,7 @@ $$
             }
             return res;
         }
-    
+
         /* 查找数组 nums 中数字 1 所在索引 */
         int findOne(int[] nums) {
             for (int i = 0; i < nums.length; i++) {
@@ -1969,7 +1969,7 @@ $$
             }
             return -1;
         }
-        
+
         /* Driver Code */
         public void main(String[] args) {
             for (int i = 0; i < 10; i++) {
@@ -2029,7 +2029,7 @@ $$
     ```python title="worst_best_time_complexity.py"
     """ 生成一个数组，元素为: 1, 2, ..., n ，顺序被打乱 """
     def random_numbers(n):
-        # 生成数组 nums =: 1, 2, 3, ..., n 
+        # 生成数组 nums =: 1, 2, 3, ..., n
         nums = [i for i in range(1, n + 1)]
         # 随机打乱数组元素
         random.shuffle(nums)

From 2bd24e61a8ddb17da40b46341b3aa2ae2b52f799 Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Mon, 2 Jan 2023 18:57:26 +0800
Subject: [PATCH 059/158] code: added doc code

---
 .../time_complexity.js                        | 16 ------
 .../time_complexity.ts                        | 17 ------
 .../time_complexity.md                        | 52 ++++++++++++++++++-
 3 files changed, 50 insertions(+), 35 deletions(-)

diff --git a/codes/javascript/chapter_computational_complexity/time_complexity.js b/codes/javascript/chapter_computational_complexity/time_complexity.js
index 1ce3ffbf0..9c877602f 100644
--- a/codes/javascript/chapter_computational_complexity/time_complexity.js
+++ b/codes/javascript/chapter_computational_complexity/time_complexity.js
@@ -3,19 +3,3 @@
  * Created Time: 2023-01-02
  * Author: RiverTwilight (contact@rene.wang)
  */
-
-function algorithm_A(n) {
-	console.log(0);
-}
-// 算法 B 时间复杂度：线性阶
-function algorithm_B(n) {
-	for (var i = 0; i < n; i++) {
-		console.log(0);
-	}
-}
-// 算法 C 时间复杂度：常数阶
-function algorithm_C(n) {
-	for (var i = 0; i < 1000000; i++) {
-		console.log(0);
-	}
-}
diff --git a/codes/typescript/chapter_computational_complexity/time_complexity.ts b/codes/typescript/chapter_computational_complexity/time_complexity.ts
index cc183265b..6f0c9737c 100644
--- a/codes/typescript/chapter_computational_complexity/time_complexity.ts
+++ b/codes/typescript/chapter_computational_complexity/time_complexity.ts
@@ -3,20 +3,3 @@
  * Created Time: 2023-01-02
  * Author: RiverTwilight (contact@rene.wang)
  */
-
-// 算法 A 时间复杂度：常数阶
-function algorithm_A(n: number): void {
-	console.log(0);
-}
-// 算法 B 时间复杂度：线性阶
-function algorithm_B(n: number): void {
-	for (var i = 0; i < n; i++) {
-		console.log(0);
-	}
-}
-// 算法 C 时间复杂度：常数阶
-function algorithm_C(n: number): void {
-	for (var i = 0; i < 1000000; i++) {
-		console.log(0);
-	}
-}
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index dd82b6a2a..8c2edb08a 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -233,7 +233,7 @@ $$
 
 === "JavaScript"
 
-    ```js title="time_complexity.js"
+    ```js title=""
     // 算法 A 时间复杂度：常数阶
     function algorithm_A(n) {
         console.log(0);
@@ -255,7 +255,7 @@ $$
 
 === "TypeScript"
 
-    ```typescript title="time_complexity.ts"
+    ```typescript title=""
     // 算法 A 时间复杂度：常数阶
     function algorithm_A(n: number): void {
         console.log(0);
@@ -406,12 +406,32 @@ $$
 === "JavaScript"
 
     ```js title=""
+    function algorithm(n){
+        var a = 1; // +1
+        a += 1; // +1
+        a *= 2; // +1
+        // 循环 n 次
+        for(var i = 0; i < n; i++){ // +1
+            console.log(0) // +1
+        }
+
+    }
 
     ```
 
 === "TypeScript"
 
     ```typescript title=""
+    function algorithm(n: number): void{
+        var a: number = 1; // +1
+        a += 1; // +1
+        a *= 2; // +1
+        // 循环 n 次
+        for(var i = 0; i < n; i++){ // +1
+            console.log(0) // +1
+        }
+
+    }
 
     ```
 
@@ -575,12 +595,40 @@ $$
 === "JavaScript"
 
     ```js title=""
+    function algorithm(n) {
+        var a = 1;  // +0（技巧 1）
+        a = a + n;  // +0（技巧 1）
+        // +n（技巧 2）
+        for (var i = 0; i < 5 * n + 1; i++) {
+            console.log(0);
+        }
+        // +n*n（技巧 3）
+        for (var i = 0; i < 2 * n; i++) {
+            for (var j = 0; j < n + 1; j++) {
+                console.log(0);
+            }
+        }
+    }
 
     ```
 
 === "TypeScript"
 
     ```typescript title=""
+    function algorithm(n: number): void {
+        var a: number = 1;  // +0（技巧 1）
+        a = a + n;  // +0（技巧 1）
+        // +n（技巧 2）
+        for (var i = 0; i < 5 * n + 1; i++) {
+            console.log(0);
+        }
+        // +n*n（技巧 3）
+        for (var i = 0; i < 2 * n; i++) {
+            for (var j = 0; j < n + 1; j++) {
+                console.log(0);
+            }
+        }
+    }
 
     ```
 

From 1f1c58519deb942c51ff53e086344060c8783380 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Mon, 2 Jan 2023 18:59:35 +0800
Subject: [PATCH 060/158] Update the array and linked list (Go code).

---
 .../go/chapter_array_and_linkedlist/array.go  |  6 +++---
 .../linked_list.go                            |  8 +++----
 .../linked_list_test.go                       | 21 ++++++++++---------
 3 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/codes/go/chapter_array_and_linkedlist/array.go b/codes/go/chapter_array_and_linkedlist/array.go
index 1f1a78be1..578bcb349 100644
--- a/codes/go/chapter_array_and_linkedlist/array.go
+++ b/codes/go/chapter_array_and_linkedlist/array.go
@@ -5,7 +5,6 @@
 package chapter_array_and_linkedlist
 
 import (
-	"fmt"
 	"math/rand"
 )
 
@@ -60,9 +59,10 @@ func traverse(nums []int) {
 	for i := 0; i < len(nums); i++ {
 		count++
 	}
+	count = 0
 	// 直接遍历数组
-	for index, val := range nums {
-		fmt.Printf("index:%v value:%v\n", index, val)
+	for range nums {
+		count++
 	}
 }
 
diff --git a/codes/go/chapter_array_and_linkedlist/linked_list.go b/codes/go/chapter_array_and_linkedlist/linked_list.go
index 106e49f4c..fa4538ab4 100644
--- a/codes/go/chapter_array_and_linkedlist/linked_list.go
+++ b/codes/go/chapter_array_and_linkedlist/linked_list.go
@@ -9,14 +9,14 @@ import (
 )
 
 /* 在链表的结点 n0 之后插入结点 P */
-func insertNode(n0 *pkg.ListNode, P *pkg.ListNode) {
+func insertNode(n0 *ListNode, P *ListNode) {
 	n1 := n0.Next
 	n0.Next = P
 	P.Next = n1
 }
 
 /* 删除链表的结点 n0 之后的首个结点 */
-func removeNode(n0 *pkg.ListNode) {
+func removeNode(n0 *ListNode) {
 	if n0.Next == nil {
 		return
 	}
@@ -27,7 +27,7 @@ func removeNode(n0 *pkg.ListNode) {
 }
 
 /* 访问链表中索引为 index 的结点 */
-func access(head *pkg.ListNode, index int) *pkg.ListNode {
+func access(head *ListNode, index int) *ListNode {
 	for i := 0; i < index; i++ {
 		head = head.Next
 		if head == nil {
@@ -38,7 +38,7 @@ func access(head *pkg.ListNode, index int) *pkg.ListNode {
 }
 
 /* 在链表中查找值为 target 的首个结点 */
-func findNode(head *pkg.ListNode, target int) int {
+func findNode(head *ListNode, target int) int {
 	index := 0
 	for head != nil {
 		if head.Val == target {
diff --git a/codes/go/chapter_array_and_linkedlist/linked_list_test.go b/codes/go/chapter_array_and_linkedlist/linked_list_test.go
index 18061efff..466bde4f5 100644
--- a/codes/go/chapter_array_and_linkedlist/linked_list_test.go
+++ b/codes/go/chapter_array_and_linkedlist/linked_list_test.go
@@ -6,18 +6,19 @@ package chapter_array_and_linkedlist
 
 import (
 	"fmt"
-	"github.com/krahets/hello-algo/pkg"
 	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
 )
 
 func TestLikedList(t *testing.T) {
 	/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
 	// 初始化各个结点
-	n0 := pkg.NewListNode(1)
-	n1 := pkg.NewListNode(3)
-	n2 := pkg.NewListNode(2)
-	n3 := pkg.NewListNode(5)
-	n4 := pkg.NewListNode(4)
+	n0 := NewListNode(1)
+	n1 := NewListNode(3)
+	n2 := NewListNode(2)
+	n3 := NewListNode(5)
+	n4 := NewListNode(4)
 
 	// 构建引用指向
 	n0.Next = n1
@@ -25,17 +26,17 @@ func TestLikedList(t *testing.T) {
 	n2.Next = n3
 	n3.Next = n4
 	fmt.Println("初始化的链表为")
-	pkg.PrintLinkedList(n0)
+	PrintLinkedList(n0)
 
 	/* 插入结点 */
-	insertNode(n0, pkg.NewListNode(0))
+	insertNode(n0, NewListNode(0))
 	fmt.Println("插入结点后的链表为")
-	pkg.PrintLinkedList(n0)
+	PrintLinkedList(n0)
 
 	/* 删除结点 */
 	removeNode(n0)
 	fmt.Println("删除结点后的链表为")
-	pkg.PrintLinkedList(n0)
+	PrintLinkedList(n0)
 
 	/* 访问结点 */
 	node := access(n0, 3)

From 5cb62fd45899b8ddd74e1c76cf419356c67449b8 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Mon, 2 Jan 2023 19:03:36 +0800
Subject: [PATCH 061/158] Update the array (Go code).

---
 codes/go/chapter_array_and_linkedlist/array.go | 4 ++--
 docs/chapter_array_and_linkedlist/array.md     | 5 ++---
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/codes/go/chapter_array_and_linkedlist/array.go b/codes/go/chapter_array_and_linkedlist/array.go
index 578bcb349..5740811d8 100644
--- a/codes/go/chapter_array_and_linkedlist/array.go
+++ b/codes/go/chapter_array_and_linkedlist/array.go
@@ -27,8 +27,8 @@ func extend(nums []int, enlarge int) []int {
 	// 初始化一个扩展长度后的数组
 	res := make([]int, len(nums)+enlarge)
 	// 将原数组中的所有元素复制到新数组
-	for i := 0; i < len(nums); i++ {
-		res[i] = nums[i]
+	for i, num := range nums {
+		res[i] = num
 	}
 	// 返回扩展后的新数组
 	return res
diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 5168a5d5d..7f853a8f5 100644
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -136,7 +136,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
     ```go title="array.go"
     /* 随机返回一个数组元素 */
-    func randomAccess(nums [5]int) (randomNum int) {
+    func randomAccess(nums []int) (randomNum int) {
         // 在区间 [0, nums.length) 中随机抽取一个数字
         randomIndex := rand.Intn(len(nums))
         // 获取并返回随机元素
@@ -392,7 +392,6 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     /* 在数组的索引 index 处插入元素 num */
     func insert(nums []int, num int, index int) {
         // 把索引 index 以及之后的所有元素向后移动一位
-        // 如果超出了数组长度，会被直接舍弃
         for i := len(nums) - 1; i > index; i-- {
             nums[i] = nums[i-1]
         }
@@ -403,7 +402,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     /* 删除索引 index 处元素 */
     func remove(nums []int, index int) {
         // 把索引 index 之后的所有元素向前移动一位
-        for i := index; i < len(nums) - 1; i++ {
+        for i := index; i < len(nums)-1; i++ {
             nums[i] = nums[i+1]
         }
     }

From 6b02449f2275b5be5df66379b17f29f99c32db68 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Mon, 2 Jan 2023 19:09:46 +0800
Subject: [PATCH 062/158] Update the chapter sorting (Go code).

---
 codes/go/chapter_sorting/{bubble_sort => }/bubble_sort.go      | 2 +-
 codes/go/chapter_sorting/{bubble_sort => }/bubble_sort_test.go | 2 +-
 .../go/chapter_sorting/{insertion_sort => }/insertion_sort.go  | 2 +-
 .../{insertion_sort => }/insertion_sort_test.go                | 2 +-
 codes/go/chapter_sorting/{merge_sort => }/merge_sort.go        | 2 +-
 codes/go/chapter_sorting/{merge_sort => }/merge_sort_test.go   | 3 ++-
 codes/go/chapter_sorting/{quick_sort => }/quick_sort.go        | 2 +-
 codes/go/chapter_sorting/{quick_sort => }/quick_sort_test.go   | 2 +-
 8 files changed, 9 insertions(+), 8 deletions(-)
 rename codes/go/chapter_sorting/{bubble_sort => }/bubble_sort.go (97%)
 rename codes/go/chapter_sorting/{bubble_sort => }/bubble_sort_test.go (94%)
 rename codes/go/chapter_sorting/{insertion_sort => }/insertion_sort.go (95%)
 rename codes/go/chapter_sorting/{insertion_sort => }/insertion_sort_test.go (92%)
 rename codes/go/chapter_sorting/{merge_sort => }/merge_sort.go (98%)
 rename codes/go/chapter_sorting/{merge_sort => }/merge_sort_test.go (92%)
 rename codes/go/chapter_sorting/{quick_sort => }/quick_sort.go (99%)
 rename codes/go/chapter_sorting/{quick_sort => }/quick_sort_test.go (97%)

diff --git a/codes/go/chapter_sorting/bubble_sort/bubble_sort.go b/codes/go/chapter_sorting/bubble_sort.go
similarity index 97%
rename from codes/go/chapter_sorting/bubble_sort/bubble_sort.go
rename to codes/go/chapter_sorting/bubble_sort.go
index a51d19925..ff1ff9ee5 100644
--- a/codes/go/chapter_sorting/bubble_sort/bubble_sort.go
+++ b/codes/go/chapter_sorting/bubble_sort.go
@@ -2,7 +2,7 @@
 // Created Time: 2022-12-06
 // Author: Slone123c (274325721@qq.com)
 
-package bubble_sort
+package chapter_sorting
 
 /* 冒泡排序 */
 func bubbleSort(nums []int) {
diff --git a/codes/go/chapter_sorting/bubble_sort/bubble_sort_test.go b/codes/go/chapter_sorting/bubble_sort_test.go
similarity index 94%
rename from codes/go/chapter_sorting/bubble_sort/bubble_sort_test.go
rename to codes/go/chapter_sorting/bubble_sort_test.go
index bab85139e..53a7d055a 100644
--- a/codes/go/chapter_sorting/bubble_sort/bubble_sort_test.go
+++ b/codes/go/chapter_sorting/bubble_sort_test.go
@@ -2,7 +2,7 @@
 // Created Time: 2022-12-06
 // Author: Slone123c (274325721@qq.com)
 
-package bubble_sort
+package chapter_sorting
 
 import (
 	"fmt"
diff --git a/codes/go/chapter_sorting/insertion_sort/insertion_sort.go b/codes/go/chapter_sorting/insertion_sort.go
similarity index 95%
rename from codes/go/chapter_sorting/insertion_sort/insertion_sort.go
rename to codes/go/chapter_sorting/insertion_sort.go
index 2be78bcf6..24101e969 100644
--- a/codes/go/chapter_sorting/insertion_sort/insertion_sort.go
+++ b/codes/go/chapter_sorting/insertion_sort.go
@@ -2,7 +2,7 @@
 // Created Time: 2022-12-12
 // Author: msk397 (machangxinq@gmail.com)
 
-package insertion_sort
+package chapter_sorting
 
 func insertionSort(nums []int) {
 	// 外循环：待排序元素数量为 n-1, n-2, ..., 1
diff --git a/codes/go/chapter_sorting/insertion_sort/insertion_sort_test.go b/codes/go/chapter_sorting/insertion_sort_test.go
similarity index 92%
rename from codes/go/chapter_sorting/insertion_sort/insertion_sort_test.go
rename to codes/go/chapter_sorting/insertion_sort_test.go
index 07a96b8f4..9802b406b 100644
--- a/codes/go/chapter_sorting/insertion_sort/insertion_sort_test.go
+++ b/codes/go/chapter_sorting/insertion_sort_test.go
@@ -2,7 +2,7 @@
 // Created Time: 2022-12-12
 // Author: msk397 (machangxinq@gmail.com)
 
-package insertion_sort
+package chapter_sorting
 
 import (
 	"fmt"
diff --git a/codes/go/chapter_sorting/merge_sort/merge_sort.go b/codes/go/chapter_sorting/merge_sort.go
similarity index 98%
rename from codes/go/chapter_sorting/merge_sort/merge_sort.go
rename to codes/go/chapter_sorting/merge_sort.go
index f2910600a..1b3a3932d 100644
--- a/codes/go/chapter_sorting/merge_sort/merge_sort.go
+++ b/codes/go/chapter_sorting/merge_sort.go
@@ -2,7 +2,7 @@
 // Created Time: 2022-12-13
 // Author: msk397 (machangxinq@gmail.com)
 
-package merge_sort
+package chapter_sorting
 
 // 合并左子数组和右子数组
 // 左子数组区间 [left, mid]
diff --git a/codes/go/chapter_sorting/merge_sort/merge_sort_test.go b/codes/go/chapter_sorting/merge_sort_test.go
similarity index 92%
rename from codes/go/chapter_sorting/merge_sort/merge_sort_test.go
rename to codes/go/chapter_sorting/merge_sort_test.go
index 04abd443b..3ece175a1 100644
--- a/codes/go/chapter_sorting/merge_sort/merge_sort_test.go
+++ b/codes/go/chapter_sorting/merge_sort_test.go
@@ -1,8 +1,9 @@
-package merge_sort
 // File: merge_sort_test.go
 // Created Time: 2022-12-13
 // Author: msk397 (machangxinq@gmail.com)
 
+package chapter_sorting
+
 import (
 	"fmt"
 	"testing"
diff --git a/codes/go/chapter_sorting/quick_sort/quick_sort.go b/codes/go/chapter_sorting/quick_sort.go
similarity index 99%
rename from codes/go/chapter_sorting/quick_sort/quick_sort.go
rename to codes/go/chapter_sorting/quick_sort.go
index d42eb0abd..88aa14264 100644
--- a/codes/go/chapter_sorting/quick_sort/quick_sort.go
+++ b/codes/go/chapter_sorting/quick_sort.go
@@ -2,7 +2,7 @@
 // Created Time: 2022-12-12
 // Author: msk397 (machangxinq@gmail.com)
 
-package quick_sort
+package chapter_sorting
 
 // 快速排序
 type QuickSort struct{}
diff --git a/codes/go/chapter_sorting/quick_sort/quick_sort_test.go b/codes/go/chapter_sorting/quick_sort_test.go
similarity index 97%
rename from codes/go/chapter_sorting/quick_sort/quick_sort_test.go
rename to codes/go/chapter_sorting/quick_sort_test.go
index 0a0a6d44a..86ae0115a 100644
--- a/codes/go/chapter_sorting/quick_sort/quick_sort_test.go
+++ b/codes/go/chapter_sorting/quick_sort_test.go
@@ -2,7 +2,7 @@
 // Created Time: 2022-12-12
 // Author: msk397 (machangxinq@gmail.com)
 
-package quick_sort
+package chapter_sorting
 
 import (
 	"fmt"

From 8c736252abd973e881091facff78872eef85bbb3 Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Mon, 2 Jan 2023 19:10:48 +0800
Subject: [PATCH 063/158] code: transcribe time_complexity.js

---
 .../time_complexity.js                        | 153 ++++++++++++++++++
 .../time_complexity.ts                        |   2 +-
 2 files changed, 154 insertions(+), 1 deletion(-)

diff --git a/codes/javascript/chapter_computational_complexity/time_complexity.js b/codes/javascript/chapter_computational_complexity/time_complexity.js
index 9c877602f..803b15c85 100644
--- a/codes/javascript/chapter_computational_complexity/time_complexity.js
+++ b/codes/javascript/chapter_computational_complexity/time_complexity.js
@@ -3,3 +3,156 @@
  * Created Time: 2023-01-02
  * Author: RiverTwilight (contact@rene.wang)
  */
+
+class time_complexity {
+	/* 常数阶 */
+	constant(n) {
+		var count = 0;
+		const size = 100000;
+		for (var i = 0; i < size; i++) count++;
+		return count;
+	}
+
+	/* 线性阶 */
+	linear(n) {
+		var count = 0;
+		for (var i = 0; i < n; i++) count++;
+		return count;
+	}
+
+	/* 线性阶（遍历数组） */
+	arrayTraversal(nums) {
+		var count = 0;
+		// 循环次数与数组长度成正比
+		nums.forEach(() => {
+			count++;
+		});
+	}
+
+	/* 平方阶 */
+	quadratic(n) {
+		var count = 0;
+		// 循环次数与数组长度成平方关系
+		for (var i = 0; i < n; i++) {
+			for (let j = 0; j < n; j++) {
+				count++;
+			}
+		}
+		return count;
+	}
+
+	/* 平方阶（冒泡排序） */
+	bubbleSort(nums) {
+		var count = 0; // 计数器
+		// 外循环：待排序元素数量为 n-1, n-2, ..., 1
+		for (var i = nums.length - 1; i > 0; i--) {
+			// 内循环：冒泡操作
+			for (let j = 0; j < i; j++) {
+				if (nums[j] > nums[j + 1]) {
+					// 交换 nums[j] 与 nums[j + 1]
+					let tmp = nums[j];
+					nums[j] = nums[j + 1];
+					nums[j + 1] = tmp;
+					count += 3; // 元素交换包含 3 个单元操作
+				}
+			}
+		}
+		return count;
+	}
+
+	/* 指数阶（循环实现） */
+	exponential(n) {
+		var count = 0,
+			base = 1;
+		// cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+		for (var i = 0; i < n; i++) {
+			for (let j = 0; j < base; j++) {
+				count++;
+			}
+			base *= 2;
+		}
+		// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+		return count;
+	}
+
+	/* 指数阶（递归实现） */
+	expRecur(n) {
+		if (n == 1) return 1;
+		return this.expRecur(n - 1) + this.expRecur(n - 1) + 1;
+	}
+
+	/* 对数阶（循环实现） */
+	logarithmic(n) {
+		var count = 0;
+		while (n > 1) {
+			n = n / 2;
+			count++;
+		}
+		return count;
+	}
+
+	/* 对数阶（递归实现） */
+	logRecur(n) {
+		if (n <= 1) return 0;
+		return this.logRecur(n / 2) + 1;
+	}
+
+	/* 线性对数阶 */
+	linearLogRecur(n) {
+		if (n <= 1) return 1;
+		var count = this.linearLogRecur(n / 2) + this.linearLogRecur(n / 2);
+		for (var i = 0; i < n; i++) {
+			count++;
+		}
+		return count;
+	}
+
+	/* 阶乘阶（递归实现） */
+	factorialRecur(n) {
+		if (n == 0) return 1;
+		var count = 0;
+		// 从 1 个分裂出 n 个
+		for (var i = 0; i < n; i++) {
+			count += this.factorialRecur(n - 1);
+		}
+		return count;
+	}
+}
+
+(function main() {
+	var test = new time_complexity();
+
+	var n = 8;
+	console.log("输入数据大小 n = " + n);
+
+	var count = test.constant(n);
+	console.log("常数阶的计算操作数量 = " + count);
+
+	count = test.linear(n);
+	console.log("线性阶的计算操作数量 = " + count);
+	count = test.arrayTraversal(new Array(n));
+	console.log("线性阶（遍历数组）的计算操作数量 = " + count);
+
+	count = test.quadratic(n);
+	console.log("平方阶的计算操作数量 = " + count);
+	var nums = new Array(n);
+	for (var i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
+	count = test.bubbleSort(nums);
+	console.log("平方阶（冒泡排序）的计算操作数量 = " + count);
+
+	count = test.exponential(n);
+	console.log("指数阶（循环实现）的计算操作数量 = " + count);
+	count = test.expRecur(n);
+	console.log("指数阶（递归实现）的计算操作数量 = " + count);
+
+	count = test.logarithmic(n);
+	console.log("对数阶（循环实现）的计算操作数量 = " + count);
+	count = test.logRecur(n);
+	console.log("对数阶（递归实现）的计算操作数量 = " + count);
+
+	count = test.linearLogRecur(n);
+	console.log("线性对数阶（递归实现）的计算操作数量 = " + count);
+
+	count = test.factorialRecur(n);
+	console.log("阶乘阶（递归实现）的计算操作数量 = " + count);
+})();
diff --git a/codes/typescript/chapter_computational_complexity/time_complexity.ts b/codes/typescript/chapter_computational_complexity/time_complexity.ts
index 6f0c9737c..9c877602f 100644
--- a/codes/typescript/chapter_computational_complexity/time_complexity.ts
+++ b/codes/typescript/chapter_computational_complexity/time_complexity.ts
@@ -1,5 +1,5 @@
 /**
- * File: time_complexity.ts
+ * File: time_complexity.js
  * Created Time: 2023-01-02
  * Author: RiverTwilight (contact@rene.wang)
  */

From f83dcce3467f31823b471e13c7a93b0125efb814 Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Mon, 2 Jan 2023 19:13:36 +0800
Subject: [PATCH 064/158] fix: doesnt return anything

---
 .../chapter_computational_complexity/time_complexity.js      | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/codes/javascript/chapter_computational_complexity/time_complexity.js b/codes/javascript/chapter_computational_complexity/time_complexity.js
index 803b15c85..9fafb9656 100644
--- a/codes/javascript/chapter_computational_complexity/time_complexity.js
+++ b/codes/javascript/chapter_computational_complexity/time_complexity.js
@@ -24,9 +24,10 @@ class time_complexity {
 	arrayTraversal(nums) {
 		var count = 0;
 		// 循环次数与数组长度成正比
-		nums.forEach(() => {
+		for (var i = 0; i < nums.length; i++) {
 			count++;
-		});
+		}
+		return count;
 	}
 
 	/* 平方阶 */

From 410c5d6b6270dd58fac638194e56f879fec512eb Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Mon, 2 Jan 2023 19:53:55 +0800
Subject: [PATCH 065/158] Free memory after removing a node from a LinkedList
 or TreeNode.

---
 .../linked_list.cpp                           |  2 +
 .../linkedlist_queue.cpp                      |  3 +
 .../linkedlist_stack.cpp                      |  3 +
 codes/cpp/chapter_tree/binary_search_tree.cpp |  8 ++-
 codes/cpp/chapter_tree/binary_tree.cpp        |  1 +
 codes/csharp/chapter_tree/avl_tree.cs         |  6 +-
 .../csharp/chapter_tree/binary_search_tree.cs |  6 +-
 codes/go/chapter_tree/binary_search_tree.go   | 21 ++-----
 .../chapter_tree/binary_search_tree_test.go   | 17 +++---
 codes/java/chapter_tree/avl_tree.java         |  6 +-
 .../java/chapter_tree/binary_search_tree.java |  6 +-
 .../chapter_tree/binary_search_tree.js        |  6 +-
 codes/python/chapter_tree/avl_tree.py         |  6 +-
 .../python/chapter_tree/binary_search_tree.py |  7 +--
 .../chapter_tree/binary_search_tree.ts        |  6 +-
 .../linked_list.md                            |  2 +
 docs/chapter_stack_and_queue/queue.md         |  3 +
 docs/chapter_stack_and_queue/stack.md         |  3 +
 docs/chapter_tree/avl_tree.md                 | 37 +-----------
 docs/chapter_tree/binary_search_tree.md       | 60 +++----------------
 20 files changed, 69 insertions(+), 140 deletions(-)

diff --git a/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp b/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp
index 46116d291..4cf049204 100644
--- a/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp
+++ b/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp
@@ -21,6 +21,8 @@ void remove(ListNode* n0) {
     ListNode* P = n0->next;
     ListNode* n1 = P->next;
     n0->next = n1;
+    // 释放内存
+    delete P;
 }
 
 /* 访问链表中索引为 index 的结点 */
diff --git a/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp b/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp
index 17625322d..dcaac225f 100644
--- a/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp
+++ b/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp
@@ -50,7 +50,10 @@ public:
     int poll() {
         int num = peek();
         // 删除头结点
+        ListNode *tmp = front;
         front = front->next;
+        // 释放内存
+        delete tmp; 
         queSize--;
         return num;
     }
diff --git a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp
index 1bb7c2a3c..312b75135 100644
--- a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp
+++ b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp
@@ -39,7 +39,10 @@ public:
     /* 出栈 */
     int pop() {
         int num = top();
+        ListNode *tmp = stackTop;
         stackTop = stackTop->next;
+        // 释放内存
+        delete tmp;
         stkSize--;
         return num;
     }
diff --git a/codes/cpp/chapter_tree/binary_search_tree.cpp b/codes/cpp/chapter_tree/binary_search_tree.cpp
index 246bdbaa1..c7f8734da 100644
--- a/codes/cpp/chapter_tree/binary_search_tree.cpp
+++ b/codes/cpp/chapter_tree/binary_search_tree.cpp
@@ -96,11 +96,13 @@ public:
             // 删除结点 cur
             if (pre->left == cur) pre->left = child;
             else pre->right = child;
+            // 释放内存
+            delete cur;
         }
         // 子结点数量 = 2
         else {
             // 获取中序遍历中 cur 的下一个结点
-            TreeNode* nex = min(cur->right);
+            TreeNode* nex = getInOrderNext(cur->right);
             int tmp = nex->val;
             // 递归删除结点 nex
             remove(nex->val);
@@ -110,8 +112,8 @@ public:
         return cur;
     }
 
-    /* 获取最小结点 */
-    TreeNode* min(TreeNode* root) {
+    /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+    TreeNode* getInOrderNext(TreeNode* root) {
         if (root == nullptr) return root;
         // 循环访问左子结点，直到叶结点时为最小结点，跳出
         while (root->left != nullptr) {
diff --git a/codes/cpp/chapter_tree/binary_tree.cpp b/codes/cpp/chapter_tree/binary_tree.cpp
index 3258d9cfc..fb00431eb 100644
--- a/codes/cpp/chapter_tree/binary_tree.cpp
+++ b/codes/cpp/chapter_tree/binary_tree.cpp
@@ -33,6 +33,7 @@ int main() {
     PrintUtil::printTree(n1);
     // 删除结点 P
     n1->left = n2;
+    delete P;  // 释放内存
     cout << endl << "删除结点 P 后\n" << endl;
     PrintUtil::printTree(n1);
 
diff --git a/codes/csharp/chapter_tree/avl_tree.cs b/codes/csharp/chapter_tree/avl_tree.cs
index 99ec17f63..6bcb559b7 100644
--- a/codes/csharp/chapter_tree/avl_tree.cs
+++ b/codes/csharp/chapter_tree/avl_tree.cs
@@ -162,7 +162,7 @@ namespace hello_algo.chapter_tree
                 else
                 {
                     // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
-                    TreeNode? temp = minNode(node.right);
+                    TreeNode? temp = getInOrderNext(node.right);
                     node.right = removeHelper(node.right, temp.val);
                     node.val = temp.val;
                 }
@@ -174,8 +174,8 @@ namespace hello_algo.chapter_tree
             return node;
         }
 
-        /* 获取最小结点 */
-        private TreeNode? minNode(TreeNode? node)
+        /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+        private TreeNode? getInOrderNext(TreeNode? node)
         {
             if (node == null) return node;
             // 循环访问左子结点，直到叶结点时为最小结点，跳出
diff --git a/codes/csharp/chapter_tree/binary_search_tree.cs b/codes/csharp/chapter_tree/binary_search_tree.cs
index 8224317df..5164cf780 100644
--- a/codes/csharp/chapter_tree/binary_search_tree.cs
+++ b/codes/csharp/chapter_tree/binary_search_tree.cs
@@ -125,7 +125,7 @@ namespace hello_algo.chapter_tree
             else
             {
                 // 获取中序遍历中 cur 的下一个结点
-                TreeNode? nex = min(cur.right);
+                TreeNode? nex = getInOrderNext(cur.right);
                 if (nex != null)
                 {
                     int tmp = nex.val;
@@ -138,8 +138,8 @@ namespace hello_algo.chapter_tree
             return cur;
         }
 
-        /* 获取最小结点 */
-        private TreeNode? min(TreeNode? root)
+        /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+        private TreeNode? getInOrderNext(TreeNode? root)
         {
             if (root == null) return root;
             // 循环访问左子结点，直到叶结点时为最小结点，跳出
diff --git a/codes/go/chapter_tree/binary_search_tree.go b/codes/go/chapter_tree/binary_search_tree.go
index 2af2e7be0..c8fc5d62c 100644
--- a/codes/go/chapter_tree/binary_search_tree.go
+++ b/codes/go/chapter_tree/binary_search_tree.go
@@ -23,13 +23,13 @@ func NewBinarySearchTree(nums []int) *BinarySearchTree {
 	}
 }
 
-// GetRoot Get the root node of binary search tree
+/* 获取根结点 */
 func (bst *BinarySearchTree) GetRoot() *TreeNode {
 	return bst.root
 }
 
-// GetMin Get node with the min value
-func (bst *BinarySearchTree) GetMin(node *TreeNode) *TreeNode {
+/* 获取中序遍历的下一个结点 */
+func (bst *BinarySearchTree) GetInOrderNext(node *TreeNode) *TreeNode {
 	if node == nil {
 		return node
 	}
@@ -40,19 +40,6 @@ func (bst *BinarySearchTree) GetMin(node *TreeNode) *TreeNode {
 	return node
 }
 
-// GetInorderNext Get node inorder next
-func (bst *BinarySearchTree) GetInorderNext(node *TreeNode) *TreeNode {
-	if node == nil || node.Right == nil {
-		return node
-	}
-	node = node.Right
-	// 循环访问左子结点，直到叶结点时为最小结点，跳出
-	for node.Left != nil {
-		node = node.Left
-	}
-	return node
-}
-
 /* 查找结点 */
 func (bst *BinarySearchTree) Search(num int) *TreeNode {
 	node := bst.root
@@ -149,7 +136,7 @@ func (bst *BinarySearchTree) Remove(num int) *TreeNode {
 		// 子结点数为 2
 	} else {
 		// 获取中序遍历中待删除结点 cur 的下一个结点
-		next := bst.GetInorderNext(cur)
+		next := bst.GetInOrderNext(cur)
 		temp := next.Val
 		// 递归删除结点 next
 		bst.Remove(next.Val)
diff --git a/codes/go/chapter_tree/binary_search_tree_test.go b/codes/go/chapter_tree/binary_search_tree_test.go
index 0d0369a78..cdf7d8d48 100644
--- a/codes/go/chapter_tree/binary_search_tree_test.go
+++ b/codes/go/chapter_tree/binary_search_tree_test.go
@@ -12,33 +12,30 @@ import (
 func TestBinarySearchTree(t *testing.T) {
 	nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
 	bst := NewBinarySearchTree(nums)
-	fmt.Println("初始化的二叉树为:")
+	fmt.Println("\n初始化的二叉树为:")
 	bst.Print()
 
 	// 获取根结点
 	node := bst.GetRoot()
-	fmt.Println("二叉树的根结点为:", node.Val)
-	// 获取最小的结点
-	node = bst.GetMin(bst.GetRoot())
-	fmt.Println("二叉树的最小结点为:", node.Val)
+	fmt.Println("\n二叉树的根结点为:", node.Val)
 
 	// 查找结点
 	node = bst.Search(5)
-	fmt.Println("查找到的结点对象为", node, "，结点值 =", node.Val)
+	fmt.Println("\n查找到的结点对象为", node, "，结点值 =", node.Val)
 
 	// 插入结点
 	node = bst.Insert(16)
-	fmt.Println("插入结点后 16 的二叉树为:")
+	fmt.Println("\n插入结点后 16 的二叉树为:")
 	bst.Print()
 
 	// 删除结点
 	bst.Remove(1)
-	fmt.Println("删除结点 1 后的二叉树为:")
+	fmt.Println("\n删除结点 1 后的二叉树为:")
 	bst.Print()
 	bst.Remove(2)
-	fmt.Println("删除结点 2 后的二叉树为:")
+	fmt.Println("\n删除结点 2 后的二叉树为:")
 	bst.Print()
 	bst.Remove(4)
-	fmt.Println("删除结点 4 后的二叉树为:")
+	fmt.Println("\n删除结点 4 后的二叉树为:")
 	bst.Print()
 }
diff --git a/codes/java/chapter_tree/avl_tree.java b/codes/java/chapter_tree/avl_tree.java
index 48be762e9..2f731b7e4 100644
--- a/codes/java/chapter_tree/avl_tree.java
+++ b/codes/java/chapter_tree/avl_tree.java
@@ -138,7 +138,7 @@ class AVLTree {
                     node = child;
             } else {
                 // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
-                TreeNode temp = minNode(node.right);
+                TreeNode temp = getInOrderNext(node.right);
                 node.right = removeHelper(node.right, temp.val);
                 node.val = temp.val;
             }
@@ -150,8 +150,8 @@ class AVLTree {
         return node;
     }
 
-    /* 获取最小结点 */
-    private TreeNode minNode(TreeNode node) {
+    /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+    private TreeNode getInOrderNext(TreeNode node) {
         if (node == null) return node;
         // 循环访问左子结点，直到叶结点时为最小结点，跳出
         while (node.left != null) {
diff --git a/codes/java/chapter_tree/binary_search_tree.java b/codes/java/chapter_tree/binary_search_tree.java
index 0770c567d..4a7c53dba 100644
--- a/codes/java/chapter_tree/binary_search_tree.java
+++ b/codes/java/chapter_tree/binary_search_tree.java
@@ -101,7 +101,7 @@ class BinarySearchTree {
         // 子结点数量 = 2
         else {
             // 获取中序遍历中 cur 的下一个结点
-            TreeNode nex = min(cur.right);
+            TreeNode nex = getInOrderNext(cur.right);
             int tmp = nex.val;
             // 递归删除结点 nex
             remove(nex.val);
@@ -111,8 +111,8 @@ class BinarySearchTree {
         return cur;
     }
 
-    /* 获取最小结点 */
-    public TreeNode min(TreeNode root) {
+    /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+    public TreeNode getInOrderNext(TreeNode root) {
         if (root == null) return root;
         // 循环访问左子结点，直到叶结点时为最小结点，跳出
         while (root.left != null) {
diff --git a/codes/javascript/chapter_tree/binary_search_tree.js b/codes/javascript/chapter_tree/binary_search_tree.js
index 1e0d92738..c00d8bea8 100644
--- a/codes/javascript/chapter_tree/binary_search_tree.js
+++ b/codes/javascript/chapter_tree/binary_search_tree.js
@@ -98,7 +98,7 @@ function remove(num) {
     // 子结点数量 = 2
     else {
         // 获取中序遍历中 cur 的下一个结点
-        let nex = min(cur.right);
+        let nex = getInOrderNext(cur.right);
         let tmp = nex.val;
         // 递归删除结点 nex
         remove(nex.val);
@@ -108,8 +108,8 @@ function remove(num) {
     return cur;
 }
 
-/* 获取最小结点 */
-function min(root) {
+/* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+function getInOrderNext(root) {
     if (root === null) return root;
     // 循环访问左子结点，直到叶结点时为最小结点，跳出
     while (root.left !== null) {
diff --git a/codes/python/chapter_tree/avl_tree.py b/codes/python/chapter_tree/avl_tree.py
index d0ff48cba..04218e46a 100644
--- a/codes/python/chapter_tree/avl_tree.py
+++ b/codes/python/chapter_tree/avl_tree.py
@@ -132,7 +132,7 @@ class AVLTree:
                 else:
                     node = child
             else:  # 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
-                temp = self.__min_node(node.right)
+                temp = self.__get_inorder_next(node.right)
                 node.right = self.__remove_helper(node.right, temp.val)
                 node.val = temp.val
         # 更新结点高度
@@ -140,8 +140,8 @@ class AVLTree:
         # 2. 执行旋转操作，使该子树重新恢复平衡
         return self.__rotate(node)
 
-    """ 获取最小结点 """
-    def __min_node(self, node: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
+    """ 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） """
+    def __get_inorder_next(self, node: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
         if node is None:
             return None
         # 循环访问左子结点，直到叶结点时为最小结点，跳出
diff --git a/codes/python/chapter_tree/binary_search_tree.py b/codes/python/chapter_tree/binary_search_tree.py
index 23e341854..db52d57bd 100644
--- a/codes/python/chapter_tree/binary_search_tree.py
+++ b/codes/python/chapter_tree/binary_search_tree.py
@@ -117,7 +117,7 @@ class BinarySearchTree:
         # 子结点数量 = 2
         else:
             # 获取中序遍历中 cur 的下一个结点
-            nex = self.min(cur.right)
+            nex = self.get_inorder_next(cur.right)
             tmp = nex.val
             # 递归删除结点 nex
             self.remove(nex.val)
@@ -125,11 +125,10 @@ class BinarySearchTree:
             cur.val = tmp
         return cur
 
-    """ 获取最小结点 """
-    def min(self, root: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
+    """ 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） """
+    def get_inorder_next(self, root: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
         if root is None:
             return root
-
         # 循环访问左子结点，直到叶结点时为最小结点，跳出
         while root.left is not None:
             root = root.left
diff --git a/codes/typescript/chapter_tree/binary_search_tree.ts b/codes/typescript/chapter_tree/binary_search_tree.ts
index 6dad83421..a99e6ba26 100644
--- a/codes/typescript/chapter_tree/binary_search_tree.ts
+++ b/codes/typescript/chapter_tree/binary_search_tree.ts
@@ -120,7 +120,7 @@ function remove(num: number): TreeNode | null {
     // 子结点数量 = 2
     else {
         // 获取中序遍历中 cur 的下一个结点
-        let next = min(cur.right);
+        let next = getInOrderNext(cur.right);
         let tmp = next!.val;
         // 递归删除结点 nex
         remove(next!.val);
@@ -130,8 +130,8 @@ function remove(num: number): TreeNode | null {
     return cur;
 }
 
-/* 获取最小结点 */
-function min(root: TreeNode | null): TreeNode | null {
+/* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+function getInOrderNext(root: TreeNode | null): TreeNode | null {
     if (root === null) {
         return null;
     }
diff --git a/docs/chapter_array_and_linkedlist/linked_list.md b/docs/chapter_array_and_linkedlist/linked_list.md
index a55d68028..5b6888c06 100644
--- a/docs/chapter_array_and_linkedlist/linked_list.md
+++ b/docs/chapter_array_and_linkedlist/linked_list.md
@@ -293,6 +293,8 @@ comments: true
         ListNode* P = n0->next;
         ListNode* n1 = P->next;
         n0->next = n1;
+        // 释放内存
+        delete P;
     }
     ```
 
diff --git a/docs/chapter_stack_and_queue/queue.md b/docs/chapter_stack_and_queue/queue.md
index 3c5c0528d..cc815b3ab 100644
--- a/docs/chapter_stack_and_queue/queue.md
+++ b/docs/chapter_stack_and_queue/queue.md
@@ -331,7 +331,10 @@ comments: true
         int poll() {
             int num = peek();
             // 删除头结点
+            ListNode *tmp = front;
             front = front->next;
+            // 释放内存
+            delete tmp; 
             queSize--;
             return num;
         }
diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index b0d577bce..7e35fddbd 100644
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -311,7 +311,10 @@ comments: true
         /* 出栈 */
         int pop() {
             int num = top();
+            ListNode *tmp = stackTop;
             stackTop = stackTop->next;
+            // 释放内存
+            delete tmp;
             stkSize--;
             return num;
         }
diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md
index e9a656bed..45308fa6f 100644
--- a/docs/chapter_tree/avl_tree.md
+++ b/docs/chapter_tree/avl_tree.md
@@ -772,7 +772,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
                     node = child;
             } else {
                 // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
-                TreeNode temp = minNode(node.right);
+                TreeNode temp = getInOrderNext(node.right);
                 node.right = removeHelper(node.right, temp.val);
                 node.val = temp.val;
             }
@@ -783,16 +783,6 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         // 返回子树的根节点
         return node;
     }
-    
-    /* 获取最小结点 */
-    TreeNode minNode(TreeNode node) {
-        if (node == null) return node;
-        // 循环访问左子结点，直到叶结点时为最小结点，跳出
-        while (node.left != null) {
-            node = node.left;
-        }
-        return node;
-    }
     ```
 
 === "C++"
@@ -828,22 +818,13 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
                 else:
                     node = child
             else:  # 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
-                temp = self.min_node(node.right)
+                temp = self.__get_inorder_next(node.right)
                 node.right = self.__remove_helper(node.right, temp.val)
                 node.val = temp.val
         # 更新结点高度
         self.__update_height(node)
         # 2. 执行旋转操作，使该子树重新恢复平衡
         return self.__rotate(node)
-
-    """ 获取最小结点 """
-    def min_node(self, node: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
-        if node is None:
-            return None
-        # 循环访问左子结点，直到叶结点时为最小结点，跳出
-        while node.left is not None:
-            node = node.left
-        return node
     ```
 
 === "Go"
@@ -904,7 +885,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
             else
             {
                 // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
-                TreeNode? temp = minNode(node.right);
+                TreeNode? temp = getInOrderNext(node.right);
                 node.right = removeHelper(node.right, temp.val);
                 node.val = temp.val;
             }
@@ -915,18 +896,6 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         // 返回子树的根节点
         return node;
     }
-
-    /* 获取最小结点 */
-    private TreeNode? minNode(TreeNode? node)
-    {
-        if (node == null) return node;
-        // 循环访问左子结点，直到叶结点时为最小结点，跳出
-        while (node.left != null)
-        {
-            node = node.left;
-        }
-        return node;
-    }
     ```
 
 ### 查找结点
diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md
index 629c051f1..cc7c2f51c 100644
--- a/docs/chapter_tree/binary_search_tree.md
+++ b/docs/chapter_tree/binary_search_tree.md
@@ -445,19 +445,15 @@ comments: true
 3. 使用 `nex` 替换待删除结点；
 
 === "Step 1"
-
     ![bst_remove_case3_1](binary_search_tree.assets/bst_remove_case3_1.png)
 
 === "Step 2"
-
     ![bst_remove_case3_2](binary_search_tree.assets/bst_remove_case3_2.png)
 
 === "Step 3"
-
     ![bst_remove_case3_3](binary_search_tree.assets/bst_remove_case3_3.png)
 
 === "Step 4"
-
     ![bst_remove_case3_4](binary_search_tree.assets/bst_remove_case3_4.png)
 
 删除结点操作也使用 $O(\log n)$ 时间，其中查找待删除结点 $O(\log n)$ ，获取中序遍历后继结点 $O(\log n)$ 。
@@ -489,11 +485,13 @@ comments: true
             // 删除结点 cur
             if (pre.left == cur) pre.left = child;
             else pre.right = child;
+            // 释放内存
+            delete cur;
         }
         // 子结点数量 = 2
         else {
             // 获取中序遍历中 cur 的下一个结点
-            TreeNode nex = min(cur.right);
+            TreeNode nex = getInOrderNext(cur.right);
             int tmp = nex.val;
             // 递归删除结点 nex
             remove(nex.val);
@@ -502,15 +500,6 @@ comments: true
         }
         return cur;
     }
-    /* 获取最小结点 */
-    TreeNode min(TreeNode root) {
-        if (root == null) return root;
-        // 循环访问左子结点，直到叶结点时为最小结点，跳出
-        while (root.left != null) {
-            root = root.left;
-        }
-        return root;
-    }
     ```
 
 === "C++"
@@ -544,7 +533,7 @@ comments: true
         // 子结点数量 = 2
         else {
             // 获取中序遍历中 cur 的下一个结点
-            TreeNode* nex = min(cur->right);
+            TreeNode* nex = getInOrderNext(cur->right);
             int tmp = nex->val;
             // 递归删除结点 nex
             remove(nex->val);
@@ -553,15 +542,6 @@ comments: true
         }
         return cur;
     }
-    /* 获取最小结点 */
-    TreeNode* min(TreeNode* root) {
-        if (root == nullptr) return root;
-        // 循环访问左子结点，直到叶结点时为最小结点，跳出
-        while (root->left != nullptr) {
-            root = root->left;
-        }
-        return root;
-    }
     ```
 
 === "Python"
@@ -604,23 +584,13 @@ comments: true
         # 子结点数量 = 2
         else:
             # 获取中序遍历中 cur 的下一个结点
-            nex = self.min(cur.right)
+            nex = self.get_inorder_next(cur.right)
             tmp = nex.val
             # 递归删除结点 nex
             self.remove(nex.val)
             # 将 nex 的值复制给 cur
             cur.val = tmp
         return cur
-
-    """ 获取最小结点 """
-    def min(self, root: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
-        if root is None:
-            return root
-
-        # 循环访问左子结点，直到叶结点时为最小结点，跳出
-        while root.left is not None:
-            root = root.left
-        return root
     ```
 
 === "Go"
@@ -671,7 +641,7 @@ comments: true
             // 子结点数为 2
         } else {
             // 获取中序遍历中待删除结点 cur 的下一个结点
-            next := bst.GetInorderNext(cur)
+            next := bst.GetInOrderNext(cur)
             temp := next.Val
             // 递归删除结点 next
             bst.Remove(next.Val)
@@ -713,7 +683,7 @@ comments: true
         // 子结点数量 = 2
         else {
             // 获取中序遍历中 cur 的下一个结点
-            let nex = min(cur.right);
+            let nex = getInOrderNext(cur.right);
             let tmp = nex.val;
             // 递归删除结点 nex
             remove(nex.val);
@@ -766,7 +736,7 @@ comments: true
         // 子结点数量 = 2
         else {
             // 获取中序遍历中 cur 的下一个结点
-            let next = min(cur.right);
+            let next = getInOrderNext(cur.right);
             let tmp = next!.val;
             // 递归删除结点 nex
             remove(next!.val);
@@ -824,7 +794,7 @@ comments: true
         else
         {
             // 获取中序遍历中 cur 的下一个结点
-            TreeNode? nex = min(cur.right);
+            TreeNode? nex = getInOrderNext(cur.right);
             if (nex != null)
             {
                 int tmp = nex.val;
@@ -836,18 +806,6 @@ comments: true
         }
         return cur;
     }
-    
-    /* 获取最小结点 */
-    TreeNode? min(TreeNode? root)
-    {
-        if (root == null) return root;
-        // 循环访问左子结点，直到叶结点时为最小结点，跳出
-        while (root.left != null)
-        {
-            root = root.left;
-        }
-        return root;
-    }
     ```
 
 ## 二叉搜索树的优势

From 6e2412f89704665a9e365f9222cf07ee8db422f1 Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Mon, 2 Jan 2023 20:40:01 +0800
Subject: [PATCH 066/158] lint: code lint

---
 docs/chapter_computational_complexity/time_complexity.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 8c2edb08a..2ba703457 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -412,7 +412,7 @@ $$
         a *= 2; // +1
         // 循环 n 次
         for(var i = 0; i < n; i++){ // +1
-            console.log(0) // +1
+            console.log(0); // +1
         }
 
     }
@@ -428,7 +428,7 @@ $$
         a *= 2; // +1
         // 循环 n 次
         for(var i = 0; i < n; i++){ // +1
-            console.log(0) // +1
+            console.log(0); // +1
         }
 
     }

From db2a91bd93f3803ae34f218736414876e36a27f8 Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Mon, 2 Jan 2023 20:49:35 +0800
Subject: [PATCH 067/158] lint: remove class and main

---
 .../time_complexity.js                        | 280 +++++++++---------
 1 file changed, 137 insertions(+), 143 deletions(-)

diff --git a/codes/javascript/chapter_computational_complexity/time_complexity.js b/codes/javascript/chapter_computational_complexity/time_complexity.js
index 9fafb9656..b1a9eb7c5 100644
--- a/codes/javascript/chapter_computational_complexity/time_complexity.js
+++ b/codes/javascript/chapter_computational_complexity/time_complexity.js
@@ -4,156 +4,150 @@
  * Author: RiverTwilight (contact@rene.wang)
  */
 
-class time_complexity {
-	/* 常数阶 */
-	constant(n) {
-		var count = 0;
-		const size = 100000;
-		for (var i = 0; i < size; i++) count++;
-		return count;
-	}
-
-	/* 线性阶 */
-	linear(n) {
-		var count = 0;
-		for (var i = 0; i < n; i++) count++;
-		return count;
-	}
-
-	/* 线性阶（遍历数组） */
-	arrayTraversal(nums) {
-		var count = 0;
-		// 循环次数与数组长度成正比
-		for (var i = 0; i < nums.length; i++) {
-			count++;
-		}
-		return count;
-	}
-
-	/* 平方阶 */
-	quadratic(n) {
-		var count = 0;
-		// 循环次数与数组长度成平方关系
-		for (var i = 0; i < n; i++) {
-			for (let j = 0; j < n; j++) {
-				count++;
-			}
-		}
-		return count;
-	}
-
-	/* 平方阶（冒泡排序） */
-	bubbleSort(nums) {
-		var count = 0; // 计数器
-		// 外循环：待排序元素数量为 n-1, n-2, ..., 1
-		for (var i = nums.length - 1; i > 0; i--) {
-			// 内循环：冒泡操作
-			for (let j = 0; j < i; j++) {
-				if (nums[j] > nums[j + 1]) {
-					// 交换 nums[j] 与 nums[j + 1]
-					let tmp = nums[j];
-					nums[j] = nums[j + 1];
-					nums[j + 1] = tmp;
-					count += 3; // 元素交换包含 3 个单元操作
-				}
-			}
-		}
-		return count;
-	}
-
-	/* 指数阶（循环实现） */
-	exponential(n) {
-		var count = 0,
-			base = 1;
-		// cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
-		for (var i = 0; i < n; i++) {
-			for (let j = 0; j < base; j++) {
-				count++;
-			}
-			base *= 2;
-		}
-		// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
-		return count;
-	}
-
-	/* 指数阶（递归实现） */
-	expRecur(n) {
-		if (n == 1) return 1;
-		return this.expRecur(n - 1) + this.expRecur(n - 1) + 1;
-	}
-
-	/* 对数阶（循环实现） */
-	logarithmic(n) {
-		var count = 0;
-		while (n > 1) {
-			n = n / 2;
-			count++;
-		}
-		return count;
-	}
-
-	/* 对数阶（递归实现） */
-	logRecur(n) {
-		if (n <= 1) return 0;
-		return this.logRecur(n / 2) + 1;
-	}
-
-	/* 线性对数阶 */
-	linearLogRecur(n) {
-		if (n <= 1) return 1;
-		var count = this.linearLogRecur(n / 2) + this.linearLogRecur(n / 2);
-		for (var i = 0; i < n; i++) {
-			count++;
-		}
-		return count;
-	}
-
-	/* 阶乘阶（递归实现） */
-	factorialRecur(n) {
-		if (n == 0) return 1;
-		var count = 0;
-		// 从 1 个分裂出 n 个
-		for (var i = 0; i < n; i++) {
-			count += this.factorialRecur(n - 1);
-		}
-		return count;
-	}
+/* 常数阶 */
+function constant(n) {
+	var count = 0;
+	const size = 100000;
+	for (var i = 0; i < size; i++) count++;
+	return count;
 }
 
-(function main() {
-	var test = new time_complexity();
+/* 线性阶 */
+function linear(n) {
+	var count = 0;
+	for (var i = 0; i < n; i++) count++;
+	return count;
+}
 
-	var n = 8;
-	console.log("输入数据大小 n = " + n);
+/* 线性阶（遍历数组） */
+function arrayTraversal(nums) {
+	var count = 0;
+	// 循环次数与数组长度成正比
+	for (var i = 0; i < nums.length; i++) {
+		count++;
+	}
+	return count;
+}
 
-	var count = test.constant(n);
-	console.log("常数阶的计算操作数量 = " + count);
+/* 平方阶 */
+function quadratic(n) {
+	var count = 0;
+	// 循环次数与数组长度成平方关系
+	for (var i = 0; i < n; i++) {
+		for (let j = 0; j < n; j++) {
+			count++;
+		}
+	}
+	return count;
+}
 
-	count = test.linear(n);
-	console.log("线性阶的计算操作数量 = " + count);
-	count = test.arrayTraversal(new Array(n));
-	console.log("线性阶（遍历数组）的计算操作数量 = " + count);
+/* 平方阶（冒泡排序） */
+function bubbleSort(nums) {
+	var count = 0; // 计数器
+	// 外循环：待排序元素数量为 n-1, n-2, ..., 1
+	for (var i = nums.length - 1; i > 0; i--) {
+		// 内循环：冒泡操作
+		for (let j = 0; j < i; j++) {
+			if (nums[j] > nums[j + 1]) {
+				// 交换 nums[j] 与 nums[j + 1]
+				let tmp = nums[j];
+				nums[j] = nums[j + 1];
+				nums[j + 1] = tmp;
+				count += 3; // 元素交换包含 3 个单元操作
+			}
+		}
+	}
+	return count;
+}
 
-	count = test.quadratic(n);
-	console.log("平方阶的计算操作数量 = " + count);
-	var nums = new Array(n);
-	for (var i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
-	count = test.bubbleSort(nums);
-	console.log("平方阶（冒泡排序）的计算操作数量 = " + count);
+/* 指数阶（循环实现） */
+function exponential(n) {
+	var count = 0,
+		base = 1;
+	// cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+	for (var i = 0; i < n; i++) {
+		for (let j = 0; j < base; j++) {
+			count++;
+		}
+		base *= 2;
+	}
+	// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+	return count;
+}
 
-	count = test.exponential(n);
-	console.log("指数阶（循环实现）的计算操作数量 = " + count);
-	count = test.expRecur(n);
-	console.log("指数阶（递归实现）的计算操作数量 = " + count);
+/* 指数阶（递归实现） */
+function expRecur(n) {
+	if (n == 1) return 1;
+	return expRecur(n - 1) + expRecur(n - 1) + 1;
+}
 
-	count = test.logarithmic(n);
-	console.log("对数阶（循环实现）的计算操作数量 = " + count);
-	count = test.logRecur(n);
-	console.log("对数阶（递归实现）的计算操作数量 = " + count);
+/* 对数阶（循环实现） */
+function logarithmic(n) {
+	var count = 0;
+	while (n > 1) {
+		n = n / 2;
+		count++;
+	}
+	return count;
+}
 
-	count = test.linearLogRecur(n);
-	console.log("线性对数阶（递归实现）的计算操作数量 = " + count);
+/* 对数阶（递归实现） */
+function logRecur(n) {
+	if (n <= 1) return 0;
+	return logRecur(n / 2) + 1;
+}
 
-	count = test.factorialRecur(n);
-	console.log("阶乘阶（递归实现）的计算操作数量 = " + count);
-})();
+/* 线性对数阶 */
+function linearLogRecur(n) {
+	if (n <= 1) return 1;
+	var count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
+	for (var i = 0; i < n; i++) {
+		count++;
+	}
+	return count;
+}
+
+/* 阶乘阶（递归实现） */
+function factorialRecur(n) {
+	if (n == 0) return 1;
+	var count = 0;
+	// 从 1 个分裂出 n 个
+	for (var i = 0; i < n; i++) {
+		count += factorialRecur(n - 1);
+	}
+	return count;
+}
+
+var n = 8;
+console.log("输入数据大小 n = " + n);
+
+var count = constant(n);
+console.log("常数阶的计算操作数量 = " + count);
+
+count = linear(n);
+console.log("线性阶的计算操作数量 = " + count);
+count = arrayTraversal(new Array(n));
+console.log("线性阶（遍历数组）的计算操作数量 = " + count);
+
+count = quadratic(n);
+console.log("平方阶的计算操作数量 = " + count);
+var nums = new Array(n);
+for (var i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
+count = bubbleSort(nums);
+console.log("平方阶（冒泡排序）的计算操作数量 = " + count);
+
+count = exponential(n);
+console.log("指数阶（循环实现）的计算操作数量 = " + count);
+count = expRecur(n);
+console.log("指数阶（递归实现）的计算操作数量 = " + count);
+
+count = logarithmic(n);
+console.log("对数阶（循环实现）的计算操作数量 = " + count);
+count = logRecur(n);
+console.log("对数阶（递归实现）的计算操作数量 = " + count);
+
+count = linearLogRecur(n);
+console.log("线性对数阶（递归实现）的计算操作数量 = " + count);
+
+count = factorialRecur(n);
+console.log("阶乘阶（递归实现）的计算操作数量 = " + count);

From d3e15a88563713444b0a6ef3a5d745bd30165396 Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Mon, 2 Jan 2023 20:52:15 +0800
Subject: [PATCH 068/158] lint: var to let

---
 .../time_complexity.js                        |  42 ++---
 .../time_complexity.ts                        | 154 ++++++++++++++++++
 2 files changed, 175 insertions(+), 21 deletions(-)

diff --git a/codes/javascript/chapter_computational_complexity/time_complexity.js b/codes/javascript/chapter_computational_complexity/time_complexity.js
index b1a9eb7c5..d044f22f0 100644
--- a/codes/javascript/chapter_computational_complexity/time_complexity.js
+++ b/codes/javascript/chapter_computational_complexity/time_complexity.js
@@ -6,24 +6,24 @@
 
 /* 常数阶 */
 function constant(n) {
-	var count = 0;
+	let count = 0;
 	const size = 100000;
-	for (var i = 0; i < size; i++) count++;
+	for (let i = 0; i < size; i++) count++;
 	return count;
 }
 
 /* 线性阶 */
 function linear(n) {
-	var count = 0;
-	for (var i = 0; i < n; i++) count++;
+	let count = 0;
+	for (let i = 0; i < n; i++) count++;
 	return count;
 }
 
 /* 线性阶（遍历数组） */
 function arrayTraversal(nums) {
-	var count = 0;
+	let count = 0;
 	// 循环次数与数组长度成正比
-	for (var i = 0; i < nums.length; i++) {
+	for (let i = 0; i < nums.length; i++) {
 		count++;
 	}
 	return count;
@@ -31,9 +31,9 @@ function arrayTraversal(nums) {
 
 /* 平方阶 */
 function quadratic(n) {
-	var count = 0;
+	let count = 0;
 	// 循环次数与数组长度成平方关系
-	for (var i = 0; i < n; i++) {
+	for (let i = 0; i < n; i++) {
 		for (let j = 0; j < n; j++) {
 			count++;
 		}
@@ -43,9 +43,9 @@ function quadratic(n) {
 
 /* 平方阶（冒泡排序） */
 function bubbleSort(nums) {
-	var count = 0; // 计数器
+	let count = 0; // 计数器
 	// 外循环：待排序元素数量为 n-1, n-2, ..., 1
-	for (var i = nums.length - 1; i > 0; i--) {
+	for (let i = nums.length - 1; i > 0; i--) {
 		// 内循环：冒泡操作
 		for (let j = 0; j < i; j++) {
 			if (nums[j] > nums[j + 1]) {
@@ -62,10 +62,10 @@ function bubbleSort(nums) {
 
 /* 指数阶（循环实现） */
 function exponential(n) {
-	var count = 0,
+	let count = 0,
 		base = 1;
 	// cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
-	for (var i = 0; i < n; i++) {
+	for (let i = 0; i < n; i++) {
 		for (let j = 0; j < base; j++) {
 			count++;
 		}
@@ -83,7 +83,7 @@ function expRecur(n) {
 
 /* 对数阶（循环实现） */
 function logarithmic(n) {
-	var count = 0;
+	let count = 0;
 	while (n > 1) {
 		n = n / 2;
 		count++;
@@ -100,8 +100,8 @@ function logRecur(n) {
 /* 线性对数阶 */
 function linearLogRecur(n) {
 	if (n <= 1) return 1;
-	var count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
-	for (var i = 0; i < n; i++) {
+	let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
+	for (let i = 0; i < n; i++) {
 		count++;
 	}
 	return count;
@@ -110,18 +110,18 @@ function linearLogRecur(n) {
 /* 阶乘阶（递归实现） */
 function factorialRecur(n) {
 	if (n == 0) return 1;
-	var count = 0;
+	let count = 0;
 	// 从 1 个分裂出 n 个
-	for (var i = 0; i < n; i++) {
+	for (let i = 0; i < n; i++) {
 		count += factorialRecur(n - 1);
 	}
 	return count;
 }
 
-var n = 8;
+let n = 8;
 console.log("输入数据大小 n = " + n);
 
-var count = constant(n);
+let count = constant(n);
 console.log("常数阶的计算操作数量 = " + count);
 
 count = linear(n);
@@ -131,8 +131,8 @@ console.log("线性阶（遍历数组）的计算操作数量 = " + count);
 
 count = quadratic(n);
 console.log("平方阶的计算操作数量 = " + count);
-var nums = new Array(n);
-for (var i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
+let nums = new Array(n);
+for (let i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
 count = bubbleSort(nums);
 console.log("平方阶（冒泡排序）的计算操作数量 = " + count);
 
diff --git a/codes/typescript/chapter_computational_complexity/time_complexity.ts b/codes/typescript/chapter_computational_complexity/time_complexity.ts
index 9c877602f..f722a1117 100644
--- a/codes/typescript/chapter_computational_complexity/time_complexity.ts
+++ b/codes/typescript/chapter_computational_complexity/time_complexity.ts
@@ -3,3 +3,157 @@
  * Created Time: 2023-01-02
  * Author: RiverTwilight (contact@rene.wang)
  */
+
+/**
+ * File: time_complexity.js
+ * Created Time: 2023-01-02
+ * Author: RiverTwilight (contact@rene.wang)
+ */
+
+/* 常数阶 */
+function constant(n: number): number {
+	let count = 0;
+	const size = 100000;
+	for (let i = 0; i < size; i++) count++;
+	return count;
+}
+
+/* 线性阶 */
+function linear(n: number): number {
+	let count = 0;
+	for (let i = 0; i < n; i++) count++;
+	return count;
+}
+
+/* 线性阶（遍历数组） */
+function arrayTraversal(nums) {
+	let count = 0;
+	// 循环次数与数组长度成正比
+	for (let i = 0; i < nums.length; i++) {
+		count++;
+	}
+	return count;
+}
+
+/* 平方阶 */
+function quadratic(n: number): number {
+	let count = 0;
+	// 循环次数与数组长度成平方关系
+	for (let i = 0; i < n; i++) {
+		for (let j = 0; j < n; j++) {
+			count++;
+		}
+	}
+	return count;
+}
+
+/* 平方阶（冒泡排序） */
+function bubbleSort(nums: number[]): number {
+	let count = 0; // 计数器
+	// 外循环：待排序元素数量为 n-1, n-2, ..., 1
+	for (let i = nums.length - 1; i > 0; i--) {
+		// 内循环：冒泡操作
+		for (let j = 0; j < i; j++) {
+			if (nums[j] > nums[j + 1]) {
+				// 交换 nums[j] 与 nums[j + 1]
+				let tmp = nums[j];
+				nums[j] = nums[j + 1];
+				nums[j + 1] = tmp;
+				count += 3; // 元素交换包含 3 个单元操作
+			}
+		}
+	}
+	return count;
+}
+
+/* 指数阶（循环实现） */
+function exponential(n: number): number {
+	let count = 0,
+		base = 1;
+	// cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+	for (let i = 0; i < n; i++) {
+		for (let j = 0; j < base; j++) {
+			count++;
+		}
+		base *= 2;
+	}
+	// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+	return count;
+}
+
+/* 指数阶（递归实现） */
+function expRecur(n: number): number {
+	if (n == 1) return 1;
+	return expRecur(n - 1) + expRecur(n - 1) + 1;
+}
+
+/* 对数阶（循环实现） */
+function logarithmic(n: number): number {
+	let count = 0;
+	while (n > 1) {
+		n = n / 2;
+		count++;
+	}
+	return count;
+}
+
+/* 对数阶（递归实现） */
+function logRecur(n: number): number {
+	if (n <= 1) return 0;
+	return logRecur(n / 2) + 1;
+}
+
+/* 线性对数阶 */
+function linearLogRecur(n: number): number {
+	if (n <= 1) return 1;
+	let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
+	for (let i = 0; i < n; i++) {
+		count++;
+	}
+	return count;
+}
+
+/* 阶乘阶（递归实现） */
+function factorialRecur(n: number): number {
+	if (n == 0) return 1;
+	let count = 0;
+	// 从 1 个分裂出 n 个
+	for (let i = 0; i < n; i++) {
+		count += factorialRecur(n - 1);
+	}
+	return count;
+}
+
+var n: number = 8;
+console.log("输入数据大小 n = " + n);
+
+let count = constant(n);
+console.log("常数阶的计算操作数量 = " + count);
+
+count = linear(n);
+console.log("线性阶的计算操作数量 = " + count);
+count = arrayTraversal(new Array(n));
+console.log("线性阶（遍历数组）的计算操作数量 = " + count);
+
+count = quadratic(n);
+console.log("平方阶的计算操作数量 = " + count);
+var nums = new Array(n);
+for (let i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
+count = bubbleSort(nums);
+console.log("平方阶（冒泡排序）的计算操作数量 = " + count);
+
+count = exponential(n);
+console.log("指数阶（循环实现）的计算操作数量 = " + count);
+count = expRecur(n);
+console.log("指数阶（递归实现）的计算操作数量 = " + count);
+
+count = logarithmic(n);
+console.log("对数阶（循环实现）的计算操作数量 = " + count);
+count = logRecur(n);
+console.log("对数阶（递归实现）的计算操作数量 = " + count);
+
+count = linearLogRecur(n);
+console.log("线性对数阶（递归实现）的计算操作数量 = " + count);
+
+count = factorialRecur(n);
+console.log("阶乘阶（递归实现）的计算操作数量 = " + count);

From 621fcb731c3bc833f0de095e3dc67b7fe98bd6a3 Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Mon, 2 Jan 2023 21:01:16 +0800
Subject: [PATCH 069/158] lint: switch indent type

---
 .../time_complexity.js                             |  2 +-
 .../time_complexity.ts                             | 14 ++++----------
 2 files changed, 5 insertions(+), 11 deletions(-)

diff --git a/codes/javascript/chapter_computational_complexity/time_complexity.js b/codes/javascript/chapter_computational_complexity/time_complexity.js
index d044f22f0..4cd6705bf 100644
--- a/codes/javascript/chapter_computational_complexity/time_complexity.js
+++ b/codes/javascript/chapter_computational_complexity/time_complexity.js
@@ -118,7 +118,7 @@ function factorialRecur(n) {
 	return count;
 }
 
-let n = 8;
+const n = 8;
 console.log("输入数据大小 n = " + n);
 
 let count = constant(n);
diff --git a/codes/typescript/chapter_computational_complexity/time_complexity.ts b/codes/typescript/chapter_computational_complexity/time_complexity.ts
index f722a1117..0b1b5be4c 100644
--- a/codes/typescript/chapter_computational_complexity/time_complexity.ts
+++ b/codes/typescript/chapter_computational_complexity/time_complexity.ts
@@ -1,11 +1,5 @@
 /**
- * File: time_complexity.js
- * Created Time: 2023-01-02
- * Author: RiverTwilight (contact@rene.wang)
- */
-
-/**
- * File: time_complexity.js
+ * File: time_complexity.ts
  * Created Time: 2023-01-02
  * Author: RiverTwilight (contact@rene.wang)
  */
@@ -26,7 +20,7 @@ function linear(n: number): number {
 }
 
 /* 线性阶（遍历数组） */
-function arrayTraversal(nums) {
+function arrayTraversal(nums: number[]) {
 	let count = 0;
 	// 循环次数与数组长度成正比
 	for (let i = 0; i < nums.length; i++) {
@@ -124,10 +118,10 @@ function factorialRecur(n: number): number {
 	return count;
 }
 
-var n: number = 8;
+var n = 8;
 console.log("输入数据大小 n = " + n);
 
-let count = constant(n);
+var count = constant(n);
 console.log("常数阶的计算操作数量 = " + count);
 
 count = linear(n);

From 63cd3e4f65117235461437df3f02604cf93aadc5 Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Mon, 2 Jan 2023 21:16:24 +0800
Subject: [PATCH 070/158] lint: added prettier config and switch indent type

---
 .prettierrc                                   |   4 +
 .../time_complexity.js                        | 140 +++++++++---------
 .../time_complexity.ts                        | 140 +++++++++---------
 3 files changed, 144 insertions(+), 140 deletions(-)
 create mode 100644 .prettierrc

diff --git a/.prettierrc b/.prettierrc
new file mode 100644
index 000000000..5a938ce18
--- /dev/null
+++ b/.prettierrc
@@ -0,0 +1,4 @@
+{
+  "tabWidth": 4,
+  "useTabs": false
+}
diff --git a/codes/javascript/chapter_computational_complexity/time_complexity.js b/codes/javascript/chapter_computational_complexity/time_complexity.js
index 4cd6705bf..c8809caa0 100644
--- a/codes/javascript/chapter_computational_complexity/time_complexity.js
+++ b/codes/javascript/chapter_computational_complexity/time_complexity.js
@@ -6,116 +6,116 @@
 
 /* 常数阶 */
 function constant(n) {
-	let count = 0;
-	const size = 100000;
-	for (let i = 0; i < size; i++) count++;
-	return count;
+    let count = 0;
+    const size = 100000;
+    for (let i = 0; i < size; i++) count++;
+    return count;
 }
 
 /* 线性阶 */
 function linear(n) {
-	let count = 0;
-	for (let i = 0; i < n; i++) count++;
-	return count;
+    let count = 0;
+    for (let i = 0; i < n; i++) count++;
+    return count;
 }
 
 /* 线性阶（遍历数组） */
 function arrayTraversal(nums) {
-	let count = 0;
-	// 循环次数与数组长度成正比
-	for (let i = 0; i < nums.length; i++) {
-		count++;
-	}
-	return count;
+    let count = 0;
+    // 循环次数与数组长度成正比
+    for (let i = 0; i < nums.length; i++) {
+        count++;
+    }
+    return count;
 }
 
 /* 平方阶 */
 function quadratic(n) {
-	let count = 0;
-	// 循环次数与数组长度成平方关系
-	for (let i = 0; i < n; i++) {
-		for (let j = 0; j < n; j++) {
-			count++;
-		}
-	}
-	return count;
+    let count = 0;
+    // 循环次数与数组长度成平方关系
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+            count++;
+        }
+    }
+    return count;
 }
 
 /* 平方阶（冒泡排序） */
 function bubbleSort(nums) {
-	let count = 0; // 计数器
-	// 外循环：待排序元素数量为 n-1, n-2, ..., 1
-	for (let i = nums.length - 1; i > 0; i--) {
-		// 内循环：冒泡操作
-		for (let j = 0; j < i; j++) {
-			if (nums[j] > nums[j + 1]) {
-				// 交换 nums[j] 与 nums[j + 1]
-				let tmp = nums[j];
-				nums[j] = nums[j + 1];
-				nums[j + 1] = tmp;
-				count += 3; // 元素交换包含 3 个单元操作
-			}
-		}
-	}
-	return count;
+    let count = 0; // 计数器
+    // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+    for (let i = nums.length - 1; i > 0; i--) {
+        // 内循环：冒泡操作
+        for (let j = 0; j < i; j++) {
+            if (nums[j] > nums[j + 1]) {
+                // 交换 nums[j] 与 nums[j + 1]
+                let tmp = nums[j];
+                nums[j] = nums[j + 1];
+                nums[j + 1] = tmp;
+                count += 3; // 元素交换包含 3 个单元操作
+            }
+        }
+    }
+    return count;
 }
 
 /* 指数阶（循环实现） */
 function exponential(n) {
-	let count = 0,
-		base = 1;
-	// cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
-	for (let i = 0; i < n; i++) {
-		for (let j = 0; j < base; j++) {
-			count++;
-		}
-		base *= 2;
-	}
-	// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
-	return count;
+    let count = 0,
+        base = 1;
+    // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < base; j++) {
+            count++;
+        }
+        base *= 2;
+    }
+    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+    return count;
 }
 
 /* 指数阶（递归实现） */
 function expRecur(n) {
-	if (n == 1) return 1;
-	return expRecur(n - 1) + expRecur(n - 1) + 1;
+    if (n == 1) return 1;
+    return expRecur(n - 1) + expRecur(n - 1) + 1;
 }
 
 /* 对数阶（循环实现） */
 function logarithmic(n) {
-	let count = 0;
-	while (n > 1) {
-		n = n / 2;
-		count++;
-	}
-	return count;
+    let count = 0;
+    while (n > 1) {
+        n = n / 2;
+        count++;
+    }
+    return count;
 }
 
 /* 对数阶（递归实现） */
 function logRecur(n) {
-	if (n <= 1) return 0;
-	return logRecur(n / 2) + 1;
+    if (n <= 1) return 0;
+    return logRecur(n / 2) + 1;
 }
 
 /* 线性对数阶 */
 function linearLogRecur(n) {
-	if (n <= 1) return 1;
-	let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
-	for (let i = 0; i < n; i++) {
-		count++;
-	}
-	return count;
+    if (n <= 1) return 1;
+    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
+    for (let i = 0; i < n; i++) {
+        count++;
+    }
+    return count;
 }
 
 /* 阶乘阶（递归实现） */
 function factorialRecur(n) {
-	if (n == 0) return 1;
-	let count = 0;
-	// 从 1 个分裂出 n 个
-	for (let i = 0; i < n; i++) {
-		count += factorialRecur(n - 1);
-	}
-	return count;
+    if (n == 0) return 1;
+    let count = 0;
+    // 从 1 个分裂出 n 个
+    for (let i = 0; i < n; i++) {
+        count += factorialRecur(n - 1);
+    }
+    return count;
 }
 
 const n = 8;
diff --git a/codes/typescript/chapter_computational_complexity/time_complexity.ts b/codes/typescript/chapter_computational_complexity/time_complexity.ts
index 0b1b5be4c..900585c81 100644
--- a/codes/typescript/chapter_computational_complexity/time_complexity.ts
+++ b/codes/typescript/chapter_computational_complexity/time_complexity.ts
@@ -6,116 +6,116 @@
 
 /* 常数阶 */
 function constant(n: number): number {
-	let count = 0;
-	const size = 100000;
-	for (let i = 0; i < size; i++) count++;
-	return count;
+    let count = 0;
+    const size = 100000;
+    for (let i = 0; i < size; i++) count++;
+    return count;
 }
 
 /* 线性阶 */
 function linear(n: number): number {
-	let count = 0;
-	for (let i = 0; i < n; i++) count++;
-	return count;
+    let count = 0;
+    for (let i = 0; i < n; i++) count++;
+    return count;
 }
 
 /* 线性阶（遍历数组） */
 function arrayTraversal(nums: number[]) {
-	let count = 0;
-	// 循环次数与数组长度成正比
-	for (let i = 0; i < nums.length; i++) {
-		count++;
-	}
-	return count;
+    let count = 0;
+    // 循环次数与数组长度成正比
+    for (let i = 0; i < nums.length; i++) {
+        count++;
+    }
+    return count;
 }
 
 /* 平方阶 */
 function quadratic(n: number): number {
-	let count = 0;
-	// 循环次数与数组长度成平方关系
-	for (let i = 0; i < n; i++) {
-		for (let j = 0; j < n; j++) {
-			count++;
-		}
-	}
-	return count;
+    let count = 0;
+    // 循环次数与数组长度成平方关系
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+            count++;
+        }
+    }
+    return count;
 }
 
 /* 平方阶（冒泡排序） */
 function bubbleSort(nums: number[]): number {
-	let count = 0; // 计数器
-	// 外循环：待排序元素数量为 n-1, n-2, ..., 1
-	for (let i = nums.length - 1; i > 0; i--) {
-		// 内循环：冒泡操作
-		for (let j = 0; j < i; j++) {
-			if (nums[j] > nums[j + 1]) {
-				// 交换 nums[j] 与 nums[j + 1]
-				let tmp = nums[j];
-				nums[j] = nums[j + 1];
-				nums[j + 1] = tmp;
-				count += 3; // 元素交换包含 3 个单元操作
-			}
-		}
-	}
-	return count;
+    let count = 0; // 计数器
+    // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+    for (let i = nums.length - 1; i > 0; i--) {
+        // 内循环：冒泡操作
+        for (let j = 0; j < i; j++) {
+            if (nums[j] > nums[j + 1]) {
+                // 交换 nums[j] 与 nums[j + 1]
+                let tmp = nums[j];
+                nums[j] = nums[j + 1];
+                nums[j + 1] = tmp;
+                count += 3; // 元素交换包含 3 个单元操作
+            }
+        }
+    }
+    return count;
 }
 
 /* 指数阶（循环实现） */
 function exponential(n: number): number {
-	let count = 0,
-		base = 1;
-	// cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
-	for (let i = 0; i < n; i++) {
-		for (let j = 0; j < base; j++) {
-			count++;
-		}
-		base *= 2;
-	}
-	// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
-	return count;
+    let count = 0,
+        base = 1;
+    // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < base; j++) {
+            count++;
+        }
+        base *= 2;
+    }
+    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+    return count;
 }
 
 /* 指数阶（递归实现） */
 function expRecur(n: number): number {
-	if (n == 1) return 1;
-	return expRecur(n - 1) + expRecur(n - 1) + 1;
+    if (n == 1) return 1;
+    return expRecur(n - 1) + expRecur(n - 1) + 1;
 }
 
 /* 对数阶（循环实现） */
 function logarithmic(n: number): number {
-	let count = 0;
-	while (n > 1) {
-		n = n / 2;
-		count++;
-	}
-	return count;
+    let count = 0;
+    while (n > 1) {
+        n = n / 2;
+        count++;
+    }
+    return count;
 }
 
 /* 对数阶（递归实现） */
 function logRecur(n: number): number {
-	if (n <= 1) return 0;
-	return logRecur(n / 2) + 1;
+    if (n <= 1) return 0;
+    return logRecur(n / 2) + 1;
 }
 
 /* 线性对数阶 */
 function linearLogRecur(n: number): number {
-	if (n <= 1) return 1;
-	let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
-	for (let i = 0; i < n; i++) {
-		count++;
-	}
-	return count;
+    if (n <= 1) return 1;
+    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
+    for (let i = 0; i < n; i++) {
+        count++;
+    }
+    return count;
 }
 
 /* 阶乘阶（递归实现） */
 function factorialRecur(n: number): number {
-	if (n == 0) return 1;
-	let count = 0;
-	// 从 1 个分裂出 n 个
-	for (let i = 0; i < n; i++) {
-		count += factorialRecur(n - 1);
-	}
-	return count;
+    if (n == 0) return 1;
+    let count = 0;
+    // 从 1 个分裂出 n 个
+    for (let i = 0; i < n; i++) {
+        count += factorialRecur(n - 1);
+    }
+    return count;
 }
 
 var n = 8;

From 6e8954672f52fa3a0fb801868212905e5dfc9d41 Mon Sep 17 00:00:00 2001
From: nuomi1 <nuomi1@qq.com>
Date: Mon, 2 Jan 2023 21:40:19 +0800
Subject: [PATCH 071/158] feat: add .gitignore file for Swift

---
 codes/swift/.gitignore | 130 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 130 insertions(+)
 create mode 100644 codes/swift/.gitignore

diff --git a/codes/swift/.gitignore b/codes/swift/.gitignore
new file mode 100644
index 000000000..6295af4cc
--- /dev/null
+++ b/codes/swift/.gitignore
@@ -0,0 +1,130 @@
+# Created by https://www.toptal.com/developers/gitignore/api/objective-c,swift,swiftpackagemanager
+# Edit at https://www.toptal.com/developers/gitignore?templates=objective-c,swift,swiftpackagemanager
+
+### Objective-C ###
+# Xcode
+#
+# gitignore contributors: remember to update Global/Xcode.gitignore, Objective-C.gitignore & Swift.gitignore
+
+## User settings
+xcuserdata/
+
+## compatibility with Xcode 8 and earlier (ignoring not required starting Xcode 9)
+*.xcscmblueprint
+*.xccheckout
+
+## compatibility with Xcode 3 and earlier (ignoring not required starting Xcode 4)
+build/
+DerivedData/
+*.moved-aside
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+
+## Obj-C/Swift specific
+*.hmap
+
+## App packaging
+*.ipa
+*.dSYM.zip
+*.dSYM
+
+# CocoaPods
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+# Pods/
+# Add this line if you want to avoid checking in source code from the Xcode workspace
+# *.xcworkspace
+
+# Carthage
+# Add this line if you want to avoid checking in source code from Carthage dependencies.
+# Carthage/Checkouts
+
+Carthage/Build/
+
+# fastlane
+# It is recommended to not store the screenshots in the git repo.
+# Instead, use fastlane to re-generate the screenshots whenever they are needed.
+# For more information about the recommended setup visit:
+# https://docs.fastlane.tools/best-practices/source-control/#source-control
+
+fastlane/report.xml
+fastlane/Preview.html
+fastlane/screenshots/**/*.png
+fastlane/test_output
+
+# Code Injection
+# After new code Injection tools there's a generated folder /iOSInjectionProject
+# https://github.com/johnno1962/injectionforxcode
+
+iOSInjectionProject/
+
+### Objective-C Patch ###
+
+### Swift ###
+# Xcode
+# gitignore contributors: remember to update Global/Xcode.gitignore, Objective-C.gitignore & Swift.gitignore
+
+
+
+
+
+
+## Playgrounds
+timeline.xctimeline
+playground.xcworkspace
+
+# Swift Package Manager
+# Add this line if you want to avoid checking in source code from Swift Package Manager dependencies.
+# Packages/
+# Package.pins
+# Package.resolved
+# *.xcodeproj
+# Xcode automatically generates this directory with a .xcworkspacedata file and xcuserdata
+# hence it is not needed unless you have added a package configuration file to your project
+# .swiftpm
+
+.build/
+
+# CocoaPods
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+# Pods/
+# Add this line if you want to avoid checking in source code from the Xcode workspace
+# *.xcworkspace
+
+# Carthage
+# Add this line if you want to avoid checking in source code from Carthage dependencies.
+# Carthage/Checkouts
+
+
+# Accio dependency management
+Dependencies/
+.accio/
+
+# fastlane
+# It is recommended to not store the screenshots in the git repo.
+# Instead, use fastlane to re-generate the screenshots whenever they are needed.
+# For more information about the recommended setup visit:
+# https://docs.fastlane.tools/best-practices/source-control/#source-control
+
+
+# Code Injection
+# After new code Injection tools there's a generated folder /iOSInjectionProject
+# https://github.com/johnno1962/injectionforxcode
+
+
+### SwiftPackageManager ###
+Packages
+xcuserdata
+*.xcodeproj
+
+
+# End of https://www.toptal.com/developers/gitignore/api/objective-c,swift,swiftpackagemanager

From 2890771d93266832c4a1341a25ed6b1b6878336e Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Mon, 2 Jan 2023 21:52:40 +0800
Subject: [PATCH 072/158] Update stack.md

---
 docs/chapter_stack_and_queue/stack.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index 7e35fddbd..c982f5a75 100644
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -6,7 +6,9 @@ comments: true
 
 「栈 Stack」是一种遵循「先入后出 first in, last out」数据操作规则的线性数据结构。我们可以将栈类比为放在桌面上的一摞盘子，如果需要拿出底部的盘子，则需要先将上面的盘子依次取出。
 
-我们将顶部盘子称为「栈顶」，底部盘子称为「栈底」，将把元素添加到栈顶的操作称为「入栈」，将删除栈顶元素的操作称为「出栈」。
+“盘子”是一种形象比喻，我们将盘子替换为任意一种元素（例如整数、字符、对象等），就得到了栈数据结构。
+
+我们将这一摞元素的顶部称为「栈顶」，将底部称为「栈底」，将把元素添加到栈顶的操作称为「入栈」，将删除栈顶元素的操作称为「出栈」。
 
 ![stack_operations](stack.assets/stack_operations.png)
 

From 92c8d34f13ad2b6e1359b41f27d2a5c31ae6a3ff Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Mon, 2 Jan 2023 21:53:21 +0800
Subject: [PATCH 073/158] lint: remove extra indent

---
 .../time_complexity.md                                 | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 2ba703457..bd7cb119b 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -148,9 +148,9 @@ $$
 
 “时间增长趋势”这个概念比较抽象，我们借助一个例子来理解。设输入数据大小为 $n$ ，给定三个算法 `A` , `B` , `C` 。
 
--   算法 `A` 只有 $1$ 个打印操作，算法运行时间不随着 $n$ 增大而增长。我们称此算法的时间复杂度为「常数阶」。
--   算法 `B` 中的打印操作需要循环 $n$ 次，算法运行时间随着 $n$ 增大成线性增长。此算法的时间复杂度被称为「线性阶」。
--   算法 `C` 中的打印操作需要循环 $1000000$ 次，但运行时间仍与输入数据大小 $n$ 无关。因此 `C` 的时间复杂度和 `A` 相同，仍为「常数阶」。
+- 算法 `A` 只有 $1$ 个打印操作，算法运行时间不随着 $n$ 增大而增长。我们称此算法的时间复杂度为「常数阶」。
+- 算法 `B` 中的打印操作需要循环 $n$ 次，算法运行时间随着 $n$ 增大成线性增长。此算法的时间复杂度被称为「线性阶」。
+- 算法 `C` 中的打印操作需要循环 $1000000$ 次，但运行时间仍与输入数据大小 $n$ 无关。因此 `C` 的时间复杂度和 `A` 相同，仍为「常数阶」。
 
 === "Java"
 
@@ -1983,8 +1983,8 @@ $$
 
 **某些算法的时间复杂度不是恒定的，而是与输入数据的分布有关。** 举一个例子，输入一个长度为 $n$ 数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的；算法的任务是返回元素 $1$ 的索引。我们可以得出以下结论：
 
--   当 `nums = [?, ?, ..., 1]`，即当末尾元素是 $1$ 时，则需完整遍历数组，此时达到 **最差时间复杂度 $O(n)$** ；
--   当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，此时达到 **最佳时间复杂度 $\Omega(1)$** ；
+- 当 `nums = [?, ?, ..., 1]`，即当末尾元素是 $1$ 时，则需完整遍历数组，此时达到 **最差时间复杂度 $O(n)$** ；
+- 当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，此时达到 **最佳时间复杂度 $\Omega(1)$** ；
 
 「函数渐近上界」使用大 $O$ 记号表示，代表「最差时间复杂度」。与之对应，「函数渐近下界」用 $\Omega$ 记号（Omega Notation）来表示，代表「最佳时间复杂度」。
 

From 23b4aa118b413d72dfdbeeeaa766ee2795e84717 Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Mon, 2 Jan 2023 22:07:48 +0800
Subject: [PATCH 074/158] code: added scripts to the doc

---
 .../time_complexity.md                        | 229 ++++++++++++++++--
 1 file changed, 205 insertions(+), 24 deletions(-)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index bd7cb119b..4328dc6b3 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -416,7 +416,6 @@ $$
         }
 
     }
-
     ```
 
 === "TypeScript"
@@ -432,7 +431,6 @@ $$
         }
 
     }
-
     ```
 
 === "C"
@@ -609,7 +607,6 @@ $$
             }
         }
     }
-
     ```
 
 === "TypeScript"
@@ -629,7 +626,6 @@ $$
             }
         }
     }
-
     ```
 
 === "C"
@@ -778,13 +774,24 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 常数阶 */
+    function constant(n) {
+        let count = 0;
+        const size = 100000;
+        for (let i = 0; i < size; i++) count++;
+        return count;
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    function constant(n: number): number {
+        let count = 0;
+        const size = 100000;
+        for (let i = 0; i < size; i++) count++;
+        return count;
+    }
     ```
 
 === "C"
@@ -876,13 +883,23 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 线性阶 */
+    function linear(n) {
+        let count = 0;
+        for (let i = 0; i < n; i++) count++;
+        return count;
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 线性阶 */
+    function linear(n: number): number {
+        let count = 0;
+        for (let i = 0; i < n; i++) count++;
+        return count;
+    }
     ```
 
 === "C"
@@ -980,13 +997,29 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 线性阶（遍历数组） */
+    function arrayTraversal(nums) {
+        let count = 0;
+        // 循环次数与数组长度成正比
+        for (let i = 0; i < nums.length; i++) {
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 线性阶（遍历数组） */
+    function arrayTraversal(nums: number[]) {
+        let count = 0;
+        // 循环次数与数组长度成正比
+        for (let i = 0; i < nums.length; i++) {
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "C"
@@ -1093,13 +1126,33 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 平方阶 */
+    function quadratic(n) {
+        let count = 0;
+        // 循环次数与数组长度成平方关系
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j < n; j++) {
+                count++;
+            }
+        }
+        return count;
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 平方阶 */
+    function quadratic(n: number): number {
+        let count = 0;
+        // 循环次数与数组长度成平方关系
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j < n; j++) {
+                count++;
+            }
+        }
+        return count;
+    }
     ```
 
 === "C"
@@ -1244,13 +1297,47 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 平方阶（冒泡排序） */
+    function bubbleSort(nums) {
+        let count = 0; // 计数器
+        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        for (let i = nums.length - 1; i > 0; i--) {
+            // 内循环：冒泡操作
+            for (let j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    count += 3; // 元素交换包含 3 个单元操作
+                }
+            }
+        }
+        return count;
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 平方阶（冒泡排序） */
+    function bubbleSort(nums: number[]): number {
+        let count = 0; // 计数器
+        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        for (let i = nums.length - 1; i > 0; i--) {
+            // 内循环：冒泡操作
+            for (let j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    count += 3; // 元素交换包含 3 个单元操作
+                }
+            }
+        }
+        return count;
+    }
     ```
 
 === "C"
@@ -1390,13 +1477,40 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
+    /* 指数阶（循环实现） */
+    function exponential(n) {
+        let count = 0,
+            base = 1;
+        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j < base; j++) {
+                count++;
+            }
+            base *= 2;
+        }
+        // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+        return count;
+    }
 
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 指数阶（循环实现） */
+    function exponential(n: number): number {
+        let count = 0,
+            base = 1;
+        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j < base; j++) {
+                count++;
+            }
+            base *= 2;
+        }
+        // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+        return count;
+    }
     ```
 
 === "C"
@@ -1495,12 +1609,21 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 指数阶（递归实现） */
+    function expRecur(n) {
+        if (n == 1) return 1;
+        return expRecur(n - 1) + expRecur(n - 1) + 1;
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
+    /* 指数阶（递归实现） */
+    function expRecur(n: number): number {
+        if (n == 1) return 1;
+        return expRecur(n - 1) + expRecur(n - 1) + 1;
+    }
 
     ```
 
@@ -1598,13 +1721,29 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 对数阶（循环实现） */
+    function logarithmic(n) {
+        let count = 0;
+        while (n > 1) {
+            n = n / 2;
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 对数阶（循环实现） */
+    function logarithmic(n: number): number {
+        let count = 0;
+        while (n > 1) {
+            n = n / 2;
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "C"
@@ -1694,13 +1833,21 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 对数阶（递归实现） */
+    function logRecur(n) {
+        if (n <= 1) return 0;
+        return logRecur(n / 2) + 1;
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 对数阶（递归实现） */
+    function logRecur(n: number): number {
+        if (n <= 1) return 0;
+        return logRecur(n / 2) + 1;
+    }
     ```
 
 === "C"
@@ -1801,13 +1948,29 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 线性对数阶 */
+    function linearLogRecur(n) {
+        if (n <= 1) return 1;
+        let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
+        for (let i = 0; i < n; i++) {
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 线性对数阶 */
+    function linearLogRecur(n: number): number {
+        if (n <= 1) return 1;
+        let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
+        for (let i = 0; i < n; i++) {
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "C"
@@ -1926,13 +2089,31 @@ $$
 === "JavaScript"
 
     ```js title="time_complexity.js"
-
+    /* 阶乘阶（递归实现） */
+    function factorialRecur(n) {
+        if (n == 0) return 1;
+        let count = 0;
+        // 从 1 个分裂出 n 个
+        for (let i = 0; i < n; i++) {
+            count += factorialRecur(n - 1);
+        }
+        return count;
+    }
     ```
 
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
-
+    /* 阶乘阶（递归实现） */
+    function factorialRecur(n: number): number {
+        if (n == 0) return 1;
+        let count = 0;
+        // 从 1 个分裂出 n 个
+        for (let i = 0; i < n; i++) {
+            count += factorialRecur(n - 1);
+        }
+        return count;
+    }
     ```
 
 === "C"

From e850152130e89e66bc34621610797c2b0f0e7702 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Tue, 3 Jan 2023 03:40:01 +0800
Subject: [PATCH 075/158] Update the rotation cases of the AVL tree.

---
 .../avl_tree.assets/left_rotate.png           | Bin 0 -> 78956 bytes
 .../left_rotate_with_grandchild.png           | Bin 88169 -> 92532 bytes
 .../avl_tree.assets/right_rotate_step2.png    | Bin 56856 -> 56463 bytes
 .../avl_tree.assets/right_rotate_step3.png    | Bin 60764 -> 61266 bytes
 .../avl_tree.assets/right_rotate_step4.png    | Bin 68870 -> 72098 bytes
 .../right_rotate_with_grandchild.png          | Bin 91488 -> 93429 bytes
 docs/chapter_tree/avl_tree.md                 |  26 ++++++++++--------
 7 files changed, 15 insertions(+), 11 deletions(-)
 create mode 100644 docs/chapter_tree/avl_tree.assets/left_rotate.png

diff --git a/docs/chapter_tree/avl_tree.assets/left_rotate.png b/docs/chapter_tree/avl_tree.assets/left_rotate.png
new file mode 100644
index 0000000000000000000000000000000000000000..4c07196dce29db38cce0157cdde3bd4d7cb6b4f9
GIT binary patch
literal 78956
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
bEd8{2Kzd?tUJ0~T2e^E92JYZ{MxXpIRKj21

literal 0
HcmV?d00001

diff --git a/docs/chapter_tree/avl_tree.assets/left_rotate_with_grandchild.png b/docs/chapter_tree/avl_tree.assets/left_rotate_with_grandchild.png
index 8384696b4490d80bee9f2f529c7b16d193692967..949c5c20fabbc449dea5f2ff2958e86ca239e316 100644
GIT binary patch
literal 92532
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
Bdd~m=

literal 88169
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
C*!{}@

diff --git a/docs/chapter_tree/avl_tree.assets/right_rotate_step2.png b/docs/chapter_tree/avl_tree.assets/right_rotate_step2.png
index 108e2754b34ca8facf01a258a28d43545f6bdcc9..8cabc71212dbcfea85c4d9d1155c039532d5618b 100644
GIT binary patch
delta 28261
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
LOb%CQIb8TJK;6>~

delta 28657
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

diff --git a/docs/chapter_tree/avl_tree.assets/right_rotate_step3.png b/docs/chapter_tree/avl_tree.assets/right_rotate_step3.png
index 7d9c996f0d9281cae2496925a591b86cf6bc7961..8a13863553e61314b5b8219dd9993dfe5cc65455 100644
GIT binary patch
literal 61266
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
Ra~UuIfv2mV%Q~loCIH%HQVjqA

literal 60764
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%0Adt6m|)j(?46lGnuuD
z9oa?n=Y@4a_v6dx_W^v=5n4aH8Pj*T_X9E-JLk$1*(ECl^9DZ<M@8Jx(tZ6Azsx{u
z?nVWa_94+B>_fu6wyxXH6^_yR%)rf#fu__?W=rI7OtvmtIbH<|KiTmQ`M2bKyYlMC
z`&|UP(mG{YK<h+3u|<nBF!SA=%HysySrqo;B9aD)1vJ8>lKRvJ!+}(b#c@BGKI=vk
zpixReW$5i1HD?3HdY~d~asGe`GHkJnzu5Wx%k{I-wqlh~@hbOe%ni4SZuZ3q$9@6S
zZ$I9>O23xq>jkRVj#UV(RQZPgnHmei2{&Pa))WSd-NzW=`>2TOvhW)+wd2yDRrwRn
z>oFtr$I9>`Iq4CcMwMeUoaJLVhXnS7g#^0M^ECFlh-*W59Zb(~+3Y4+WtodTL_1u1
z#z${3>R;R&;v#MtSzsq_rzn*5%YE6J7kd434Nu+T+oOkMzTrl1&CUW&w;C^lsM8a}
zMo7#f_(f>LdHI`O;){`cdgO*VM%k5Q6CVf8$a76QWs<0>T$I{+(cO|6gjU|uH}B6+
z<m$1W?=+iUNxydTnSjq_lXKEKhT#QNu}rs`?#FDcOx+RE4dNzs8|(LN>Q<f~O*iuQ
zT^sgD>c;7F`n1N~e34EM-!-N+9ndsA8$`fwDcic8PoPrnYP_IfdNe0hAg2(+VjmQ_
z2Hr};BKK;(hF3oRh|n8n8&L%n7C_*SR^5T?2;IOb3>983z-{DXVHZ>`U3xi?hks*%
zlkt^fVze~A*|4&IF!7QKOR@~si1D-A1W4Yel}#8%FYYRrcaH3b#LK;8k<?*ep=CXm
z^X9qv^0vh4kQ9yK>kcua^gFT4x6JbnWeNAISy0NmSumQc^iL<?X0#jEm<4LT;m35;
zF2O?-+F>JK2Lp;N2p?dm!kc27Z)rVp?No4`e9D!YXKmF+IB3Eruu)PaxR=y#jQeEV
zsNQ5j?EGhk(9ERjl1cWFABLxI;bwKso%C(N_=4wm{gtmx_ejX}{tUBSj1JdpI0=+9
zC9Lv+TQpEA2p%s*N3X^9y&S%6nB30ShdHGB%U`U&1mRA>=B24r<`0z2C-&d6)$NbT
zY<QTl>bt2MuEBAHM<XTfQV)iN%dc&3P&Lc7cV^j)@jXobl%p}NY;OJn+*Cs*tVli>
zFjd|0g=7Zs3{V$6tj3g#ZVvozEs1P7)gpdh$pvFZMS+L1@m!1`_o<tPLQ=3BpXO{L
z>_c+-H}jia31}iKs)Ql9Rfnue#GVz~o8n!`o|O$a`Zh(h4d-8l1IcfbXW(WHb&pz4
ziwVv;qZr%?5nM0K*&a|^ge#s)K*fV0;p~%_3)dS@){BD#!io8}DVK+7eX<NGd~%H!
zHW}#R#)X2m{2qraH<0z2cGkM62%=71SkThzjE&1GV0<282JvwOaYy8Q>J~$k@H7^R
zMRM=L5#<e|xU<Mgidw>qB8}+Etfa1Q>g0F*F+X`y>5@1P_9}Dj_MDJCTBNcRhxpLn
zD4icN^vgDn&!{stP5Th%+!3)^(t}4L!c-j!r^+bqoa@%AQDegt?xa)=%I5_k4%2`|
z8yD$ta`u9gv>b=c@1t}|#WhCB1;@>b4me+$u2`@clP-z*0(jui{ac#kmh#R@imk*D
zd6f!Zp%SML83ezdI;qXCN^A^Nq7;+Y-qJr0d+js5p_kCDp2Q83pH}=C6wm#fd-eN6
zvg5Tho8uq}-<giD&S;3QcyQ75B-v@GjB>f3d-1lOdYrLCaL;-5utLuY`GE=!?|F9p
z&P+}j0e!r&Z1OJ@NDWY+vjaK1DAZXDa-R^+m21K6p<G3L_IwFjTUN|=c5H8w&Qh7)
z*shEAc)#VL2+|Z+Z?cX_+RRU^-Y^s<&C*=kG5(i~cTIDd>bGBT3w|^?Iy-hsc<fpe
zye2{EEB9a{LVPUWZH4_X&1C}BozwM)PF=p33i+oYN++se9rv=p-8_8Wz1$cDnPC+b
z7I?3{c#y95@$z_Y@Gz_;6;wl%)0iYiNEQx3mQHp<1(ljH=panVFgpiTRsz0=RF-v;
zH;e(mLZHt@Y&iD<ij$zMVg)%4Q{qp0zEeUALi>rGfc|>7@g6-jmav%z3k#;pY|lrd
zmQ8G3ZE^b$`7CoRI0RAY$p!?$?x!18w$zx?YmLymD>1|XQb3D|k;At4Sf;S5<(O#n
zSb5A-RVFZyv*qHZHS4MUa=ih&VJ|T%gjhZX)g%55YrwrJ_PbI2o@BST>7#-+$1RIX
zUt3SDi{Ec*8>~dCc)8o~O<;?b;2NFK{b!n^1W5sP#)QoMw|fY47Pc#QYw!A;?QFgi
zV^FI%lBSOD`LLFsLet8=_!T9=HX@qjnd}Gr)iqEfW`6SN_7dezZ;6-qSLR8)oFf#-
zjO(nI$0tq|2$tJYlqA_4sK1cGk3DjY8eeI)-*n}A5>fO%lIMJX7*VSuIv|?oskUoD
zrS{x>a*w?EgIbehGOIqJB)gA4=<*xbhB&mND{i@U@C}8_co7Zn$*b8i98HI-|7xKS
z`29F$v$pK`=#Jjdd_1un!(@Zr06T8OffG~E5C`3_>JJC)r7Y^msk%XDsfF$9Uk322
z85xH0K5!K~cbQ#E@7wixlw|F+KYcJ_yW7ng`B1eH73Z?Dyw*ufFu*KPv3K=&gGZHR
z5CYp?_{0=|QcE%r7-@N*UV3|yobFc8MPK^i7(MzB4rv<0i};oAikt;%7A|lRzbBm8
z^%0yq9vyJ~v;A)GQ*qp~U3KZ?<6hAkbK;WB;N|*j;zumROuupgJ*aec^js5uL$LIA
zSF;eAXX8#61_pYzDNa+XN8_e0FbPurdTE#VRCNEW`K{%ndyM+Ab}*qB=`Y4qve$Dq
zR;;l*VbZLJOQ-TPb6H3tkB!9|_n0tk3<04wD>&d2#N&5kCbJnO(>bP!GXla1`_OzB
z5<u>E6P5I#ayl`^c7p_On%Y-$pV8<I@;1%_*w(B4Fj@S_?)@)`Urz7)Dq6UWG9A7`
zVj;lCBOt_Y#8zM~xOM2bR|hCvzgjuMVW6UI1sgJ@P_l#4E^))m3YGS$k42eTQ|n)f
z78F?-A`=DpYjb=0iyBBEyGAXf#%v{|YM`41N`_sR*jYHBtcl_4VUR$^cH=S5N*CqV
z`v}_Izj^|o6YQk8a{$VY$*B-@4JVY!7-S4)6}v?z^AV=)n6rHS@LCf5;iaQI|5h_E
zQmxiOLSDADc|w<{#-eMt?!2VK_fTqqi3GSGYnSI<^+*aseece7*J{c_!$cv?L8~VG
z^XBc?L_7VWLL&6d8zDc$G4_H)@nd3}M`uxVN&@B1%Irg)Ts%GKQ=5X`QZ|6o8HjH?
z{><*OXSHjWD*ep~5>|jd^L2b)nFu3{hgimp7CidNvbMRVgia)@WWJv+#)R6&^BP}X
zFgBiDL*HChA~rrxUhvS6n2L<QR~Wg9mp%Taq8q+^<*)J$q85;hXaf@bsC*JD{04>@
zA1G%`y?|YG&h_#B@9zQ#I^|OEC}mE>TO~XQp>&GIv9*qC`(|)B)%i5wq<uR1c}9TA
zx~*bcqTg16Cp3$NNqQljvhTN22t(f@nm@SGlTpGuD5R`OKYFk%v7-n&w!>jh%IbEz
zHSh>!TS)r8ZELAc&4@w@Ru{NSW9D;<8nIHsC?u|b33{50$b}GXMPX3{>0{}svl6^h
z98whYF%J0)9c~Los!^6B2MhPB@&IyUo*-sgg&PH}{!cktLWd{RUlM!)8wezKCEw+t
zLUz<rKdCdkck2e#UqhN3K^dQqwsFm7aS0&hGM!>j-bOJ9cjDDS#n}Q4Z{;CA8%u|0
zD+xGz)h~rRr%#+N{flVy_IWHqOSruBpu@jd<A`G<^aaO=WRoo#DNG5oD|E>8E0TL2
z`D6%Jl2B-`mn}l*;wQLN|MA0zL@QpelYNWfd{v{d3EsrERO2=~4XNiUtkNamf-Eov
z(YO~PKh=-r3eF#IEVFVwpMKV(x70wdS6924=gn3ToYch6hTkPOmxxb19Cuo3_4nBz
zT)Yx=*{APzHEs{6wZ0-3wxehB4q{v>l+Z5Is8|4z<-_-yNf{Ibbtr(u<?HHTj_j^u
zx)ITxg(!5SP*(Mm6|sb1aVL9+%TE>`cn8|R9dfKf6RRw5x;stmfreRbn&^Z`sR})Z
zCi#EV9MIZo37?I{3HzaDQV+)8XNvh;V!)3mzCOvO{kS=IAl}3ex{rkmlJ~s!LBG;#
zLwj~&LaR#)xvQL+cI3_7Ii%@Kr8?=iYP7yN8-Q$yQv6x#QP@ddTJ&{Ug({MyKMV|2
zAboYzfps{|1K^q)k_Z}cPt`HF=Y042g?whcj=Z{L_2Be~W<5wes@xHbx^KNnRpX{9
zs!fG${8|PU=7LGp#1pm8Ia6NC+;mfzZ^J^@rG)7{#oW*{A*UQw!ErJ_aMF6zdnHy1
zB>_Jfezwsg1o5+J8&0}H;1?{4%Z9>f8bm8d$7TU;8wdeJ6n&D1Wg7egbZ-YIN;In;
zSjB7M6Zj1bLO;ASiqoq=YcIw39?{SbRvtNC?>2lYhx|!vCJQH_F8+7pS*ahk5Bah;
zJ;;fA`wmhyrG3w;G!<lzK&I9|t^KtuJ2#*@2dA_@fY~`*Gs7z>tL<AU!oQetB478M
z>*5P*BxFfd*qE~JyK-uFAl$$DXhKNuM~K;!61*R#VT5DamsSiK4b*Bi)zzR^$BCOl
zbiz+m5Js_rQblJ|BmE#AWsXorhRPX`!h#i7keT!w>T38!E4~a&OeC9GA@m&KF>%s>
z%vW8NPAQd8k=Tu+qoibVO({$H8_^vCP2v+tpMf5f(9gLSIzZe4!#CynnNl|BttfEq
zG_h+)90b(8ZkeEr$UJfobuVfz4l_?N9Y1~DEnaT^T5ZKd!uk;~^uOkby`KqTL~f@?
zW#{)x+zG)>jH*Ot&Vb>o)4o73TpU01P-jhoh8IXZ-Z^P$Liq;2Rq(MqtChJ$SCy6d
z)=2H?GbH6!&9~C$BG&`HBltJk5tOp=kC7iF;av~d8D%%u{mZX_>68Fxu$KM~8|A<p
zY&)NfekY%dR+@QY{VgTjeDiBXTbqC4`-Nb-!02g{1l<P`L53)E#`r-3hhK9R#**ud
z4j9$=>!)VR${20ftsa6Rx_lDrEAg6vR*KhvPvGrJ-0<6CL?ysw5#z$|QV1-%7Q&Im
za0Du!$r^_Xqc`LQ0B}JNDv<$s7!<m3F$`V&R*{@vy8rYR&5#ry`#~1-MEE<q*}PI6
zhYl=+D5@T>ZY9upBoTxE*}ggNYl$ZX9}MkypMLiER*1kb2(O9H54Cy0?q>Z|6M7&E
zK_Vu^$42!t4Vf;fDH{5L#x=DaDT*G%^9kIVQsgK#G;XtyBv0%Pmmg*S%I_>2Ym63W
z7jNirrZ(;!H(EvY4{P)SIq4Bnhb-J&16o4$D!MHzSwce;NiN0uTJJ>@1?a)`Eoc-a
zAW<@-^4YUVFqDWtrk)ne%ug<7e&?%9t!|k*mMRJu|JBm99vorRd-06AGJF>64jfOl
z)UQ-vpTYnHXQ~ycOj?v&4WpLO8{~!DPE6QhJP(iwQ*c$d#F*B<l={+<OEc({yr`&r
zygNmer<?SuD6RXow(Qj~S9gTWX`q^vnt3N)>qP|`cL77mr5oB3fp<$@F^%`F(JW~&
z*O*Uue5<~^X$|>sJr+uPikf=aBg5T0FFIYI=~YqCY98-1x7!9L^zrTMebM~KU3E%p
z;9F+8RC-u{tF4qlCa^tZN>g`Kb`(D))<XT4l#W(Am8PSnpC2N)x1|x=7ZppR#d-%1
z*x@oknae$lAL(P|+UX1oAvGq*=@r<@eX$1NsVf|g6_K%BEGamqCURdl%%^JYr)JI4
z-LDgbmYL2MhjC8OOr1^<vfG(3NR~e6E6%stKoBwz)-&)JEJ5D+BS{Ht3{yCVwVqSV
z*3Gvnz5Xl_FxTYBJLgW-?{(tiC_7wVxMOOvdR7`2YaH(|h8mid>i?FKQsBFErWiz>
zr#Qajg+OErM(FL&E*;;~xoq_~3!Xc%GU0rDRtxo4`yJ%3zNbJq2MdLgz$jYr@Jp$j
z2K@E25oO6~@GUg}wR3&EN9jZUeGzlUFo5L2^#B#D!FDrCq`bZ;1^In>QVNsgqmWz*
z>a;`Mci&WP7!AMIdfK1mC%ULLEnM%*5NdpOWD9Pj7!I`xF#M_{{pBMbgYP@gK@-@J
z$t;A4>{D%so|BnkmeI1AL3ygbts{q3n-7x3@3k}NB&B{nl)5z@Y2C(rBZ+w2DBpuT
z5{IdUBY#98mAk?SNsei|V^r~Zn9utjZtr2(;*51?l8|A`OPZjfI?-l_@Kk4pzcB+i
z-|L`1%}=UxCtg?-E0Dy$rL<eE$y`>a88;%b^K10n*Wi?FvQNh6^}QGETGS8>6bqUe
zz`XH?l*MV|uJy2x%APQ$!kF_Pv4Y+96kjP0xSXT<eM;k@58`0gUqa9Y@{u~U`Vw&-
z4jPZWa5vYbf>2Mk@Y639-q;H^5*?>mea0rZv4wWyEwpy#N7QeAK4B1mo)RBY!o{J;
zqyr>!sX+I*BnXA+UZ}8BLCltIj`sDzsv<cjSXa)+9^8E9d;aagX9-PZ#)S-NqRZ4<
zsjq&MWeO48ATn#UXkk&zRf26|g)fG)W`X04Uws8JdNp2I@um!8{tPg}q*NZ@R>z~)
zQ0kMLn;;AmRMftxOuQ4u=2usv`}GfpwG++^<3%vDlfxm+pRA#w9dS{6K_j6-&8;ZU
zo2-{?9yR7}G`}{4J(B-|b**no>#TTCL6^4I__mck!KF@LSWVe)Kgxr;iuCK+pSc{g
zQ`U(|^5|>=jkBqz`x`SlN6}6-j9n&id$WY%uEgHWFC6o2fpV$E#Pe3mYzx@|Ui6wr
zwskJej~6on&Ku1C(j=+O3Q%n)I=$fKMco(m4SGAC)P!{wdRM{@y(d-MiRtd#2uHlZ
z%(msOH_F(#NlW?;WKmz9&99jc+@Y+t*s}{Geec6UKh;QURx4Mj|2wh(3jh59G@lTX
zOxOuo<cMwWMOb#Np>kGWe}m=N3E}ko^|rfb_0l^=xSwu&Ja#GV;LZL13OkVzaf5O-
zF|~SsBr-XA%^Khgrlj+fnP<i_Nub~Jw|qDN`>c#bDJ4c23$@K#N*a05U;H^0E-#F{
zWj=JE9Re@<h~jaVQQwI*2MG=%a-7?x#N_pV@sn7hIZ3s#Zo26_gv#|O=epYvF}Qq$
z2pE|ch?c|UU5hN(^)!eU4Ut8!#bz*$-uS~U?>3ZY5#s66Vy;=<Q40bIukS)V2unhi
zV0r?0ZXn6BLznGjdBlJ0jp|LsPc+f`Bg&?n?}y!QRay=6b@cThf6@R;4upK38AxLJ
z#`%~Aj`M~dr#9KiqA%;^7rZQ@;fNfs-b^be?&B9<oclT+^`rUs;JMO0XM3;Rx|TfE
zB5EMC?s~GnHi)&JP}G@Qg+713JS*v=MupL}ug9CKtE=nlmZmu2i0h%kY}kOHZ((Ic
z1Spn57(cB!alq}VkBi~z(0VvZd&pedc@MSZsv>+o;`>|EJUnyGg|gOj?V;Q1vJU*E
z{tySQ>`di46lG&(N%}f|_NtO95j<Iub0bv;6m>S<jYE0J`yP)x4eOGvXgvg>7O)tp
zn}lu_tKF-^U8Y7VL#MEBjo?L7LP}Li1U}<KT76nt8qJJBRDRH>nYzxASQSco9K8Ag
z-J!2V51p8f$MedED6v)H!auV4?V;p?Q8_3EgksNY-o2|5yOZ$Rx-nv1^PorQ-Mq`n
zy=g50WiO}il-{eoDO|QnTW=zNh5O7*m>XB{9YA)M*)uoz2Ep6c9JNLrNrwbGO;lSH
z=0qP9wqW;|nd6>GsUC)%h$}k|pg$#Z&3X8t7VxWA1=#K4>NV==k=X5OpAR;%T*e#y
zG{7qC9IRA*-J3fOXnqggyOZxG`Pg(R&JU=%7#=jBZgUl%d?$+fRWboQ-HWioi!Zu<
zkaZ-+fxe-~sJD5M+EBehiMYZ$jg2jXUr}Ls1-PJLd>1Ya;!LuZa|VXnf2ZY`I78q~
zvWkEoibp=l2$PM*MPEo>d8cH!zio}0U!{}|q2f@2g6Mg)(z%)sonuW?=&aWCK&pV&
zU*F$$Q_|Om_ER{?B*mT|Zqq9dK@JV*3n|j)sR>N_3e2~mxc7tEIO!y%13cRUF{_m+
z^@vTq-s5C4o0$8t=F*BLD+Xg7r;=R%z#A+s=5!dnmW(aD;ox{I1_`*Xz(kH&Ol-ag
z68*<H$s(qUmY)fQtj0>ru~mDc>W!amqqJ$4He1cc|8@Q>DBD}FptUSEc{zwMAxt_#
zYvjDp7NpDojf-Iv|43!ad`+oT`S!J*hb*}`s!{<*iPw2VWCL#J@4#Qs2;=VNXmqJ6
z-Ux!gak#8uA~~`=^3UR6H$EHg-pGA9Sg)KQHnzF+l!}dyfLr_1J}FicGQSkV<X_B8
zcDUcl@sS9I9l5|e;QCdunzVbO;%cRaBWts?c$O{K$vqqGgZek~I&&#Z9+g@nF-Aow
z<U@|7^ha%>e8#A$^}U~$8A+Xv+lYF->x})80yV<Hq^<UtB*M>GbxaOQM)N)_+h`Ur
zzKI#$)e<1j4zSMco5JF|%dxjj^6{7dSfUu<ztp4gbrgi(i4k7JM!^cflou6Grt)Ee
zqPq90Qdm8R#Qi{vEo3J%43*^VqcTTBlS5ywQmr(R!{9_(qB~-De`b$z6k8;{fZmCp
z%M_d(UnG7@6JyVJqQWi?HnsIm##ikZrI-Si{B8EuHM<!8A#@e!Ikqs0eQc~O98aBD
zGBsOQI_Kr^XtY*++M^Kh^r*J`&nzU@CW(sg_h5K|(o2cIvH0~EY4jhnOPHUZV5A!o
zK0L`k$g>EL=;jUBV>kcvolZ*HfPOWxTg`#ES@`aQZmF%uaCN8dlD$qlk=(r9HF6^Y
z$K0LON2J|KzQal*u~|1agj6a&ri`)$(B_|%W^_=}y?8RiWO;{#NCuxTN0@WvJp~!z
zG||Nje(caYZ=16CUzH8uJ|aPZ3;QNE+}sk1H6I#|Mynk!PNU6;g-4>5;G_nripO1W
z0W?tZ3=%Ke2nZE*cce7Bv&XIAeBX|3I7(c~$~hHf>g<EFPuyY7$1BvP(x|bRq&IgO
zj*CA?I6W0|H@1?M?Hc73s=vHA#RE5WTG9EoRh6jo0r4yi5LIteJ*^&;5VeJeP@SD`
z`Pf=nO@d74+2KXM&xIr4v8AzFJnENSS)yp#lQ1Tj{Q0zI+_WycPqWypg6~J|6F`-%
zW*d-*r`K%hnWa_9kF7oiWIIN!>eXvZZb;g)@j4GYPUc=<>=Ic3PgGi3YH|xRwOy!N
zqqA|)<W^!*hVU|m%!MF5pp1<OA&Jr6&~I>;Lo<<;Ze!5X5zJAm;k6)Kf}?gvhO^Q}
z6_ED;f;*ftlmHYgtKNy1i=3b*G#}FWd86uh9gLn;dV)#-Yn#wLKHiVzrKKDRv0j$a
z9UmD}kA5!v$m?;LbQ-}x|8b}J9Q|qLH8m%vFw5eHRVY0GhFb&ji(;|(*~ynii4g?1
zWCAcf9JNN@pLA;0=Hj<h<~6#)5KVgoBX==E$Xf%(e2J3oGGS47=d2OboZ*YMAJ(WC
zqmIY>y$?;8JT$vTp{Zp$f<{ZLhVNqDeZSljx_m)^Xu-PS&{YMrX8^94ZRQh2?)jI1
z03zT+{zb>J4={$1A8&vJ@Blu45~6<wRrUe|L=vz4L3hHlHASBjaO2^?un91;9RZmh
z!JPmUa^v*t48u1-FX*0K9fcninJ=S!qrol)AMJc$^way$bn?b;BMWD`8V+u#FX4Cf
zh(PJL9;>O@0kGf~D%=6#JGQ&c<DFA7{7l9)CL%_G*TNjOEy<K}*%lq{F3XqUUADLX
zMQ-Bq+I#-&Z~u?2zl_Ur`Q8Umctj~_=~PM@=}zgAE(z)GkOmQu4hiW7=?3Xgy1To(
zyUwtG|Ly*s^Eq#L^>E*F&#YOqX07YG)?y9I7=zIwk8%6HT=A6Ss3YELM`vuR+hG(-
zM)Z$&rfXge?(SUs++`NZliK{L%ymVEt7S#_;ik8J+88zQXAK^`H^nK9t^hck1i-*|
z!Zs(}l$p@waVNQvL;SbXgC}u=vF`<}K&omwDI?3ec0KmceUn=)_%<&4<cXwLnk42h
z$a_hERm8{WKoc9vcaTjgS~OYJs`Q}gc!ph<W652LWu|n~fp49a4KTOWdgoG(4JAKy
zUhM^IpJhN#w<jWMKdkKC1JI(~k`HW7-TQ7Zms&{&)w5Pq72z<}u^`8QhG0=M@6?F-
zgp93a`GDwVUetYx`Ty8V4j4<9Z{&Nrl;$h=P(gM`0DkF361VfgPx;K79|G@&*z99L
znWJ-%YnK*A4NkYI#}gE^&}?tUOFXOIW2e(_m^gt1Goco@+jagx(yE%O#e@CeY<2#h
zTW<5={9dEtz+dXB#(%yU$2vZAertgISTb`T87$gyH4ub-<gK?@QYqfY-@9_Nwf6v^
zYd_A1sUX!zLSEN1fR&tNYdCoP6BpYbj((k~{Debae0;dvo$1dC<J$R|z^&^t_1R5r
zf;)7qb}J*;695ZWt~(GO+$GQWQ$Fb$y)5iCP*s&u-TbyLrJ0h%xzZh9fW^;DtMUX)
z<neU4?_h5#!+Vwy2{@Q%$E7irsV7fF#wRp(Do8MaQae98Z;+PTewD44i+AR6)XrDw
z(*d|h_uZlzyFd|^&y3=zrKsf7SvG(vLH7Bz?6n=~Lp)1(Cs--0c=vSx^e+jiOnnA2
z$3&>~h*D|q;2EKR_!36~dQ?Mem?Xqk*!x%O6K}v6hz$VL>{EFP0O>qzZn|fw-w<>n
zHoq$S`t7}}q6`IssB0ID&5o-;;AB6Jee1oHYN1N&tku-RiOfW;7wp);(5nu8r#ahB
z53oGs4yRub=|A^sF0|3Y*NMWTj6r#JdM!O8ew)W?K0*6NNWPZ%cB)ewKoVm=5)M&G
z24-4dYA;6jmvCTsE#>8=+^k?XUjhH=B|+MdEJzEaZv(t+&}7wXIGNy$Iea}9Zx>V*
zdKKZ0oO$gx`p{qXnJ*<H4&t9$9M*28L=|jD2mbOnG(p8<#cz+@iIpi`fghb;MPKwJ
zOYyuhZGzXYV>oSu5BpXC3iFda)kk%cjR#tXuGn52?tVsyS)+g)k;pKfVr@y^bhV<C
z!jJIWCgWY&SIFllcDzpqSxfVuIxqaw2`*}QK-uzqL{sXsz8Bp6)Pj`R$#(}ZU;u{S
z!hH7x{^mV&ku!T!y&<G^<QT`a%UE_gCT~nweS98HH*4^5wjd`i;l^6CI5oEO`n1n*
zl7Hg9*X?sSklJk8x3m_X^b<g0cRTS_HpTxEfwh%!Q!2Odsc8kX<gK|}|Kc44x|#l6
z*{>=WD%9kamD`D$rgl4-q_!Z;L^y@d*S$JKs_<U-pnNQvu$?SSEP=*0c1>xGBnyD3
z<)SAP2f!!lO-n^ycguM)2}R2HHk1eEvS{)p6@1oNjqKH?mN>OTiV4<_U3!d?YIqhz
zkWqfEw>Ilvt817E^|rd7ZT3iF3p$(~o?`Iy<lq}=nE3GF6TRxdFsWtO=+zX+Ryfa?
z=5{SJYsqj@*nzb3CXC@bcort;F$OWx@S!qLS*s##k#kuiZ$30d=arx(?)^Sde4Ve+
zhC^V|S8Sj_-puC=Ov;45!OKrA)x8&Kre-efuDlGtaPnpYyEqUdrB-*G5kYt2A&@G}
z2OFvTwB?=k0*~DX$g8b=(I>R)zKnf_Ksj=81bM^2)ldMR(g<D&C!88x_ugu>*XmG`
z$E%;q<S%alu0r-DWTBz5jhR^_k|pU0-Y)v8Yz;m9ZQD!h*QY+};(?q$3x}Mx(gP-j
zqD0N8qscxI{&}%Uj4cS`u4CAHi3KNso76`z-PV{bpZ*DjNF#$tZJSzz_lagQspG|q
z34qc&ja8`E4KT}TirN(DNo~7PQ8ATAT8ilH58qSozWxEwdZFv4*)uaD5G?UT(~|m#
zQnav_V0hzSzu;zrA4`B*{sYpQm_-?ki`N6r57&cU#l+Ad%3qPSK@q%*d19V-Jz8<a
z+3ap7naj~kMwh2H3m~~^8xOZ*F8LdSL{fAZ%RF|GW+HRQT+JVQ#A5GVHtd}TwWg=X
zt42jL`F{0YZDUMeHl5~Svh!<qB-c-F>^9o;B&ho}R?S&I^cky`S5GXas<kRDTT+Jd
zIMjdawLPDweefc=RLR-P>QuUVqAyuPaL~lxQmOu~Qm&r*jlwUjNR`9ODh0_K9j(Py
zq=^p-44~8e!D5zw2$DP}*K)S|O{;{5Bs1}<BJ#nTM~#ObhwnNGFe0ys@0MWE8h>F>
z;r4QreMNs)Mt(!-6&`I-f7VILr7AWU9zRufI9ycokhdR3qhYl0PH+9B*wR_++#ki+
za;_*R#hK^y{cP1{<v?Ao;YA}U7k7P*)pTvIIk&dw(6=&to|36=Xms{OX7v|)6R=je
zWn0_D{nfiu=Ap**S!!ICjfWi*^~Gi`YsC|k#!f}-#rC^#j(f))#rv?OEp}$qi7kRX
zW`om7O`}iPYQ6oRZ#%Sf<Gn2~iE!HX(8^$#0AZGIT8ej6DV)Su2>lJU&-UC{yLBqe
z5g=X}QfC<HoF+_0dq~EE5O~i(f8*>V`o!@Dc)irl#2U&y$M+RzA7#wl6F*T}o;b^o
zPz+<i;GMCICpEzr-k$8&CxOeN4}eYFI6`bP7e029`?QjHlLn`rd{!(-isi(q7D+S-
z2T{(bdo75GJS={TQXuZ1sDJ+uhe)jE+T)0bRk9~}!CzOpYF!bV>M|KsbHH+e;pPC#
z5=)S~_{(OZ&9Oj}x9+I6nYV85Qp|$Kr7xkjyoRrAg}a89I<I~EYPd)lLD%8D^YP>?
z1Jk_F!$Q6@CVb<>_MC+xQJCXhxFA~qi)}MtAiWN(0i`TnKZ4=h=DT%<+L^<{^JmB$
zX(*G^#sJ_n)I#29-_ya|*lovSK|rpI%JZi$&R}9ES|SCUNX$iLvTBuq?vke?fif+%
zVr$Ghacb%hY1;QYs;bkDx6c<XwzpDz`-e|TxMxauDM#j0PmM{%;=GRKNGYUc<BMvv
znNH$Tt<`55D@PLaANH!fv_~Iqt&6U@<m#%`u+4%K2(NwhHB&TizYQdgJKgF`PHZ1P
zD$~pk@)zw7@=M`cMw%p_>fTlvm(1+a6)YT&qgnpW<CARj2Q+H;EDCNYV)vugd%k#H
zf37#$C1mGP&_tedx6-uyVDG!dh7&w+P2Ey^c!{2ITOWM0@9^ncxp<}TdWvhD6lv+>
zLNIMgXiK$$ZX6sxAgs$l+{$zDq-~310g+~3p>vzY-uIoa+6NV`=j7h+^Nf4pqyD7&
zo*|tF=e-tUn|Bzc?tj?lk4tjb5@j?<&>Ux7@yVU+3YT_rW-9PpMZdYOxum@wqQ{Vw
zoVbX_ObM^wGri!=x2&j)<<XsvB|Z86cCp;H;XS?|6n(sZKa4D1H-gbZH^uM|Oa771
zfo?`d_BPQm4v~#`rYxe(`)7r$X#{KZ)}K&Sr$vh3HjNfF-dh)LzQ@IS_vYyQiRb3e
zi1#DA;>DPhwO?wkrz*CY`knNwvau7vN#xHF*Fne30ghse^H{%A(d3&$8a^**<mCfM
za4PQg{AEqy7Ob0D{(T?DaNRabqDk|?9NIpqYNH1f{hY<QMM4doN1<yKxN&7Iomvz{
zv4jg2GWmrR3fzxqz%2o{;g)9zA>e2~O}eZ3`f0V99Fp1@B@RPmz2KWAlL+V1@=RLS
z{-!)A=Sn$t;hhK+;z+VHd0wXY8m^H9rrhffJ@Risx~l?h3BQ&?JJM)%<1^S`t`rgT
zxSt>HuJ2y7Yp@{}b!>nrzRCHtZ4Bb}>V8&bR|aR?b+94Ec~G;qb!(#JfSpQ<PGXPI
zaP92aQkB2XUA+^J^Ja*7zCPtoS*KBE_|zxqtih&D7e%Z|th}|y=2|yfmHQ^w-t+23
zo3+|YIu|<$WAgrURmzF>&~XpfSQ*!}_oiRJb`>W&&hKOzBXZi?v;vB{rw2BL9j3GG
zqG5h>Ps3uw<?xu-{iIjfqD7WG6Nng9HQ*Ae;&50PtN<BnJKKIYxt=X)!nJdqj%MQO
zPSbd?h5|XgqT;^r`v_G11o33q<2%w=dXxH-KAYKUTAh)H&chP-!MteG=DRrcb183!
z%?$>N$Js-T6qh$u5$JRk2d4E_$(t_YyZmEit2CO2jp_GohwpnWCzIxnXCAi_n0S@*
zXj}1Nv~kZ=;uw8+dQdMJKAqknxbB<l%xWrntaWBeK{r(8;k2U7b?#++>{B(CDFnCV
z)A#+Qn&{lR%X>11CIg(C1VresxCcf11dK%C5#nnc(+gZo+o-pA7#Ht0*j+Ld#3=GX
zfwR~@#gY8OXGlY!fyOJHKlI${S8m%t2--&*?oV~Rcp<=W*Tuc5E%&nBT(MX?bw-}E
zIjlltT|B!wi7X;z)4(73I5L-#7@Bj`RUNxZpDb7E@KLMMJsH7cc`Y*4Z9PFfZn95<
z&-fTGSz%;AK<@FVg{x$~mmSw}rhszU&V4@Qe9=bb8p-FyjHkr)4~uSXruQkQG^w1S
zu!IgDs4<9CUv8;FG1JA?<>^U$QLie?ahCABPhHt-kLlb}y9zp*B=dRk`y@;YS^K(a
z6rQcaW!7mk#=K4qe}B&P@VqE|KJG^AI%Skgr;ZEC?QH5oY7!=>X2D_k8z~>R-krbY
zFUv`y<k^Gj6aHrIjO=XtOJOmuV(C7o+iZTTZH?2Q+|}$7?emUs`6~U{`I&>dI>QZq
z@fruGN-g_=e0IX->hAo9!H?5XjlokY*zG@Z<*_XE37I5U%tMFno6K!*x9Bw~h)naD
zGZWooZS>2n8hTnwg2NL$Ldxa1h2q!=@8C;gl`Dnc#fFi3Z10dV={M34p}&Fa3Zz<j
zYcOtol-HdL`9*<a`5qzyjx3R9aWD(792sZ+VI~mxOu6}2xwySRjip&IUuZm?6ya#L
z*!h{|nRgUq>QN+YzZRzdq50KphTC!hE9BRtm6^jQL$OH=+}9pQY`dquiPe<hrbY57
zgXaFp^6?HbSW>vFy+SWB(u1&rN8e%xA73bWyjy*jIEXmS_wm=a*bF#bp0E7(+j9C>
zT}6QSfN{yuQ6XV5L&;Vw`V|t7HgW6E-tc-tEvNv~-D%I$M7oNu;s}%4VE|y>=$u32
zhpt!dGY}{8Bq2E2Gi^7@yW#l9eMtraoixaT_fC@urSd&}6m{668g33UiNhyjq_z`P
z-72Iih`O?-PL`2okAuXl7!MUiM+Fq&P)6j`8(#wu<8%Z$j4DE-Wlq%qen3qnv}+A@
z`H7H>xhmz~wevJuTH_dxnBOd)vl!%uOzB@Z*34RQhrG5*<(E?lCpAhT*dWWbiTR=4
zGPi^t&R$e@!=e&XHPP1uN)fjktI9y+4!ViU#ie_AY1QHLlcz&pVyAEO9e%nqDKmAw
zpu-sXC}_U#o59<Qe{!`_)jCm7V$If6<X(%n-f<yvm)MqshkV93P;3n-bfD&|0h8$u
zb+FxzfEkIT)_5^vemlh271JbRbeiSayOg|JAGuS)q}`Fi7MvmGBy~`)E=u^U<Uw6)
zQeHD2mX$`Zp2CtV!?C|&nDyF)TcoNlnN{y@ZEZNaznChq#Jtuxzk-=co4)#S`{l!~
zdcNU8VM@Gk(r@(RW9<-6m+Po%b9(a^v+C`N8g{Hq!^M%|PUL71oJsm^H72g&6G=FA
zZp#@KSr_H#uQUasx$s9iS8do=zdzl7sr14h6mC$>5d5;1nRga=`KIbSlgt`$A_KzR
zOiy)q_rp`E>`wukEx><Jkb1izk^3{O10|H8^hJkJnfKHu1<@|f<1H<VCujD%Ut&8$
zcP@O#Ps<$Exy;M#8!rS|espPbj3UzK>9#$n!3b6K90Sm)@J3S<?re>LvsYjg?{h{e
zC;LC+2z-MdJ(NC_`70k?rhrOS-<?5X_J;=!6n)<$wV}5~)~}LJhRQjxxL<>>Trn+7
z|1_-BJL0G~Ef&%T!(cG_%PfvzTcet6)@}0Vd3kR3Hs)Yep@w|I^r`!Jop?|Rb^u9$
zM}8owfK#~wRFjUwHvZyO2j7h$>tQ*B<06k9tpyE2XstFvjyFgj-LCb}CB}!&OL49_
z0i})el(y^9Zqw>}p~0i{epr>wk#kmKGzX+@{?T=)TNFG=NSX{V(@lK=>RnqfLzvQQ
zq~D^St4<%X!!YvUI$?b>Y1q?8%PAB#N?R3CvS!IS&&xJfT37U~2pbb9+R40IJ5Sv_
z(W-2?Fc%a%?6bH#aBl8Bw411%2Lb`47`R6dm(8huUPl$SsHAx517On1l9dAcO`njv
z?zVHSm0Ckj?11RkiI`;uuiCfBVT7Gl<F_IQLE^Nu<^$J0`|xbDhsind<5g#2U!S`c
zTgtX(#@U`<kj~@Hq`X+=Q(mc4S~f-C&JidNAl?q4JD!8I601MKIB8#uj8%Y<sKVr$
z75`d-es_hrBB>~?%L2lt7QW>$t8GtRf%r-`;;n1Q1iqAjqrzlzqQ!jeJWcsHsn$J$
zTAmD1Ow@QoML}4$9u=D4_LD$QZ7z?Jre&3K%F?D%BN^Jk&8tCz-iG!}e4?d2#h&Vx
z?PZ4D>UK8dI$b|D_kjl9Wk>Yg{X?J@Gwm6#6@DY4;k6}993+7>U65n{_cBcay<pN2
z<%`6@762qU$B3aFo>vIRFZ*j2QcScn$a=zHm<4|oARMOUr&s^TKEn?HD!-RSCkuOf
z7Rc1c-+jQ(ku&i!+s1>PTr{F{vr^u?G1pH>)dYQeSoQXPrX$)Cb-x)i56_O537p&r
z{n6m*97v}6qov^xv2Na3YT^JsNm3<#37d038*e#VScS$e^SJa_iZ`d?;w(_!Z(ji|
z=xS4){+nWc1<b)F-z8@>JUtVPB}*5j;SjaSGtbKkz7Oh&XoCU7o}a;0i5cX0%qyP%
z=)(<)ersh!$~?^CR<(HcL_bT5Sb0eX(No04a_Ok=Md*0DR^q-+vrH$g8bIq)F5}?{
zOUCenTTkyYX<;J3O6HoZu0}9{F&i<y%1NsrR_u}UO>D15HHRiswrTBpWc^B|`S&98
z@>O}W2IDU#E@3Ixjq8kuaf!ViPe3%aF>39mGnHS9cT<JIgdrIQcWFXU7<A}z+;Z}+
zB-aXhm|Ib7@SmIRFJ|BQc6tsZai%Z0ND00B*-2%G%^OmIEys#>Uih(JId<OeL<7DL
zI+@xV_G@n&IzY}eL~Y(COpYM2<`ejC@2HKBY}Du=D_}(m?87nogm&@%p<d+t^CkA&
z=Vc|kyRVYqWk<MfY^We)xhmLcDv@lCyHG^hn_j-kL^mvm^+-^&#A_GB9Ome5lS}TZ
zmzj7vCfi(e?qV&7c(K}~BkO{gkf)X@weLh(iw13|Abg-o&zG6)okl~3=6Fq2n7AHy
zkR_K@vTvNs4|<QQT1$$mMRu=sSw&IHTEWXpO-=LOiSIL`4eN*pI<8lUox1zE3?=Jl
zsvA`uviV;RjV5p5N#px*;Q2`NIk_j}`lhhH1-$<HrujUcz1I!Nb2rmdabBDR+a=QW
zW;+){u@NW@#C%*oGv>d=9nSx0H3mUu;Thc8`AjsG5x5C0(*$%|K14<63q6B-bH7H(
zKV6Y*^GAd)N<R&P^NIs1Fu#2@pmq8}9peYlQ+k^ZKqB{oLfkmr9J@wnH|EAiW=6*E
zO<r4xr8w{O=*!}jS=io+EXuJtSeC-qzkSF1%X}1<E}S3r+Ja#Y<PN@7$nzg)FVt=h
zAD8=TOd>2*d);N9ju1QF&DPh)t!k8~?OQjS*DrsGA?C~UC(_l<j=8s&ZJIzwtflIb
zaxx0@{t{L2jBCAs_TpYr5Oz6u<Cach8b~kkG=|X3a$xwnNMOf}sKO?qcWO(%`;<Zg
z_t5ignt~5<9$aUXx_?HeTCL7}OTHx6;)$j%011^&!yUIa-pm+mPWR~Oo%Gs_)0pWk
zL>}q7oGp{ky@Ff%vqVXHf4Z;_;$-IIGUb`Ja48|&%t&w_NYM!}ZT-X~&;2JMip2jZ
zi^7nw_6I}GV5AcWWU%sB$JC~w%v<$6&Q+T%%*3}$_G^32@70>VI!)C)E~t-fSZ!Zb
zkbU^WZuQYdrFP$|*>+XvAv1YCH<WADaS-F{UQ)CrfA<W#CHqG3ZK3+)QU7c>=ea*?
z1@E-RcG@COcb!@{Wm1v0dIC1;yNXCvltb6a`Wq`UEH2sO40)VOY<LH%)GpbH+I1o{
z&XB|!WAnnaV0|RYBdXk_w&0K`nW7JbdvAS5X<^{)-KQAgb!^3-e|>xK@hglcKSa^x
zF&IjeE|bPpHfznaH3W#!_*1gAA-Lj=iXkI+6rM0p1(u3=djNTbH1n}5fpJF(^O$5O
znfV}(kcdqA#{HX9P3wnMxLA*aJ#nOB_fz;X4wcRYvFeobsxE7no8#eBPi5!sKJx@6
zzxSQc*4E8?om2>}YqdIuSmT+K*6JJ#L7{i4;YC+t)?#B@#5zI;;Q+K)2<?#@II<a7
zv^UtCWjNQ&Q^qrB%H>QeE4vEl`Rnlr4~dI+Iazua(W;Cvf~bcrt@gb&7<`|`tTkYQ
z+wKgH&)!tKH2<bT=>wXG$(DZ{o&&fUra(my44#j`s4SGW<6&sQL6g;ZvX`dI=J+b#
z`DwN3EKA$I!%K7=4an04Xxf_j=A|?4Yxk#^j5MIzkvG|A8Xo)VGQTG7vry9OKg1&p
zt`w}_9wT&u%KBfT<)&8#a<}jMpNaURdGySUMNN$<HHO3Nir+6)eP47wZt!dD%e`Mu
z4yM6q@o<=#&BnIo*})tYoj<$63wNNth>IWea4HGRRAq2+?5ftEs=w;48jVpMm%SBw
zcuIGHTH00|eybCM$LSwZJP3zS@^1~#2~s8r``aHyp%j0Nd(EdYWI58=1KU#Azae~O
zmy%9)7?DtCc!#V!#voIsPi@&@SI-kWjC~D<xw1U1jCn|`8qT?a!}d{xj8sU{fV1(b
zj<BR7aaZa4`a`5;mt8}vVPo8<BVDiJyT^aq?a3vlNK-hD7)J@bAtO7J6_OW<gi=r{
zCUI)`xfSC!EQfZU|G8GR?4wBSH}7w0KLxYkaLnL%pTP)8Bvwi!_8HtHUEB|<Gjk_0
z-;a3=xLjC!QUXz-p86DCi4Fe4`US@W)j9kfo<>UacJdMgIyH2@I!Xqmt*KM@@VS+R
zSzT$nfQ(xu*ak^zi0WP2WAI=tx9i8no~-o|)x&K2s5yL{;J$76(XAq)<J6f=1~C(e
zb?#wJ><aRWMR*Igvl*GO%SYbJxlFu!zV<P5RIL-9U4}2$#ScK(F#iWO2JxpubB5lB
z*Kui!uv7-3f%RwXvWv?%L=$1p>V>LN#9e;Cptk&m5n+Z~!-u|SG<$SmS&U^ra=n8k
z<i2SpvTR&lO?TEYeHb~;Y;p;Ij4*jmfDJ>!=ng?|>_|301Tspu*1-_Pb+=)Zu#wk5
zSTny-U(awGYh5fRqSVRGOxxu;8ll&~c${>fwCZH2ONz>{7*4a+>ZzRjCqoW}V6%BO
z37)-iE+b-f;m7*V>lsA%)`pWo;wGJ`xSKh;#(GOBy#T0!cwWqk#=;JGfvbn8eDhR`
zDAJh)X9d5SGG><AH#g4~w)6&zjKiB((s>gT+<4q(u<nL^d)JXXE%bA@4cUM54Uib#
z2MLxaNGe#aHH@R&c+`;YXuZX)(BsHvUwa>8Fg|!NLzL%hQxv)WcJwmDvuUzGX@siQ
zn4IWLb{*k65gS^%?V?ovm{jzr^sR;0kuPx<rp4Eq6>-d&{1c$Yrq>ZCpdd(hPM52F
zLm^M=T}{IeDt8oj%2wKb>${1|K$Vi!C7<rM(vXQl^Gu5cVW*i_g1dTrnZb{{z7gi~
zehb{HFS-~6I#dbVt{AkM+X=yvm*GYX;mLFN=Wh4S^%JK({Chj9E-Aj79;^;M*&7Xu
zCW|LM#a@rX!=Z7SX6nnM>52^B*{5z#e)IayiXsp4*4^&#Up?HA4kqNzrE9xYW=`$H
z6WiGxwUwN^u^fAn2B=0cOx}bhHU>PHj;Qwp#bPVRoFk>>-e~zY%6wFZJ>9`4Ew($-
zy!VtDzD*FiPCBQ{+U{e3iRqAje0Y1O{n*nTS#aq7oH0=cjhe8oiBg7$uhBIo;BhdG
zLgDRsdH_+r0c=l0w$9piDudxT-kf*}vJezB4;%rJAW16xkJVKKMi>o-arVQXJ*h=z
zjmP#rF}<3_S}L~ZMIxQ4i2%l4B}g(3b2HD$c|``)rZR-0tI(8!-b@ppxfuubhUZuC
zVqzBs*cDP)m6l*@@JFQpZ8n4smBPX~F{j5*hY`Y$oE0ONzTXR)fKJ@GOluKc`kRtn
z?=nxz`YPk>k+*VMT(yU4sswx*Iv%^t?he^aHxnq@%uRi_&AH(*zdW3+)ADF|%KErH
zDr=nj+=Mc7Lr(6`zXakZd@0#S2%$SBP|=EZ&!Nwo;B~v`Vk7?+<*UVie_5sYSPO_Y
zG!)O`&(A`b2TH96qF+WB#GsB}`s(?UyPgZhyp#H}43rmZJX13cz((qb44SA(b=M2}
z#<ruXaCcCDIH8yaF&EB>7e{!1((w}+i9R_q&3u2HrJg1`jm%@+No6iC##22CNJHFH
zh&-cKjxsgPkzLM>rL}Y#S5}?wl(y4%pOn+C4mav)wQu@a(sVwYFe2|G_c(>Qb<%M9
z#ZA>C%fZ25=A($1Sj}FC)@qKE*XAeZ-&}+KbzMJgm!E~%#Jm^2zbu%&te)hU*)8yB
zPN_+Cu3-}mk|b5!c%N_FyxEm~=_E0p+~jg5Mek;2lGoYl6`Z~}Y%;q~^5U%;uN6ZL
zJR|4rUIn?sdHu`pp>m{KaaJh&1ozqA*Y^nz@FV<8H;#!-t=b;v%D1m3d_G<DwDux=
zR~hrIhTq~=X|9SSlHJoOZ8fHf$n|JyM>LqH#en$92t2m#?%Z<UwxzGo<7*vPanE{r
zI8H8lPP^VWM{8YIM2#{qB&}B{z!~@n816|fj@_gyekxF4k`&{Ku!;=$z~3twNPb<h
z`irTgDNK4%&!4^AA-b}r+m-bLN>#k_`sAbllBh-roKt&5ub3ISB+{7Ha?eezPPvMZ
zYKd@@-aVvkK@CC0&7uGC{m9RWCY|mXAWN@qn-WFun(wY^+w-A$DdJ_R{|K@T5_ypu
zsB5an>=g7j?pXOjz17fO#8K#q)l)soYa(8gVo8jU(cwJH@{B2z62t9fwM6=%CTL``
z;ORAKk@WS3&}V{%yDG?&*^Qj-5YF{F_&01aqk~)amlPgK7MFn`x+1Lgm}OzbjqEW^
z3<<#s|HB%RF}rh`+USLPPt`YK1)j(6hMHfPk){@THrfGs+;i@Pys-`K_K{f>aDUZ}
z{-Du#c0gu$uEd~mOM7<9di@nsorK)tX2(ssxlkUpil+uo%!^RkqxoGQ5S_ZvL2p+l
zFQRWOvVp%(dE4#Px*|$nscESf-lbS_NUh}>e4{dyyO2SDADkzLCNCI=U}k~f=O1`3
zL^24s6@V_Hy)A~I<x*W4NuRr#g3o2uEc@7}?7n{~(wWRWa!?uI{Tu$rcWOc_vJJr&
zP8hPR7*Y+5I-T(y0`4*x$To>?c(r)vl_}n6)KBWI5!##J!Y_P|RP+LxjAwZ|0$U^2
z3QW$rS_xQvrKsKlZ7`Lm)XPmSqh)6q1ycMMboZ`u^<SQut8DbwslmaJKtaQi2?#V1
z`&DOnVhD&~!>u7e!`KuzQ0;vcpoV|@{)49C70Lo5UE|ea@ZeqLg<zHEW!s0}9ZFw}
zXyF8)AgJC@PY<C)6M*90w$w$0VG>HCa!U8yFYV>KBz+t<7S%}9c-$@TS~BLDs+afw
z=hy%IV;2<!ZYjxC3kT6h33cc|CmVIlnEFNU_jl1pX?MNsZWPiejrV$;gp1wZmCIiK
z_b#7HbOEU5I9O-Yw@{ECHq&B=+Adt|RvwO`=Xnu*c<$)}@pEl2BN$#&1n9s26+sFP
zc+QgyMhr+EY1*7Bkgj|KQ^z3xDA*bM@$69Y+xSCb$+?Fl5{z9Wlrj6-iso;lr+<#8
z{J`<3L*mW+INu(E+C>3f0nL$!#o=}^g80zSYoxHXA6KVJ?_8a&2J7<)trS_1P{kZi
z@M&5E($U{0Ju;xS_}%ah)FH;SbcEthL-BO=I>$xFc#`crST^6!Mt(4fh~@brAdC8z
znz{#``yKi}6Iw2nX7kW20A+m19XkCw!W0tZW%TT5X((9k@mFpgTf=(ML8mACXQ>pS
zmTQ=vo}MIYGAyBgUOEB)YTywYZmH0#;u91MlcYCNi|~rm?Oir;y-Giq=VPO|^Jc`p
zDOfO!A?q_KDXC<O*VX?w-U;|EF9e<zbuUC5U=&#?-Ycn-#agq|fj{xTSPn~IyPBiG
zA1=&XU+SO?M|YyyfOeA}SNEQsiGe=<7(oOf<c449QPIHoz@je*mIHq*9s{EOCJpG{
zzxEFJQ}X^>Ht}P1g5!d{a8`kS*9D8W_jmZMTNeP~yYflC3oAu>nzd@UEic%6VtEd#
zw02zRq#|p!4L<=axUoOQUv9{C+M<JzAHAIi(j#L#T7pq1dEf|NFQGzix^wdLCHYrO
zg5w4^X?_wr5S$<|J_C>Qwg-=czSl{6L_2%@^5Fco^6{1XfD48i1bktlHyc#0TaY_m
zv&pdt;bGIr{aEAEfh)JGNB3Mx;I<yYI9Ro{$q)<qA3O5J0H{|E;uIkgFSt_Z&sm4%
zTVGGdvv2)iNs}!}_odwa8XFWeEHF{-qikJtm=U2C3n<y%As4Qn&TTA<4VhY6g!6;^
zKXRoE)c@b!ffGn81=692yB-xYLKLMY!x=888!^$*ub93@7B_BXA&zC==JAJClJ36-
z3-kZ>9Dz6#^j=Hc7YS5xL}&?}3n)<MABNwoojYg=e*9Kh6H>|WzduhB1wXH3|HAw9
zb4w`gMps8gMMVwK!9_t{eac&8z6H#!9nXWq>v~C*7k^)Z;0Fcy^<jZ!m(~V?-lEX_
zhoADu@`J-lz*xa;d^6cl9R1%<fP#d*X?Z6e=1Pe3%*O$ZW8;TDYD-}2Iq`$1<I7@?
z*JTH1U;f+sHptLCEdwstY7p?-t-U>iXEtp%jpJ1ZCq3e$VK%E5Ut!Zp|8Y+Le6BYJ
zn4jb$tWs#mHhHPj{)}>gN*OfAr=A6M#Bugt#q`T)TX26zO|k?7fzzdIcy8e>;0iB(
z(*w_A)c4~|_Iq>Yt&!Ms8<Y8+JFPb~zJG`FT+o}h<@s@fx`7XdTDgIQ4~Dqi^}=*8
z3xsHi?A-|AKYQ}YQyL^g5iJ!qLtZ{Txa%@;0Ung|d0L(yMXA5}ceKw1p`bsamc)x-
zF+meP79h2BEg3Yy@+hJ>V8;17PXuUQQZOTX{Lf0319n`J)<Yk%PbJ2O2jlP0x%QdY
z4`HlICN-ILb`c|CX}lJh{*E>c^~qG0=_)$DJekUy3n<D*!Xb?3jmuSQ0eUe1ng<D#
zj|Fha#=$(NLL?Y4(U0n?6h=LloIDuDW`WBc{_a4T@4pGSmIgx@w2rG16rhAMM`6VG
z{{AR?6hf3M*miqC#{Y`+KSvK|5DW$3&|HhhhQyPkA+;oQxEtv;-6j9#b#1`Hp045c
zitFlmnyY{QMc@HriD2o@tFy2)0^a1A&1(jJKXYeQQQj6bo)#*Do)3TRhh!Dz2+Ej%
z6GMnZ5e5$rZwe}jdg`k{ZV=h(-<SK)f^B7t#-}Ju(g*{7Ak=g)MWhQJ^!|SzbP5CK
zGr(hS^i_ZY?(Ok7kh@)jHhN|wX;a_Z`HLq-++30D)ks+j74CPzzvBe1QW^@y#@~mT
z5Qgc!KwV8;odzC<@ag(3i&c21mVCCdsD?O9@*zXw`9IDQm`+49I8m-|t<=>&VNCt9
z&75l{@Q!Xfgk+>C!hKKw`(yzXuwE5kk|kb8IDtLH1^we{^VOFNrI2Bh<?4-BVcq{t
z0XS{QT8NgUM~vv<48D0!LxtS3^ZuIO#*LN#A9ERz1#9K>M;gkf4+AU|GrzUxAP)SC
zN`ace)Wu!{$Ny$D93B;t+{qA^jY$vvoPYOaR-2Yrf(j9W2rR{OhlC?0+J8+JRh%E3
z`8T-C&tRBj1-47T^fU2UHp$@xxq536L5xrCMJo9IwXBmkDE{vC!+JwQKS|))=*Px$
zZRaCDe8|LrB#ZueiS&0HjyxHaQOipdpAZb)XEt>aoiL@nz5I#WkiK944RRi=mMr_H
zjsSri_)=&Ntv@nwm2qTh;75*l>)!ur0sMdc18U1QMc)-_*IVfQ2g7GJ3EwWi3amoQ
zV(9q${oT^rlmfIm|Mx}WPg>WV1oqM|C~33ux*%HO)`?aBoR&|k7zb9-<yu2sNf2X*
zXz7c#*A14nP#PyJhsRf3+`k(?D;^kqzc(%s#FTVs2uq{!>F>l#>a7YZ<FuS#`#<Dm
z7@TAhc+)?!j;}B5*oE_9%jj*IDOkVBD9BV6{uP|5Tl?1}pq^q32nY5e9ve0bwCVgf
z_cN5D!#T9?O}4abPBFVuF^AO-)5J2=m*USDis%I4XUkqT6HM34Vj|Rug*x5_`!5E^
z{++=m$LkH{G`8D<1NTx~;9((P!g>Beqkg>2M8m~dxxz$mtkwKakw(6Sd)o<00m)$L
z*vaqR`ZGWDYN)WEs8$vq+y<w1(9Sd7{WS+~?@VB{gy&q0FCh1*-@Z2qQ>&2%#tj4^
ztZr42+<aQeCQm2#C-=<`%8uo4O6y|@t6sv37WidbpHg3d+TyFX^7`+yY}lY-N-Gvo
zCNOz?7MmulTs-7bl?f=-G2sYnVAWc(BF;@4T8HPGG481gNF*8@R05+*J6INUNqtK=
zjg(sTiSPtqP>zNoOrZZ7Rub3&duQxlJ-{KobJiQqnz+u8wAH*Zg|J#wb!&I)r+@K6
zY9%4JruHL7FHeAq7&}yfsGeGos?g1iu_m2$sa1C9En%pna2h*|E0e(gu1g$P7w1L7
z*iB~WS|_hx)Cu-#BdR-NzwF5aiD!mPsb-f;yo}ujU+CU?v!|%!L9ZjlzMS}YLS~+^
z9IkFc_uFmy*+-MZBp}uKf2I==@MK<B3hD~Q7{7LgjRF;lR`|p67{k<QtT?Z;O$|6>
zF=Z^7gcdpSM&7H_3~5xLBJ-jyAEj&&=|<@y{RwdWciWLfU_3>z#|ez(-f(I=mz}vP
zc%6sm1sdo_H^^bq&zj~?IST722{dlMW(O%x58+ko6~Pjx52c9eJv|C@#?83#Uz=IO
z^)V?YpobG^c?~1`aBt;ef_Y&vRw5Lg9iUk3*{|o^zLLS;&>$bCL$zNYt4!q<Ycv^>
zZwrUI`D3^O_A`N-ck-!hDa_y95%L2H^7&8K7L*SQTExj%7f9_S(}<Ww>Bg&VvGo7^
z6!UIZDxAf<w~WccRNGIqK=it7gk3)@Y>w2M^97aIBC(P1|C=u;9~@{H#zi<(8yIMe
zYg*z$rJpaO-c%_F<j(SCchzMVYjOKz`^3QZUin};Cm*=jo7~xq%Bq&mYQ5{w`j{YW
zq)+|V^1KBIfL9|xwR#=#972IvLBR$9sjr4`nGK!A)FetnUa%p2w4JQ${{fAh`c~;N
zhxSaCduZ87kLbTAv@C%+_dQ*vf*Fw&NFP8?P3V}pG)ESYy#3=radlgtOo62lyOmxz
zVwtMqr-nB33ZsP?h5k=_#Xon4f2KP^?8ySonA9b$&>34hxQ@GKE)$C!yHM^DRcFb&
z47&}>n0;&^iOy&<m7>oNLoN+>#~B&^8-jo&*oul@A_YkzNT8{t$&(dUXzUlPC!80k
zSt~6*V3}CHh*ci`s%G)Rsa7a)VF>YJfah)Nq%`|q!-0Y}Mg`I6DzC0cIvB#BLL!7D
zkE%7^5xu;X!!s1n3hk*C28ncGY$kxV+rJ9|u7zU2e-rS#3X{M?I%@O32fVVQjf~GZ
z^~7NO5c@;GWEF<~NMP&ez%sJh=<;V-O1=bqOBUjPBL}fJ2-;5ROS4Mh)Pia{?{`Zx
zokO=8!9H!o4E*GQIk8(-#HJ*7SAhg8@^`cmy<om-?=DJt<KS`ps4h!n7h@U<XSZqn
zsN4)<EWZ081bLbWFX#9omqT;JJ!X93{`<yK(5Y(H^n<^^1{_XmzU?CybH~(s6HRU(
z=75e*%;yFz34$+Z0~&GqeEuF2q?F!JM4Zg70wksog=V_~S?bF!(Bx}Nsn!eS=ZWXR
z5R(U?_P*SVXdEqztZoIy)Z2@-fc{!E5Mk7+`nUeOp#*eEAWc3*A5g%pBD`fst)+tV
zW-I+%t6NTK$KGotqWlz@_Skg}uZVZ(LO~coFCX)|5JpSN7*i@E(e5N?V*)NxoJ^@%
zh0V>_4$j7^k*n~(lk6TW-sLktYH(j^5#G(zG{cq&xiOXDjK`Hr&~{i~UdQNZ=zck3
zt+RR_^I~GO?F=fQrpVs0y0%lrO*C{L8!hJVD4`&n@4=c1GaxFSe)ZN%!PF{j$N6O1
z17EVwFNf!NSE)DJ$c#gEEW+E8S10|d(lD2$lq%QEeKQ=xT|YbIte<=4I!Et6-|pQK
z0W<ZC2N25yNZMhf`%VoJdswVawo9mkGQ5JhzeMUZj$HVOB`8=F5Hy#WSXw@t=!!a^
zB3@j6_G00)3f2t@*TDbJhO>cNf+j*HpAl%Og|Tu^SJw3Ms>#t;b^DdWbS^(6de(DX
zVA+E7uCvNsJ*%~RDd7j~=Z9lcoW$4v6Cp9lfR8j?>4SwPr7GynOqpHt$j46<=J!me
zn^#gaw5;2g-oIMTNnW-*tds0%tU^@aX3G3Gtb2;`{h(eCskaVfp>Dk%8p4}@xwqDP
zjg=Fw&4~55m*^Zl+k1#G8W11(_m#llK!%_*A)Z7RZc34c@(@~<U6}?(0|Qgz&6WV|
z!?f2>*|t9jS^h6q@?`7ruf3rLUK$(ufNqvi($MpdX=6Fx1mqA*m~^whQU3lf<Shh7
zZG4ZZE6|F@m{C*5a}HlH;xl4pDcF53ZmemdmE60k4Clbr!bI_RA9xFFz=QD&CgCC`
zw~%Sx&?q`Fp>1mZpm1%i8mw=7eYod$5Ou;L(+cuKe|G{d1sD*cO^&a3@0F*F9o6Qo
zPpF^KWeF$JF9Ge>$AiyLGSvUR;<*U8<9sMdZ08CSaP%8}MCMv-V`&@{pnYEXxU@RL
z!uR{%1Mq1&Q@lsLt_FC}Ktx^#k0UYdhF3c347vR5?fl}a;V_w3-7<&4o%mZEBp;_*
z_iZ`o`!+-dp2xe>(9qECLXXRX`2v-q5o3sNp-ywtqV|)dkv|gtn@I6yxm9Y=m!>Mh
z<MyI`eAfD@Tf~#h41v?lu#QtA)xU>IgfR@q9Mhoo+um+y2=D75OL^Q6gtI6~A;bDo
zbN2bJ4{uae&$_m+G48}<kj>Pxi)JbrqWiA8HGlN&P4D3ILjS7hXSOUh?)y_YL*jA`
zD#dbb=b(4Q9ngqRI{FB}GW?!EZM-jq_ZE=2@P|p_K$EOG$K56%MwIHhlXnqT0y;qh
zb#|oG!AsCICORf&n)qC^xS*gO2rwG=Cpg~j*Idq~H8njXm=_=4-lOoIeXzB)ZMOXR
z_3!#@gZ25pIGG2S_5S8=M-5K*eVfFCc{nlQ<Z4&9$c=)bD&t8j|2{m~vK_PbqPCY~
z`kxRO?a$(8L17>9VA<Ad0D<_O)$Eg?U-wJ;!-6^~k#L8Ir>reRZRHx&zG<n0JO_X5
zg05pK04EuS6LzEATV+1EW8eDad5+uSV4SwAM9k^tpxFI|pD@zD28T-uOb5q|;)?(Z
z7@CX*m5XnTdOkgtZW6LUJ73Lg@>NTDe+o>2jZj*Bs@I3HJF(<Qj{4>EJ3zF_@dtDy
z;4Cu(CNoo2w6wJBT6S9H#X_(C<b=Dgkv=iIocE?)OYxnhqr?yUwl0ANCUP+}G&Gng
z^Mld!lYpK`@mLyNfmhH9M1OMSx|g1GpmXj!`7X);!LJkHGaJ&y-t;M;+l}CTs0hbp
z?x@TD_jU>eGxFprtlC0Qd_F^Bw_;wzW_{!;;J}4$&{Mn&k_p_q3t=y4c9SZgiPqSB
zjr(p+=XXOsBCEwqYnNUv?f4m_mKizx8WA>BIM73nRL}XS6&C;bEJLS!rYKeAuSKz(
z6VMuH|KK3@(P=nC#FwRli0a^`xc;Ers-U2t>X|yd4!o(dWMph~Gz&X>L7}9Uij<pR
zWFICbCSW0?vQ#NQs_Ze<0L}1)r`}N?ws_I55WY5@4saJ;*m0A3)8W1PH+b!W0<q2u
z66WVHEATkOw?qE2RMM37%7(epamhE}o5(zIU0jJjzutJ@-D9a?k9ib&Dvc^&{q&5d
z3)i~mQ^>yi{Un~%KMK@gYYyob2L`qfqfi@{z933h`0xQTVId%vR-m_>%ym?`kUHhr
z0d~1))c{Zd01aqt`wKPqH<YjWA6EIt)XG);y9a{l>$=Pso%Yl$Z&*1irF~CMP8dA4
zrBt3_=Ex?SHD|y48_ti&ki_sWWY4OAJKzFpDNlh$<T|R;%nof_N#KMwOW6knfkdR1
zhcgSPrv}AG9w~sudxAgP{O;mlo?E<WOOPmDFuFkfxnH{uVD(U&z?Q#Bs<Kse^C(ic
zYCKnoS$ApzA_MvP`Gq&0h`Fhrbvx|V3x$KA_I?Yxm{hWJuZE=H*!igyXjlAUEoIO7
zZ)8jYz&fD2q@jUzpf^Uv1<}Y#ymGkPqN;1&_#uxcv0Y-2iy(WUlxxyH{OL`yrH^WA
zwCEY}gU>5ubENY;IS*?3#q#r?)}PLI#sM%jyYV3tsL%uOsCh{(V0K~-(mL+~Eq8Ov
zo+|zwO*Y&jGH-ssE!)ZCl7u35-Adn3VGa7j22pGJSTc!^U19k`DeDY~qwOd50=Ggn
z-{a`sO&(`bS>kzKU^YE6qBqw}{UrK!qx7P%>6xVIYygwu5&VDi{9gB4YU~IL&69H;
z`HoU@$Rs}$MDJ<hp~}SVqd1_rT@tc#zi%#|x@?H(&j&}j&SqfP(z1hDtXpHfAfM86
zto}~-NFrM|^c!nG=pf`E9od7e<6c&Mg1k_3sAwsqk_~UfCRc^8ZaX$J?IyLiGuu8!
z`|;P2*W;y^jJnt@kP?$$&=TRWo~e{jm>Z*kSDCB*v!i!jF3RQ>Sfq*Y_cS6Y0x_Uz
zd+!n|PDD#5cC-Xk?=y>}mPrE5<H&Wlm{LwA-S7~;2$ux810CGFFVioR<PpnR)LYiP
z_?Y&uQ`cQ%!Ydb*d#Jej+y{D?vMrP)MYBT`?~z$QXG<&<ejU`Tv0|mm&M2wdq27Op
zdBMiYq#)<$ByVY1WcDhG4&?~=KdVr8pzM}6H|d>_fM;JEwUSyTr$!3&BnEa25l-%B
z)}7}Rt^NxDdcc9J7#0ovnvoU~^d(mFyn1pb6ho~hcaWOR%wFw&bXq(X=koA;u-c4h
zn(B0fGhMMmrOWCv7^ORb#S*HzM3J*B8m~uNKjx|18v%47so$%|LT#?5t^=&<4%~8(
z<Ql20lh!9MSBSV6nKCqcQZlu6U&Vj&3o*l>JLf8B%%aL*dC4l59SSJ7%~Eqc$F~==
z)&&Z(rrDzk%Qw3vs%)m1PZU1@#L*ARQ+c2p4VL>a?xq9P7>h__ZMgUI`RFa^jZ)@P
zWE|@bG3-+ozxv-0TFSE3dl`lV_RtetT7wL#xW2F3+^fYxVWv|A(7MoQve<4jA!1{>
zueiUC;<18B-xL%qw8%c(ZhT|oEOWpqf&9QMz5~6ZT24B5-s^D2=E@`*fn%n}4vywH
zrusJF=BX#s22K`D@vpWq@fThj%&GF~@5U5PT<h%CCFg-EVp$G!>VGy83~WUG>)@E5
ztbo<{BS+3kK!HZp;6;Z-OkLw~rQ~xV<G5h?=JM8=drgu99lGf?FM3J2hfPnN-RwAR
zF4GaR-AID`->+JF!p{NMs^5V{uxo<k9_v-hoGMgrKw$?L?-fuIn7Gi2358P0r@r<X
zUk9BsOT(Rp1Yx@`X<99mQveQUq{fVjvQ#J;7|Z-{rWj38C7w9{u43fE34Xy*C;x-I
z7`Zy3a-M@aQ+L$d1nK|SxCa>jwtjCHDo%noLG#J4o?+@LDwNW!jc~c5yA%C>;Y(>b
z#D1$Usl*zKrgP0k%r>q@_H#eyH(-`BN1C8Hx?^^y(w{m(Y*cC^kz?ksDL)I%J2G;y
zy7e#%lVR#)!WAp-Cbf)GmFUrEbUK*3256%lr{k6O*=o!0ChW`oASKoZaJ{PEJFdZu
zjJ#{EFdlpWR9q8BrK1X}61B3nd=@{)-HC4KFsQKKZFK)0_on0^5~0z45zvAPll6Js
zHfAMesgVBiEn($Z?leBn`#~0->amh9sq1kQFY_gS^B@y4RaWqwT}TzLC_KKFA~4hI
zqvg~nX}U4vG+hr@t}EP3aXa{mA&ax-u63;&z~C)2Lrv<vzljN8JXl!CsaelL9l6)w
zMW5J>t6?5d5!y}ewOrbOvU71{ZEo}bcS^CKrH*^x3(LvMZ0pS2j!JKGe@1>O3q4fb
znf#Sjl<=y5>FiTo>Mt=0EJBa!dNO-sJ}SfL>2Ky+Q@!^muAqg>`fbdn3jN|!(-0>e
z^X7fnyy#w44Gm;94Bw);0kcAJBaefbDydX1*r^>p5W+ll+pDYM4k(hu*r5$L1^RYr
zYFiT%6M!pm3R?M9;Qb^qEm~8fetV&5Of^mXKXp)C5)eH>8RU5XGoAfD!m7M8g_bR%
z&lnQ62GwXQ!AR1Lc1s4JW4T@7>Q8rVFIV3|H>_ny(@SyLT#b%TPI@gP>U=;q%Jg(R
zI5@h!u%x0ZN{_yn{>qELZ;9Okf@h`#6_2W-OZ(K@k8>m=eKVeg!rq2I9IO=;zvFEw
zB5Pw73WrCFX()Ed5F!UO114|2k7)hfN$;xYD%Rg5kAXMHjXjHqhd_iezL_melvdC0
zti4W#r$wUm+SBUIcPNkq8A^#k=vMSPBQE`nSHE%;vmLI6L^tJwmpWL}Wz6R=l^=dD
zq;?xpMNDnU-DZJS7p03DhU2NW9k{!bC2@!B*GtQBI-csJQc#J<p-}X6bmK*wm=dfr
zt>$*>>TFYpc4&{FT^UPaK+z3=tiMI9ltoYBa?GcmEL6|@U@W0ysWkEW_Y5WN;W3a@
zm~<YWfcqODc?;ZtOWJ5>Y~*W32t=VFmACZt()_W^a&gQY&-kO4N|D(ax#P{yO)-m~
z@NR<+&1S`$)DoTXk?~(1vXj-BAM3fe2ieubL`(fYTFqcQy0^Ii9?AFJU&kHz`|4={
zNjIQ3bda46F8_W+D6I7nxWoMPaa<}rUX(oOp|d#AGEFR&RlNZ%E_sGH(90-7PkqXy
zs0yFXAi7N;B3@Bvl6eC9Q@Q}n6JF35Ek_|2A>5>U;=})Z!3l5~-OL6sa9REWQonQL
z_h&cjs;v?CYIlaqPT*<a)bTh}-l`as%f6KDm!?-uTAiG^bTgYp6xrvl*|VqmshmNf
zJj&^nL<H<-B_y6&=isTo@Cc)ksjQZ*C?5zNC@hsfHr6WlY&D&8)r&W&--rF4nVuaQ
zN;6vR4EF-!g=@FGAktlLAAcv_eAUiy<5XkD_jo<1X=oTw-J>E%eUlMPKVpL5If2%i
zugYaY$3u>{kl+XT*LR@eQ21OCXZcTu8i87G5B!f`ib$HgjXA}1wC%G)Sg|*u6Mv#a
z3M}4ae2?dny)k=Bp2o(RdcKuqTA@-jlP8&spveK@INHcR8gL!F%4_lsm-FBMc5}fS
zGwCo{LX>3`lPEcI45m?jJ)-!EQg8CeI4=B>lK(nzhC#jjeVER+f=djzCz_6nM<j|7
zU$wx>a;`^%_MKJ5#j@u;tRMpR(ma{!vi4(n5|ltNCECd1daE|D272O(1l_d45|24g
zf@U%vp=^BzEdLeI@<0k+7E_|bM?eAQOKaL2@qW})enYEsiqy80bMnPPhm!6=THL~-
zTFJO<$##)Md)ENYf{f%)=II6PRdJ(4TOj{L0R(Dt6o~Ue$$}aUJ>%+$n>7(>xweH&
z2MSA+X06Cy?Hdu;b-lirZ8BVs;{t8qZYC1(_Hkncs`+DzC)g7!i-9=OQOmQaoQ=F_
zCn>4k6kfMz11X4_raQU6HRxvw<S}$y(x2o-%u%;bf$B_O9igmX&vixWePKh7-ScK(
z%Aiqm0kS=wtk}$dDTr5~>XwU2AuLE@3kgz;d7<)Hrr${|HPngyEBd)cqFuIZ45G$~
zqp9WDH(l0<FfA@A9dc3lUa7(_=qB5d2;4Jm-+OqeHADN4+w#kF%uL&r3L2dti5HR|
z$<p6QIShqWMuf#zUH0_ak-ggU+!@pWgq&0UUL7uQT@|#G#BG=nD5&g4Pjy98R#x80
zKwa_aD)8|KXis~9bN%5n({R0!*x%p(ol>qE&t&oNi7Va>P7+KAU1|kS3zM|`^h`Mo
zbc4k-ll_Y*i(f!al@D;kn!z<Hf3jONQjLwxL;tM5jrCI-j31Y#dR5`}o?m+~w)w~t
zUU&w_q9pf!t^~p@MX5$-qv4*(B~tvmKT_*>%A^KR@2R+zhO)olB?=jZ=wrdXLWZ^s
zVUY-|<UJWvlw(C?N1yydDU~CcslmkYiOFfZKrm!=l5YmE%q{1dfwJbt-Sz2y_(}QP
z{RqECvtx?!%-lP6k%~9=|C5zkLxq;g$WN1sH7|)pxEUjF4)Yu?k+Xyz&1Pmjg4!JF
zZ69-|Nc*kSe`024R_KUlT;fn70aHY#b|WbbPc!3kF8f^8xktpJqbAq8+DJ+81r9Xr
zcLX7*&anSadvE<!RoA@_(*gpLA}LBqBOOvIEg&6-l<o#;P(e|;8<g&nPC@DJ4(T{_
z=ev0B=a%C$#&?YO5BT`g@vzU@Ywf+(TytLYn%BB!k}W+Sm5pKhvr2Dh7$9pYn&k4R
zC|MW+i9b?X*M3UK_rU4;y;}R`v=$#j9I6JN3i?RFheIWio-?J%_0J|Eg4&V83d!gp
zBbk@@)Tzm3)1wakgO%pXU9lNr#gA-*_qMqPhWqQ*tu<8pf5SHi>{}1#q5j!m@EJh}
z`=j3V{uTv-%GC;xss?fJp?T~<4sYq`PtkZPwPv9QlGUn{er1JYn}<+mbj56T4ab)<
zs;bdk?(}4~o|)@V&ntLU@!aD^%Gz*a%%%_GfBZ!_gi{d^%{|->RbJ%s@mxs0qY)Od
z^C?W%l+-2o&ff7+qUia>5)zkqIsJXUUgRC2ZCsz<806QJggl%ujr_qn8oiP7*gtNP
zc;B&@K5u+7KU1T0WlGp6)e+h8HIYNbWHhQ#`d*Fu)wf@SeC^B@w~#Zo1fh>fm@&w{
zP<%lGep$9aBU{S%?@IHn>fe9HP1Iwmjqm53J!5bXaL+A4x=-d@kZJcki79aD&w_+U
zJphz}DVF>6k3x76Mo@ICyvXdjVtO8P(ZV@9J9Bez7zBx;7!T|=XkDM=(=ZC|D-tC{
zW&aBm0L-sM5<Ci-vo1_{oCp0Va{)M|35_amomw(_x?cLMkbmOfT0POZzQAK+r!0lJ
zEucRj@N5*qA)?25%P!577=969{f61NmJxM~P`Ur(8m}35s$uO)_Ko|WuwstthKf;#
zX+if40bm7KzTaApf<P4Yl8pa@54CrN)ig2c%V7MTOos0s9y^h(nxfRAneH6PBfm6Y
z`ipV{(<j`MdlaG##ybas&qd=2O`XER#nygQFiQp&=_Qh-5i<>5tzZls_E{Uey5TF)
zxA3&mGr~T3ZZN~D(bxr%P$)wHc+)F*`Mn+`-kPeHk+#TiQNoqK!jh_Q`ml|xq;L^q
zK!^93Q;+D+qL8=)e$AH!fL1@zl(I5M08E;#@4n3dr`YBRB61I?OF8DMZgi67aM(1@
z3l<+yt*DddZAE$oZcaiI%lf#FKh2k<ko{@STUZ+)`zyc94RER?8~5^L<GH%Gk7=tu
z5hlCI(v>-6hb+F%sNtyMjWTTwA_EeRbVP$_?;QlNWxRf^iOaqv9J__F*ltqodULPt
z_*^38VKzn;I$oFJL^aLtlrpHs$>ypQ3_(%vtY*5{+U|lA;kw_~+9G^hpT#I}X;IdY
zuRZzZIr54CwqpQuUOC(_w8f&q_J7H!9P5sfS20>JJvn9)H90nxH5tJ;J%M5o8yBWm
z$|JGzzQW|_H#K36G((9AisHYh>pws`0uRGjEIvX(BEK^bl)U@W)N~CTM;K03vKMQ-
zN%?bn;$dJ`f-wRQunU*HvtNXtt`&+McnItNnLr^d!09>Nqfr+xz$xN_W4Ic(D3f`M
z475-E?N8TLBGK-dI3}<ee(qfvgwE8t9YZILhgVF#n*Y)QX{qfgN{>>k_I_$zE|}r5
z-MCSGsVqpiw7O_>iwntRYpU?WckeUjW#<n^qgN{%{%$!uia1k#$7~<HA>a3A;50hf
zjEQ>X!hHMe1n-Z*x}j~o^x)S7o{S$F5`qsCq&!A4pLOA<Mc->0=>G3;xg;LbFqH8s
z{Z?~F$DE7Cf%JCT=qMMlTxmEKwIYhAl!<)|MeA2PBhG-9gP&+qkGJ^)<<H1(2p)}y
z2`<ZBsPLo9-SIEJh6o2d6!IL(l5fXWZ?H-{!j&706=gSiVqMBi;E>yaxiL!1Ub1Gs
zwy${%=R9++pP#i@%Tir8vslb}>w$R-Gvk70zgT0&+b4MwTqj(>OMFfdJRMR5N#Kum
zSH6TDXbBf{#P$PelGN1He0M7I^DV(#SJ*uAw@W8|yD&aCu>xHAU)v3gsunG>F#U}H
z^Cpv&4)M9J3Bm|kW4kpRGd;7m>xjCoqHH3UjE-%j|1`bGXaEuWjOV$fV>BKQU}LS+
z358w$GWHtLQiytR#}#(RgNJ{fvOh;%@`04H55QXr9By^m48J16M|EAom|Dxi^P%Pt
zlYI!VST?6$qy<l^>gBRwmirS@0BJP2jOGo|Au$rs9mczd<zVD>OrYfDch1}JAhKsT
zeGU@3eu;QL`G_T{11*~@wjajm*xeAFDrN{rmJ#8l;UG!F5qaxtnCF7m(TB-rgVlsw
z6&VJ?<{>#b^x@gLH8pPMM^F_HS^Oq9l4{kdCA%8wo^u7+2LYilyT=+O;P)I98ycV<
zyb#Xp*I0|VGY)sLnGsbDwdB`8;MYJDdS<_z_4^SnVTIF2=DPFgk*zGZqxQq|nTz$u
zg{_t{*Q@+8P@lKG(AfPP_i`?kg~}!-mQ8nkaknqmDMz}OA~PsNLXLp3z$IG`)x5e3
zQsZ7zY}*mzvgLS_FoU~=HZPH!Hpjjqes<7NQQ^{S^2VtOOFXVC9(6eHxs!2^&U<ug
zlXYEHD~|ugdG&MU^z&;c9jD`JVV;uNPim&a4L!-61yltk+xcm4yTa_E0f(`!hT1zA
zXfxJ#C#d6@TCch8TpK{vKGy$!b+;J(cJWYz-|)1kESKMTcamS{A$4XyW^1U<E6*7V
zD0kR;P;(|TjBk{X52-*w@EHn<t?%c1SkE~yvKjC7&Uy=HE#CJw{{{#(zKxy_<qOmT
z60zG%5uD%?ntUTpp560U_XsYW<Sy@W24X{%p<XVYmQU`(d$e}eB+ZQB9y`3Oka|~U
z*cm1Au0otcLxV*8oln7%&?r9j!)p3`yr(=cMx)@ySa-xX^|(_|%w|8!GNPtIR550)
zwbVI|=oeKedSCdu#@)Fb#VClb+<L3bIdt^6_EaCrsdAd|-gP~BqR2W1LCr0=&T90;
zu7UHD@@sqtS=6~L+Uo~1b;JA%9#@o68ZC;q`8ez+24MC+_dL%N7({Xic>M%_AWwOr
zW%gj8zM)|JWGhM5vPYTf;NYofG%4TJXZ_rBdObtO`uTQCb7H>lUn+)HPFu1Sg**<Z
zIuEYhEjkrRekWE}Xg#ZORSF$8dg(i<J#kuUOuQanJ-p$)OARglsd0ppN2Prvl^Gdn
zkq1cBojGCq4G~SR?K7G1++e1T7|0<%d#uUf2VxyAi?Ng|%g}Fb@mMoEKe@~q=^$u5
z5A(*3en*w_3)y)qTcbx$m-ghWq53r(wncrpAC$|ucG`J<7IdUqUZ#%u>T5Qo64}E$
zWTR=<lgZEOF5Rv-cja?`@z?M}p#fn^<b~j5j)4J%bIQ!fn&fKk?`xR7A52B11vfb+
zi|)WoCJ2(>r|PaK^{%@<wN$!XaD}K{<9#Fcd7<tNiel$q@GUp()?R<}(s`CX>l@6n
zPtZECYRXFLvY2R;J6@?UyD0DJ5qTPZxlx-bu#-xA{BWP&`FZ=#z2l1@i-Diyz4jg+
zb%x%EcSB!iEga8=>rp?fZ-H*mexCH<(#M6FB`B!1E18oRU9I@oPt*{Yn3%vmHGZGG
zj!V;$B7kmp=DfJ-E={!K$0q0c5=f03p=`hDi``M*yDe7^>d@Jlsq<L3(RgDPE2}!)
zA3Tazv-?J|O`P{E&bq(U{N@i{)aGhyws1|be?5Gy#R?$_?!D@s;C6C~=`bD4tgEsw
z?NHdWU+E!hA0x7yygYf>1erNf8U@y^I6$_`0LBjW(1hf5wvFdD^P%#5^0vLUx~r<e
z<*}FLuh3A<wCBn!^yattJu+*762gM>MhEKpIDP)oir(1zqh<f-*_kq-xl=sxS3|-C
zqBFb;$H@fG^v^KZtHUec#h?EOs_~@YmloRNtcaf7rM|iphJl#9ZnpAcS@qBtXfc?L
zHI(NbwI7dGwxQ;Ayo_TXB#%Afn&M<+v_?!g_1$C%%FUFr3X&H0MX3!H6$k4*&NqV-
z6t`Rtf^3>mdcPx%Uv4BszoY&$D!^sJZp3oIi3wdniij9{D^v6M+#`&r?>l7^F)AI2
zYHvDbd)==~FW1_cwZY7Iw}rl$>n@^niIkfCd!wCE1Ho596&1#*W$dq-(P8$q&71uD
zHJPr+BW%{#@Uj70Q4#aH4U%Iw&HN6=`!vd%y@X{oOnrsa?8ZGDhdlxBw$56un`_G7
z8k1`RqV!o=vJ^~f&p{TKd9k8*f?d3EFPfaq#S8VIFlqAZ&rY_-r2bQ<9R*9~#DkW7
zF$0%ZE1dkU3J~>hS)#h@)j9FmK$^IjNgU0~8TP0IMsLdLL^9{=*GAFWdzd{}W!enL
zx3_`+(s-5ZmroC%(Ho2fvyu3yNi=+GlFZD+e|-isP^<Oo;_y99WL-_By|KCQ$^)h>
z=6FMCCr(oK`qQ1|{PS-~i=*Wg5NN}$&E;yC3EYlcZ+8BZnTKea=9A;+zm`a>G=@{M
z3$>puDT<5sa`V~G#6YyiOi@k?TPyNs2g~dfzhFHn_X~WfiAO6tgw_b0h`KrtP)&eG
z^QtJxsIKp@u{*Q{WqVT;l)QvH>a*Umj)WV101^0xJFifWv%0l4Q|*|mKD;>*r;`AI
z{N5PXn;aqvYl}D=9y}60xfUQ5Ffe&J8cuRFeQgw8&ov&g9!{e1%1||HMU9d@1B*K+
z08M|o9Jz_b!gO*H=WNhiAZZ29OpJ`9c<B2kmZ&E<-l3&#S7c%@uP0{yr)FPhPkE5g
zRd4{yWwdo1HB9yl5UP2ALFS>DdQNeO#AQ80iY4xwb&(FD589!itNnEQ;CS8+!EifS
zE%&xclHTm6k-uihee;Aa>I`!|<O@AjWQy}GI9ZVohvB7<Iy!J?nFza*OeQySGs%34
zupX<3{65<9;_Vw~%!yS|cNj(s&&PQ+!fY%i;ymM}nC24gycH@c&Rm9(aqIR2qs$Lq
z5jHq7I(n`jjm5L;T6cEvllhV(PiR;JS&Kfam~QN23IH!KWamJ^w8!aE^zbr}Wzi@x
z@E@+M&o;kIl0DTm4rUOvd2Z^zE%0X8ENbr^{`N#78Of1T5Z&&u62UQMwWqOjD+xcJ
z!9Xn<wa0bG_H@lLI94%ASyWW?<}BIn23$IByO)S!6OcGTm)B|OwnJW5-3_Y|IEU#l
zoKoQ}+#;$R^y=@}E=fv#nFYG6572!Nh(2k3HZZtnvsG`-*h_?<f|3XFZ8iPuE%+Oq
z+TpQw*|YYmLv|jR9MkX%(ubUVgCLI!@+=#qy1q`<v-KY9L)nOBU1}aHd&$z5XIO&d
zhw)FBUm^WTdfJ5w`#qDb`h*hyC<OP$AO{Ba%ao%R#&B6`NVRmGQ3QQ{hgGo!z37zt
zm3E*%YLtk90u%A_0N(FdyY-#PJs<DLYZq_;z=Tf7J!!itM%D7Ash;1}d|TCm1NFTX
ztN0*X{-5xNCmH<sbQ|@qeY`g{4pV>3<c7bxHTAoha?AK5MFU&Wua+CtTMd%_=pBN)
zb&PR8hW;2cz|^`yEAR@@DD5M?k7gkVmF4AJs?q(eTYGzU_6S7^cb~L6Ca=Winlvn#
z7rZW7{VshI=}hHy-Hx3iBp#T=s?(VwK5<kI4h{z=rw%pgr^}z_U&OC{uxteBYSd@P
z&Z?3w<LR4MWM`562)8>b9DLU?;73R_+FdUzUX;#9I>P5o9YMKuDD|aSE^;z+_yVm%
zzy8U9!XfQ}S`i+d8LAB%DxYWf8#~qvgHUIx?2X;r+>CbOOQ*Xur-Ns3CU$a+n-0SE
z>tkZaW07xfM==UAsP>nbZyM~;R%51s+edu9*NdpBq{Ly^fnQpEc6QcP>nAbTv+M=I
z)jW4kOD(%RvNj(W2=*G)QVRQjHzskPUOZwmp2zmv5gh+$-%F-Wcl_@T)~or1M;?cZ
z%Ph(GrW5n=&Puz#@8WSLd&0Z{WWayav?)wLHVzObZxtf(Q^#(Eo_7t+Gg)WP#Xf_C
z@#wQe_`^6xb~o_I=q$w%f3)z-U0q+{^GnY<?~II$<>h6JT7RCZ$-3VK8NG~~t`}Pv
zue$MJ?&Ts3-u4}qP->pgMzGTnlaLt3_O8TpS;pbXyqcgX95rXM9L$iB4CX$73k`~@
z6q}J`cfUh=U$y;DTJEN`Gmx6wBD@=kEfLiSI8t5M9Z`&!37a;uP;2VrlBsFavI7Bf
zT`$|UrEA{x2J(Gb0gC)^Hdr@z2D@!CxpRLRvp9s5S{LoP^yB5#=P2BhAZQBE;Y)2J
z4d8eiZIGmaFy=NlPoQ&E=6qIbAO>RTKhHt<D>xlM)5JRA(CD3aS_%QKCcqE<=}I|T
zKcL}BNlSB91tH9onX6Xke|mxz)vM#W=9p@&=5r>)ZQ1hi58dhXhJ5O^9YJ82Ed1gH
zIIk&lGb=0Wfsm*B5vEi;vfZhMtgiHarX^RjvqJYONitpCs#(Qoe7*XEThhKTg$|fh
z`-j~n1s1pfJAnLVjUP#Ku`&-N!fphGUK_c*Jl%KSyuIBxeQLo2?3q;UY$}mxoPbN1
z-R<=&qV@)S5mI#Dl23`*F!P;)l?NVaXU_dCy3aiB+oed=t%mC>Q2*@U=x8}v-tEx2
zjiF`~2+nBA&dXEc#YVN5t*--VdXRDP1e)W`^E)=<{aCjP01koZk?{T109~UnciJN7
z?HM4g{xVmIISWYn44E_ledDOe$ffgv)Qxbw6Tm7`7Lo7Uu0OZZ(n{<Y9v;3qR`lR0
z&?LCs9TI>A*$g=LCOCbr3*z^q69DOqN@Fss73l)`ozs$^mm7Wk;(!H{*HjBd7~4MH
zwiZEy?U3waVbt&8GbrVYj6T5T##7orAP{QTZayg~sVk6&s|5%;dSK6ZB&N{`(4=RM
zE)=|hUnb~|CiyV3b8^gzdY;{;NPsWWazjfDN<iBW^&Z_A_7^uY1h9R^&hIZQacQp?
zS^_&;!ATWzNfslAfSB{3weU^DAp@MEDHqDhQj<FV?bw8aKt^I^^-HrwE6!`?ES`7(
z2r4ORYPuhd8@CE{1W$s~)?yTc-v3Bp(;X*N*4EZmQZgv~dW+(N&HN9qG70-Z+q}z&
zy77`ZYf)`|XB5+h^Pu&t&Yi_}b0Z>{HClB8vUOVDn@oI}q66;^&KzDgJY%?9`>iIL
zS<7r%0~x8v_Z<w*@`wLSRe^Ru(AW{^4i1D}Jj(IYyF8yc7EHXrA7#}^oU!d(yiKwS
zQ&a%p-G0MEFW(;R=jk)?Kw?KA=@>KA*Tcyt8kJ}VNG*q>f@-9g=ad~VeZy|M55URt
zHg@ZJoFX^xNc=N!1|Hb$x+_GnipcX-<9!@A!w*UC{l9y-`haRpxYSQkPGFet@skQw
zPK%B7>&UH6v!FX;&qd&G=LM)p#{N&~Uf3iOKJ@1Nw|qUI_6Z7VJD|U)3@*Xxhd1&g
zj>GU0z6+PKs04{HbF$<`V|1cvECB+qY)W>j>EMja*$^KWbo#;h)Z)FfI>UPBj@f!^
znS<9;9br%Pr4E&OOLN33TwFxsocy@!w#+8dhkd#0Jsp0QQR8oI9XMStmgejZb&Y1a
zb-f&oLEGx^U*=-rEqVg8q!VuP>;9u3LS-LO{DM^E7g$ZMFZV3hbNO~Y_OVS&oF+5V
z_tH>TP-ibUnvd{xN&S#oU123^awtUEEx%^o5LJD_a+VQu_IeuqoYHv-$yB$uDO|qE
zi7^7k7_f;olKH<}-`Kb;?p)b7#Y+_wD3*Sdc&3<<l_HJI$>kd`-ue>T1_3_REm`yW
zgJD4b_r2Ym45Q6g9#T_&&%Z`(-H%)%9Wm~buI-O-%<VkjGaY&3;wK|x<pB=uaQ|)9
zX_0E0DyV(=;_1FF_{rz@nTEj~@+(CJ8CrH&AG!1Wqx7TKmbBc9*Tx{-w=5apS3e;7
zCvTM4JYNLzMg$lrhpE|uh{fiBw}(0xx|{9@kNft`G+xw!Ok*@j_z!sj#)e{?W}^^$
zEbS-=>kGLlOUYRz_bP!O1820Rhv<}k-4ykPI&Dl?YIpy*Srl`m2m{qorT5`C6OP|e
z^GXVbb{zx$-K%7EPW#=>Uy?1X(iqax@o=W?bH0lAO<%2~q77fNS6-~N$o6)<U#gN}
z^HYDLW;cN(A&ufjnE35!VlVt%m<Rl)eibzBk{{JjKV@+cc@SB_#cVQu;&?bdHJ;Y1
z_EkMjB{z_|{<9blgRn+_zXxY2v9u~=X3lUw`p|L#+YDU`i}^ZsypLgx!P;^*#jstU
z0WGSlytam(Br%WqbI?|9EcJWN%3<yI$KZ0TnA@5oin&)Hkzrg<nAbrKDg`PU-qtW~
zZ5&2Akx`+kG<+d_Vm1*#NtB23#h69@bDn37ak0WWx6OGOTT0>R=udXYkFMsY1E54Q
z)5(WTSM*MR;YY5zwB&9cdDWe;FLih2h<Z%E!$6nb-oOl;a(M%YWig)fQHMg>k!7`0
zvdtU31A=NX*?7#Bj)0{s8<SHbnNKCo^X=fT{SGP}*B3JfJ(S3}nOUiJ)mFaax|<O9
zr}KT3OOm(6$*+sR`b9opSAUC+I(7Bil7{VcfReeaDU8|!)YS~p3Vk%N(d;TcC?7Wk
zM3!`M&8Q3f_F(KvXgm$uxYwF9qjkQ=g4Ld)36iAwd8ovQtbV)xwc)HxJ3a;|s{Yq^
z4w(gaIlc5$*CIwcP;SVMtaln*I3j>-8MZI5B%M&Zb#_IcD>p>F;3+$*6c64XB7fr&
zlh4$O{*n1?piqII5SEa?_z)Pkt2#xM2s8w-%L&Kqm)YZJ2^nh(kG~OMF_A<#G1PeK
zrg}n83#g<bi^q9B41RcSr^>7ot}X3pG@kMua^f@iGG6b`bP^WCd5{fvr0qQI2sWUZ
zv8A;-hp;e5{~$V&SM)1*EF%c;IIlnK=T2@Yy|%GC%rYYw$oJ$FRV^}~thdzqu@zU$
zS<SQ?-Id6*ou6p#{C%r0KU?Whc(fyjJjWw@$NUT~m!enqS2;8WhRHqcBXhrNhF42>
z2<!)86?!n2=%-%g7b6r6^6<Za$(1a!`SAGDOXdx)Dys63awXHR=H%tQgj?CmZ8=iH
z4jHMl?)D&VpEzca+YH}Ge)VhYML<8<`pC!|vNWo-+>C+7;ndtRYPCo{>2`_TM}891
z3nnMK9{tUp`5q1ZGF8VHtd8s$d<v>=29q@fTUd13rn=6K`2%m-p_}CFKO}ZV`1i4I
zjeLp?*sAXyPnYh6;ubxtb2^L%k{-<*M&g}V(unbceuly?q~HIvnVN5ICS~<8Y8lK8
z+LmwVOm*e4S9KOw+HI+=?@xWNFODuw%q4+wEa1*#uksY{b_e$^MGKICb4#eZpZ6Y=
zQa?FS$1|DCZ$D)eNYFbpkD@IsEPh$RhapMJYRbN|HyWMkyj$K+aFNGvS;P6LRo>dh
zZ`iu<>DTCop)2an;5yT91RnVpkh*)PFzFdM1W8Z=P3s%n!z<H>M8ZH6$?M*>hhl6f
zUufZ>eiW1KNK?d7#Zjajt`bhglUgvUMnf-S;PQTuZ%z2UxCZeHhOID6GYU*b8D>li
zs$F5NtXuyS+q;n!Jfe?ipN(83=KLLl&6UB@?>A;d+lSH{Y?!T?g$l5}KzXv~G9MvI
z|KRSRrNZiN*7<17;v07P5rKkG4>yDN10oE2<E5(x>V}N3xbMJtzu0YV0BflA`o&n}
zg@Dc*^+kD0=NC!tFAsAzLhGpp5$5R4;;s<o7BmZAv3o-d?XJi|oxkXh3!Ufbi0N~l
z#XD2;8tqM|YR{@EmFKP7BD7kCKa9nJ*@w|VTw573>nT!LXEkY-ud_nF#twmao!7%b
zg`=Kk%<%XGCVD_Ja%jHuRnMz{zbeX(zMlT96qvBcQ}Pq(`7w`=z7q{E&Ger&1&4&5
z0NQM9fJb*YZMigGs+X#Wc6=F;KcyOlH)eM?*d$?|gKJBN;aGX(ee!}ukUau_cP)>3
z)orB{wv8aD72Ti3xu22bZJSF!TjIx+U8Eo+{*7|NUWbTwr==y(AB*dy(885+0bN;m
zjdFI8-)hKsYf0-C64z2!T%!eyOXLD-R1#DR!+&9fd%w)kh)WG-3pX)~@ryNzlH8Ne
z6&um8?WZI*Zfh~BDdatCtAu>q44X%3+1QBX)!FaR;IQ#K1;yb1KC?D<g!*TYd!0U@
z<mpvoX}d>yUZ)twy>asplsmFKMHx9p7UOEclcnh{8#Ohv)8*D16wr_E2Ka>sRRbc@
zi01mB^D<%u_r{%1FkKM?Qca`E&bdK#TkA%w*Ei!1(&G=N1vVfHiZgyzE_>kUSaxqV
z$rD1{&){FcW2yciG`O0E-Ve5fm?Gqc@sH5A3f!;&?%~z;#d{N4eA@w(nGa2IVg)>V
z{7Yqr3Z_TP8;q1`UWe$lJQo#_hU0b?3l^7x8rEiS#l7dW;PIbQ-J-L1e|VwVo0e7T
zdhOU(JcGxAI<=eMc64~ofJfh6o&~4vV5bDf4Si*T!3UF_6Q+>z#x|+HhaTj8kTzoR
z?Mrx9ajn4-ZmMU^J1ukKk=p9ZVH+Msp`DWVy@~9evTO#x61B)~aK%1dI3ot!erB$C
zp9Nx!{SmOK1e{@RPmsDU_4h$~#SygDH<;;;b?owU-Md&@iL%stx#raHIUe;P%6}uj
zHB!1f04cop5!Z6>qj2H5bH=wXWjO}Flk3R0ah}dvKOwDlJA4>WpmN%m{jqv_E7h1Z
zRc-adkHf%sQA>0Hr&W%;Q`7n?A`~!d-;AJKpW)5AsQQv$zgQhV=TLCK_A0(^)&ctx
zP*;M++N)JEyACKcscPbXXXK8L!Xpm}f|+Z`(m*`mNBtRsRwdV<*^-zfjmueoE!w`+
zWjb+p2PJg>1nYs9_ag{@d3i}18&OA#Qm4kvgUGM%@BaQ7&L5g7!*;3s7HU5&bRw}j
zz9g`&x`0ys4!B;+d#|AIZ)6gMe^}+y(Xygy{W~FVGDY5S%WiN8Xt*(hxsJ0lhfzeo
zi%dVN;;Y7#Bs7+`cFWqVs&SjoS{Ih`9Zq_OKedkWpzNj_E1N7mbnZfu>EN2v3(LIa
zH+T!{0Hag?Dy!WXK}<R0r9#m9a5c?|I!=G<Fe$B*%2}@buT;`6Y~5i4P=T#yrAIpu
z7M}YEelT+apBVlKj&Op6<=}9Ait^C|MPf`@uB8wD5v@oztfZS*j^-iF8RX2rY6|UV
z6*rPKSzUb07_DvID5@=||D50<34n7_Z2_Vz^ksIUkys3$J-hikfcOHDV``o!3mhDy
zjO0rZC0qrA<EYAPyh@obWoTm}gnxVvI3H5L6Y1F{{B%l5rK@CUD9M2smCh>8BPM6R
zFb73-Sk>N|T`&(;osY$oizkj$r1n;PV;S6E=XD?<6%NlJiZI5${opz_c`NY;!OV`v
z&UQnIRXAN*^Mt|XS6GB22$uqhPh5x8h*qL8&0`DG$4b^FLXF#B`;rJ1`M_mts5$K;
zgb$)Ue)ievI!>>SeC6t0dzy!=Ao6$h>{Ey62vLn=v3K$m)z8ZAx)bUw>=DF51Ys;G
zMTjFp&n3LTh6w=1-{YBVTd~kHDJ&ZoPP(~wqnXv(4YGfg$oi@JhA-#G93{rp5Z^aC
zYCDgeDuq3cgM+%Wf!AA-ob`i3U-1WL5QA+Jul(m`t)=WP9NG@4WWL=N%)(Fs@Mv{|
zXx1@5$ganH8!1p3e^lkR`n_2!GGGAO3DH&w<Ry_r9;DEN<SRxfys=Cm+UmF@ij?6k
z5MiqbB_ly})_G`Z-A}=HhbQ*ytJ&`w@wF}iw@3s<2*V8!xtCGI&WYq&mrX;U;y`QD
zq-yT01V?!KxhKZi51oO#K<POnK}&Qnw|=>kIDu|c^i$<&XlyPXIa7hY+>X7)aUoqR
zr^HctuE0Q%$ooo$)|xkO_+#M*tt{DE`U!8%0)_KU2)&}EXG)LyKzV!!XZq5duInet
z%y9MfhspA-^62tflNMgxCZCL=Qb*M{l=0e8E_B6QJz+D`4gJ(<qHyL@zXy^eYf@dB
z!m8NxEZL6!YF_-N`9)DZqtB>g?DX+=O^BnGxus`<HM{BySNZh$aROH5>yg;z%}IwU
z?~%}>T<RY6NuK5|V65WQ$;kUBrNJGMdRA|5GH6mS9nnp(W7)~YrpC3+kQD@F<vxpL
z@ExJiM}ZZH0l1=MksZKBuiH=`RG3M<`+V%QIsM&vuq!9FB*oR?aIB<Q3dv*nyl2nt
zGADado6uHN%xKCD0wJF}R>@qo>beqWEKuVuwiOUhniryUJqR^E`ZkAm{Ia~z-uGP+
z??+d;>NbOBthzmuH<S&Ts<`*-jY+LwEDd@**xHL`z4QuaOhyeJTwDg83pxEvAE?{U
zUD@a)HnSfzB15&9rco*Cn*8pZDkhOke$+K(eJUY?*>L&hq;K%qa9M}qlF*9ILiNYd
zd@O;>mC6nzt3coRz(Vo!$9{Me60pno0pNX{ialWjX2{B7D$7t>LE|y|Q*^h9<C}mb
ztmdmtTR<P#rl)=@iF5r$&DLw@H~MkfQt*~^+NZI~RW=<>1}Fg==Ft)8tVdnXcnW^l
zSjRgfd+wLbv3mvm+%r|Ld(0H*b8d}3b*hCd0*Uk|Fo;L<!Lrs!#i_k3Cuu<n%R&)`
zyT>|<=quXzNn28?O4(Rtm@%QGt*!F|9Y;C$)sZj6k$7jZU-8{MaEV_~h2<@VKV|ER
zF>oTLr5idg==tYYj=F`${q17fN0z(}GDZ9cW7`Ky<U-w?IZ}`MLbV{8WRixB<#P1<
z4kS6}nSywP>qj_$%2&ZU!lwsvNxo;xci&EnK{8a-=n+SjGtQvr<(V%p*O%0;wDGPj
z*5>i+fe8w{UjX^qYw#_FDg1Fw#Y?W*``KRXzU$m(lTBHPp@H(pg~j7>p)fEN9MZoD
z{hm7r*@5q5@8Gyy*qixQPftXMicH>-aa4zVk-4yc;`m%(n2QZY9YMI~h7-}1+tjCo
z!z$m`o!Gr*UqEBJUUJ&mg$m-dLz^(l$(r~ls}lRn;hG(>J<78sENw=hul{=H^iN=d
zA7R}SU?7@}MLRDZ=|29Ptakh%DouAGV!KGjFCw6S*?|4|boubpyKYB_wColQ9)YWv
z0=5-N^i>gqPGcS9K$ESOk2n*m<sj9NoAQr@+J9$nGZkPC(maV<B7paQRi!LL&&Xr}
z@Q5DuB*OsGAsUfr<#0Pn0%WF&97*5wAAvQ)OLm#=-+rPTFxRV*Ev0O=Uz66zSUmY_
zLI{Jtx|85Ph8GoKNveCvpmTL*=h3mSj!jzxObzMK3h5LcR$|a`+7pxQu&g!=067Sz
zR`drb(zU%wtSu`^qrJB85`jXT4EOZeVBUnV56CqWo^T7#GYiph8k^A;jT<v0(k0uB
z*sAqtt5Y8rzA70I$!zE1^&v3LOKdbs&QB=VL(4QRn7_wBk~iI8cfB69;Pp{17*-ty
z5yU|EUizIqqots=*_NGaEmNA-$j&S&+mjBi9GbX1|5=@-+#-{x;`S}O=*`L_U-IBB
zq>=pVlI;w~mU)aBk^m^13K93A4c`FDt&s)$5_tLd5I%~#$Tr#`%vNO3V)Nziw!9zw
zo;y3KQ!7)jhEeGiC<%Oj^bbcmXNf=ZWi}LV%9#)=JQNE+L6d2E_uL;BDkTLN)w}DC
zrDMm~A)}*Dw11I6h`!3jMf!eFJIZeWUWlJj7bR1nwRP<-dN_{8*<duN=!-g2mMCxc
zFm!o8yT4Zn3!gN$p}j4v*{WV%HnQH_JJ7b8On=&)NTj(G+WY(-Do=#4e?uAo-%NWl
zf--QuOhJgB{To-uU$P;AC^g-aMc_9Zdo-KStfF&phto$JlrEd-2y<GSN-NPc)6CrO
zQ;J#)n0XEBV(*L^;n;oIv|Lum@=Mr+?rfiaMUNuyiNS=)KvIN2kbYB{QQ^w0<;ZEx
z+l;yAq~w;A;KC<BSP0D(<%B=0zOS#_$oGr#tHN7ZD>t$T6r7znR9UCpVE^`^psZi@
z@x`)og9@I@*Y2xD!R|q|M?yAAyY+|eX?pLCXZqzOHSxNGsg)C2)Gc2~ZxA0c;E<mj
zHmv#A_9a}JQ@+HxeQ7BV5h!sRKL{Vc2+4U4R1iC*%JVEMCfpeaa+Wq!1~{f&zCx|E
zPd(i#9`}B?6EQv!eS-WQ>)}B8<mxh{>YbykM)$=xmKiD{(lRQ`{)faueA3<SGPsAA
zEj<Pb=|D4ykMpk#gn|fgi|L=RiEZJ<aO6}ojAgg2R5%rsz4^L?J<~rxp_j0C7+Yj4
zsu>@e?rH6{>m*}v@1yK#S~F3fme$6)h2o+;@QG>ePgK4;q%-A9z!94e3!C)X<s{Z2
z;}o4cGEZ+z_e=~4a7{D+D)1*%yOBQ#XhRHu>$$l5MvNA>&q!Aqk>P$d`&hcLi84LD
zdi;l_`?8T3Q9qTP7<>iHZ4jHXbRtU&JPqG}$V&GixC>o33${WD@_iwlEkz>kWWixX
zdu^&zK(Gija{NRuX?mk>Luui8><6K6PUdnpfFUI0bm}fh-8_&f>6Z>PEqMqWvQt_z
zUh{CMn|{T4&9_QBD)d#^oU%XwU){fCy*yu*hBpc!C*6%e(^5RA$T%>Mc-VLso2EuG
zBhR7l2kkdnL~-ul6Ku~JI5Zx0NYb>1{ZzIxhVqp!5665RGtzIj7!ZW0J^2@M1N#Jq
zY~zh4sDeIqjl!d-1A0;n6u=t&1NQ!K+53)-CJ`D3tqjZC8|lf*DSpyMz=-+mF*PZF
zk8|ijetWqgCUxsJKwL;#OFY<%hAB3X$zI}XUfIWf4S!25)lIIYA8BCoc5q{Um_aP<
z1GN>kE7VRSHCCnp-AyGnp%;Y(7JP1|qR2PrHOFae{vgJV`V%jNFOp&G#El@9QME`5
zCAUnzskm>I#-jzjKffug2DkbwhtZ!Vy8JvOpLg^9@$i@mJ1u@15T53uSG9tes@7mc
z`HG>{#5rZBuqaY;GIZyan35hI1jWv2y#<)~e|};c2#YBEiD`U<A0q|)^msG9&?3n|
zSWy4lU`L{LIOcO9*VEp05<)|Pfqu5Z8HuUB1!of4{Mt%#k6&zDv=-hi5e481Vk+hi
zzInYh7>&W#CSVuvJ!(<61`>lMQiX9^KjI{@Ak?kI*|<@i&iV^9=GcMZcmt!dT=efZ
zRARJ#<U}{C5Wh{6Qe&QN%itWLAilF^{_zz|x>7d{G)YM<=7x$P)A;s16yg<#tCC>P
zI9H|cBBlfgc)iI~w%Q6<H#SEY?38aWV4U<*WS!AHAJIwuAQMtr!xlFrW$2Ne-Z4Q-
zO2&1c!t&HD)$+|*tbwXL4<IT3$*oEP%S{U(T!8)Hv#<{JGo|2F`!#K{%pvZ3BQ|Gz
zr83|<QvP%|$JNk_7Wp4t$hW92oKG46y~4%X;IJQ{z^8r)3|38E$6?@>-pI*gHT57)
zF0wQEwd6IDT3Z!>OD>Dc*xPlwI#cVi&3G#o#q*(20=cO7k&`|OlHC_?$-@K)S7x(@
zsm6B9$wALr%%`V+MMBTu<@R2{(wF}`3?O_8(okOFYB2BQpNNAF#Kp4kFa2%@{NJ&!
zfbEt4noJKyz~-OE(!4?99vPbmmj3V`tC=7NQm7ZsAADh+-hV!ZAb?OAU)TWkHu(JK
zDgA-4U<6S9vp|K>!49Vg7y1Y|CSMwt&s;s!D{f2sKtDhR1yy&Y_AaB3upsu^qqWS#
z$a@TWm@s#Cxygw;7e*k9P`Dw1l;^ri;Yc+4c<H-X*eBL^qvdz4nFVk)T#B9F_PxmZ
z(dcLnnJ~&sfY%`fno_C7!16(OjE(g%S*vP*@$GO&WHnRDuTrJkLHTIjWY2snJ_KU7
zAtP89YSmN}_p43Z)BtD}5tG2&7yT0m5xljzq<w`o(DK}uiOx@KD~`lrlVlVj1mLOV
z=^85lm3<$OD*svK?wH%*4x!zE*}K~e!9|*$Zev*Rt=N4Tvl3J#y7NtO6B-`bDG+78
z7GVsSi@m)&?;zfER}vQ$3E`G>FE$B7y7z1lYTsS^N5u7?$LSM+4Jh!q0T>8AKt<DY
zy87to2v8{HlAosX0OJBtwo+@TPw6j$p#}hj<3_~Iv<e?4>^2#Mva&MTWY?UgB<OOo
z*SxPC!syV@7z3=!epB5uHIb>Rqf_`mR7)_qcjIt<5U*y+s^Tib7MN&}K$%Bh?t^$3
zCd~TJM`0vJ|D1Qs!ylUU2oACt9$@%Af8=4-nN$GIyv9c8uJ|Ln^6$*RM*=Tgq}J&E
zt<=MR+XRPy-}&F>Qz%eFka8)s*})-4BWNGuoyxCgIe~UplC7fqHvb5yQpt<|0RL~>
z;K}*|<=FqwIi6GSBZ0VSI(XJ{nHkg+q0VjAq8Q!6x4tso*sD#R*Lg4y-3_l#_y@2z
zgk8BtUtwCk`S{<cQYiOhV<XaY{*C7D8Whhh^zCtSvoUNmhkFAwxELSG3xhwrd;k4u
z@DR;+ORcxo%^^%cy%=VO{zNUh!}HYY;GM8G4l1XG#bu#%cUXte@j`+4_NwPuFF@Kg
zwRLuhk{K`CMg<}l@{vC}fpZs5*XQCQ`%$W;#0kjkoz^}U?#d?Wm&uDLltWt>5DEp>
z*0&r^KfCYC6$zC^*Qid<+V*08#Vo8s(8@V}#b0EwM*BHhYt5+!+Wl7`Lm>%fFBLq{
zjCB!7si6c_??%+;1%kf}c`aW2C^+|8va9M8Iu=?sojc5gG`Pv9<-1&$@N0mI0fM({
z4^s=yzic-)%hU~R*B3IPZBI-MGLDgHUiMyUS)_x)&*9V7>vH8v!0T11U!AKdjJTd;
zGSTHHf~5jT-hfk*-VQ)a1t;X}@a^<MhT7e`wI?BT3{q9l6`i7?!p!Osc0JeLR1dca
zs|yP%+@}?ZUZ>-phY-FF{*~9!(}|Olj5{r*=fl>v>OfQ2&3ri?CxVS{XVW92ixzgm
zDu8ng{#iyBkLJh)JP+hlgHEB7=%QS?=-d_<+}kQu=j}or0_OCW;)(L78>$S}p54wn
zwiz@^*G6-vca)=Kx7>HGU!`|05P3AGMsf>kT`lPx4~<=|Rxa=hIA8tl(5Y9l?IugT
zK2HYn0gB_G5@%vU;Z_z2Os^8K5wzo`2_fwT2!r09nk_RNjqx9PUrOKosDzcDTWa>X
z_bgy?!S?*(m$Z<cGRmxr`qEATQ$di5;u`<S+rW&HZSUqhqZSfIXWJbpp<7(HcGhza
z=t#Z5%({jm(bUP=6>|jaItt+cFehzb2s}kdCK7-oE*ZWcvwkeE)gM-48&(wP%)#Kc
zc+Fd@pQ^0yWu_eW{Oz%ds%j10ol(Kr3;*L^oFSjFDmYxl0s{+I{#q+&z{DhAbMc9!
zP@uhh*U#835M8k{YHSr;Q6V+Kz5XN!sV1Me!g_AD#L-!;8-?*F3h55rJ=mVH;vyhk
zTkwU+n}FOrJ_7u98u7+69Wn%<o-*G89hneNG|Jt~&M7x*l0i(O+KlCCHp>WXB~ZO?
zsV+m`LZ525k8!J~0Ef_y3p@qskSlCZN<%(bFt?Stb=W$fldX%xI_W2{kg37>V>Bti
z!Ljm-G$M<@8|Aon&q2AuvR_4Q`lLiBd33|rtec9B&1G)RK{p>&!QBd23n1YKc3mRZ
z17Bf1oF{^ZVL>(Z*0`FE(_V@Ovq=&u>^qyY7|4kUN)DU6^loCoie{@|#nOvw#2<NF
zV)Tx+`>bru-pf6HkT$U2Fm^QP6*waPm`Mkc6QG_X$;l@~ce0MRRXiLi<kq9e>*>WJ
z_1C?F;M}~!7sRbm@p0kX`%9$jP4m?<AFHpcMj9qx_|&9zJ!9gfr7_p%{#v2^DQT4i
z3qqFvyq_-mB$%geMMd(fj#u@0@vP)!4$Z(=-|oka{HVV+^N?r2ChuVo!6Q`3rDPdg
z6K}RB=WFPM(nTe>8J;%G(j4a<zC?yDlO0~(`65@{n8V0-HC57kRe=S+m2F$|1(=pt
zw#=1sXTHR5O1s@|Qp_jZQ26pQvAgN1QY>`^n|QNsa@5>^56K%MZu<`vxOZj$A1W{z
zQjQR3J$kj$YkfrtD+O18x$w$SRIUZ~wTw=u6U@Y&YD4%K&YK=XnSN9xsVbPvinO|P
zFhGNUcZ9xXJz2Kz$fSN);@l#VB*}i7NrQz0`vyJG)NqxNwakD6q5NM$@7kSiT?(h}
zn5T&FQ_+uL3uph+)euCaG)E?5s11^hwf7q=Moc^y58}V`*dKUlv^_yduw%P%<w9P7
zb<TTG!b)%((EdXk#|5arYyz3UO<Nb&M_ak=pUp54ZRqq2uwUZ84i;y!&ry)B+v`2u
zVEmPrrM&zB7eC}l|9+2q0w+|qG?P}hbC3`^k*m6%S?8i&cZ^LT><tHxfP@OvhrHpQ
zrF=BZ2A}_YNztbx47X*SN&BBm{{0$5LKu#`uen6&=6C;oiM`4~0e4(682(Rl|NR<;
ziURK5s-8OiUkw}(Vtb!Yu1Ws)*8g0Kh>Pug=b(r&@~;NY?xHqcLJz3^?dHw3KJaL$
zjfk#lQBr?3aEXjGcje@Y`=>|X1E^d^nu8Z$l&1cxfhz<A8!vtVwA<cO2<r+XAnbUP
zN2UMOfUp-ld}Tvo66{DRSSjG)-wNOBRQRiblm>6OsaaXMzn;qfJ=Xtwtp7J#|Nj|*
z#tig})0Je^0?qLux)GrhpuB<gP|$sCAbtErA_$>?G$1c1_uMq9*fCQ%0S6{sU7c@N
z*kHyB93FKiHJ-q(QMK^KKoahHpggDJb$K{ZX1-Rb57Zx+A39Ijw#K!@mfAj^9nMvK
z_;${RcQTlx^D&Ed?c2+<!_c$P;Mm8Hs<uoP6&ivGnKdP}J%0Psz6r-E@w+E<!RkAz
z?PjT`_q8=fU9Uy+P>d$1R<_w+-%2bUu9hgL1;$RLG&F`%ikB$5?#%r_yo04#?|yo)
zHi%|)`4N)8A}4eik-t0x|F&$Nd&8AG+bH=0NK;C7OS9Asv0N6|N4|K9?>%~&;z)aI
zw{$6yJ%M;;+U%W&?mMx@N!hj!Jx}K8sZhMGPFLuJfUYDMscQMB-ejTVxwFM^xeT`5
z?Re{Y$yxj(=;SdF=YURCu^*0)U99I8?s;0H192?3Rd8gN%VH@1w&oev>hY|X*WO~g
zMVHa{&5R7A>#NIgMVUvf-{I})_C0}66z?pM8k(#qe54FY+_zTyQ>#LM{rc7V(CgVo
zmx+%1uIR{42See|eP^ylp_94yK$DWTqUd|ja8Ta<pq!A5ABY|a2N=4Ig}eK*TuQ<M
z?iWngIE&xB#lkaF;!;d@S#rfIG|FlFP8T&^E>l`B&dl_Udc<eJVO%ip)*@8c;|?d0
zqkH|&Q6S*Ry?sXWf`)@;c`5Ms&tGP-V@KeKO{yTESjA9$1gP4wdEMy;Qk|e&o<?cK
zaviDsq1Q!mb(-O06Z-Ivify4rmNTY^Mm2}2!GdSt@)D6m96%W#tj^PDlQo?%u;-WL
zaVsC6?P+DC5P6EIa{Tkx=aJl?D3q$!i&SATX^kG&oKB1^BI03gmgE(b(x$w5aDNN)
zn2e{*ta7w+^FRW?#q1*%Sw}0zOp+>z3&UOWlZwyzno(6Sn`fl}a+r1Li<rdW-AOq^
zF1ONDwfX&V<75x;!p#x6zCIP<D29TyA=hf%aLGl-UGw93+F7Rwx>4AmooaZ!4^FU`
zT4*JAW8{=H<i!mx_24U+=F@LHv$IoCfDDdn%Tg5XstOoivv<mt)@CJe#Ms1G@6c3U
z0U^EdGg*Y*bbLE2Q>UYtszHvE-o1W}9`CrX^3(b!fLXnSlV<qa)ux2t*$aI?Jr7Pk
zZiV>M_I3Xe$vMkJh)xk=?cuT!%)Hml5oR-EgKkzB*mG{*qm^26Ttfd`<`H)}S^FcN
z(t6V99a2#oO-&G5vw!yZ;~uyE*f;A3*A1-tjTV6!%J1Hkb>CmT=Fh*Ht$m{vxIX-w
zk@I2c=HmRsnXJ?+z1}1NylXUF_jeuPXgdqh3hY>s9pl96YV)HAX3b81Ek9jy+1h#O
z_-b~?Q)P2{^QXhMX`NL~?o{S}eRb<BG&0?n5R<Zz*^+XKE03sEfE2Tn<P2xbQ1=|$
z*?-q2aKOXbZ?Ws~uaERx8UK**R9CCxwdFT*-`b-D?Xo7Mo(ZHLC-ZuSc*}t^y%iU~
z?$NJ!G4=)(PPL;vLw@F6Y6b~6>YVOR`AMdE?K;OVdy*~!nBzSp;btuK7VvKUlOhx!
zs>xcL`0bw~=Z$!7LB<Om;VywyN1nN=P`zd821yTSFLK@W)j3)$-bbiP&x0cE>K=-H
zq_wS>X}e2-G-CQg0`F284gP|%{Ao*}{DhqZ?x<O?CTi~{>NKu<e&p3^`O2lKKhcyU
zxX~W$_Dcw!N70z!B#?XNfzI%z2-nW~keA|kBQJ*N?Zbid;YHq4R5pz*Qj%v~s^y#1
zHcH}>m?`g0|1hxWG7@^BS@Tm;rz)Z_XXLeMIDE|l)e9rqav9ZVBMh~w>dPbLx|S(2
z8?h?G?b@(JBc_5;NFQ1w@3Pl*6-|e0NoicXRBfK7fIfV#*{e<d7pW6+99>~0@rfwv
zdY;3Ka#R%!>!}Hq-hnw&N1*U-*<<TsP&5c>m#^f^$smJ%G=k20XsYGWtyT1H{3NXH
zBb(O6Uw3#XFpPa4%hI!--kP8GwerhX7LuOrN2Ze^GGWhvI;(5CwYGeZ(<-pzA<U++
z$Dd1+6ILTX#m^>6T}VE1sXUaS>SXjc^Z#)gX0vC^-2H%6m0h)^i`mu_JJ%DQ!Ar~Z
zNV;EL%}In^zIp}nQ(dn_`JK5H6#|{{cvVf_BWt!%9d_bSqSKh8SOFb+*@ZkVvQqmb
z_xS0Bh)fY+@(42AeobGLIFO5MF~}MCiRGJp(@UBFi#+NT`J_AE36MK=AwAu5>Y+R?
zNeZUKDZ6r{Tp@MobCi7~o`N)Y_<BS7_BA!O++B2z34`FS;F^R#Q0&=eqFtk&UXr`B
zq>rGCpzY*}*JXB=mf~K;@s%T%NxVt#on|$aIdxCEAT<0(*gH0*mab(RH%KLC)<wb@
z2ETserm@i&M~^p}XY7+~yB;`qU|?v=GOX>aJ&XACYIf6Us`wu6$G0;jROBxBqBmA;
zREL@vjHN6&m7JKqh8neU(!;GJqezt@*i_<f8k-C?O%!Q0Pstmw$?xo=+LeMG&p{(-
zw$s(Dq}=NGVmmaLccpEiU|-=v3#-w2(caGGYVEOjMCs3jeI9#*l!QTEUs6sff@-`c
zFbhUlw;4H1E$nUh>yd-OAO61MoB06~Q4vGoX9lsv^dxDLd_+~85_)f1i4MzZL;b4}
zWf?|;OmI&m$~(Hr1>JeRUj8D~Nf>c{vA)tD!`07`ZYH#ACL-#I<UWCKp3__RJulAg
z%%~dQt_NrRqBq1o>1|N0A5^?(<Y(?vm<R?!6%sJP^>!uM?u~}57&u?_y}^EABm~@7
zGf`#M+J%UfKZtjtmX0dNaFkESP1de6*wK;2Qp|-s&~#sRFzX1f@W?N&-0yJcy4ynl
zaSi6Rg5XC0spQygu`TrHUM;?s(A2O#w$?I^8d~FNs~_q9LBHQ$@e!94#n)p{BGo<m
zUR?Y0OxCXTimjO4mK0o&qiyi_%EaO+ewdCUaX~0V^3KiG;svImte(<koll*YR7;{f
z7jg=gG_fg}tnQE<OWaN}aI0%#AFCWF%1q=#7uhdczSa9fX;(U_b7C-?7lrVg4&Cd}
z@@b7P6$E|^V+9xRzcsC76tjXUUpSEb_5MKc=JiQ<vOY1!(mWIotlJIJ$Y4c@nx)ST
zzZSgO$TU!3dy6`?jKEZ^;+^j?MK7LFFwz<cr%70CV=6CDqgOd89Q)UkK%IK-BUR2+
zJ<?j9bQWVz5ao&N`fPS&X$$*w;g=;U@?T*Yg-s_ieU}jtx7Ab@T)f@VczOBf`e8e|
z5m^h>z?|NnD3(0`^Mj&a2u!OPuTRVG_cd+4eGl9{kMjXR8!hvdk<v-pNG1$bMB~42
z0e*p&L*S~|HZ&M!(OF91W{onpNmzk3eYJ2Lk~?kMLXrh*$G~9Xsb2d#PK;O}PrlOf
z<)htEfzzHi*HTlfbXZg9Y@}NxX~=hEs(x-AX;1gChLh7(%aI1g5P}9sp7aGKE6XxM
zgJuyd7##4d=<(bJJ?Y?Bn3;i|G@r6*XllHtVk}B5#UbyCiTzM|^+XRe2jQ=0jy)#q
z6N;@tnOU-)+b6(sXDXhBpY|x@QUPwJ*j=;1vyOQs!LG#W@YQ?#b$uCDyMkQGNWs5i
zW;mZfT!|fv7iFNnIj1nrX{%+DYO15wv=-mn9#l-N3}q|kJEEH^MVr0gS&H(hId2@M
zf#%M^Y|u9^wp=)6sV~Z4GRZ1e@=+uZoXI`RLz)B1160(sTO&u-3RXeuQCNq?J!`RN
zTbF6|=eCPx$6;)Lk3~&cHz`Kl-*Hj%X(g8r!=h1ZMMe#gH@gFyE%@){NEOqQ?8->R
zw$<tMv;?#qk&60B(f^rNT`aFjavfz0KXj|~v^sJ6@`>453#y>ZG<bR4&EZD0IlHM5
z2by-Oh1&V%`J$MK7zuGs2JePeBxFFtt#NNpKjZz~sa2NOPuVXa0~Ye%l}FNlPUF+>
zE>8skmzrk1oB)hbiR{_i9pGI94FTz@?g%?5TxJH@FvUaj601kiq%fW^fG>0t5tyuv
z5+d-P<%ZZXD8)})<!jAKH4s?f+0~ezOw!mfFWy4{LQ2p4ogph(&{?G+cixKU)oD{v
z17sTiGtxYrl*h)MbwovW)&ya1_lv<)2@eLID~O&{osatA63jt7#N)DO(AlUg(UJc^
zbA=-pLsQ?elQKHThyCv{#^|K{wlbf+R9ix?b0i;!?`Z`w(B@2CjbmZc2e^d0<97sY
zf4@X8!<_nNO+deuk$^J28gJ(;!}-4rt<tjMvNPDx%o=@<u>TIOsk=y!cG-6^*sd^2
zCRX2Xa$wtuWKdo2Uimpq8e4<DrrBT7bNF<>?2LH&f5vx!XF^npPLzi3SOD5#pn_Xb
zEe!Llu)dz`)hZj$M42<Q1qvn?9&-U|{S}F=gVqz7B_r}nTp#~ufq=1*Fy&5}O|;_U
zdQ9^AaCl8soX7Vr4CcQa*)>-VpYLIMct{vVkGL`*fnvou*dj0Ymq|q$p?~dP;i_EK
z6X~fq1ESodrBsFWfL+yljrsNnJ3x++MW;TYBGuj?jx<)+Ajtid$42_!3mr7UO3oC`
zzS@l)7Y)+p;2$$H4O}m8Wf323gwbDfgw?|58vg0^`+ZY_-j8tLpQNbl%Yx^+@BTmW
C8XU*~

diff --git a/docs/chapter_tree/avl_tree.assets/right_rotate_step4.png b/docs/chapter_tree/avl_tree.assets/right_rotate_step4.png
index eccc0f9d4cd88725c8f6c078f1c61442d09391b4..5ede1ed2041692d86b89e41441a290995079f5e5 100644
GIT binary patch
literal 72098
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
XtO!4~Wnu1ufX~JA=I2VzxZM3elq4|W

literal 68870
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
BUzh*@

diff --git a/docs/chapter_tree/avl_tree.assets/right_rotate_with_grandchild.png b/docs/chapter_tree/avl_tree.assets/right_rotate_with_grandchild.png
index a1c80c6e69a32e62ca21e028919307b00732766b..ea07a8a2e5075459cd2fdf930f9342f58140094b 100644
GIT binary patch
literal 93429
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
BHeCP!

literal 91488
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
P0}yz+`njxgN@xNAkGU5(

diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md
index 45308fa6f..d969c66d7 100644
--- a/docs/chapter_tree/avl_tree.md
+++ b/docs/chapter_tree/avl_tree.md
@@ -127,7 +127,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
         if node is not None:
             return node.height
         return -1
-
+    
     """ 更新结点高度 """
     def __update_height(self, node: TreeNode):
         # 结点高度等于最高子树高度 + 1
@@ -167,7 +167,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
         // 空结点高度为 -1 ，叶结点高度为 0
         return node == null ? -1 : node.height;
     }
-
+    
     /* 更新结点高度 */
     private void updateHeight(TreeNode node)
     {
@@ -363,11 +363,15 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 
 ### Case 2 - 左旋
 
-类似地，如果将取上述失衡二叉树的“镜像”，那么则需要「左旋」操作。观察发现，**「左旋」和「右旋」操作是镜像对称的，两者对应解决的两种失衡情况也是对称的**。
+类似地，如果将取上述失衡二叉树的“镜像”，那么则需要「左旋」操作。
+
+![left_rotate](avl_tree.assets/left_rotate.png)
+
+同理，若结点 `child` 本身有左子结点（记为 `grandChild`），则需要在「左旋」中添加一步：将 `grandChild` 作为 `node` 的右子结点。
 
 ![left_rotate_with_grandchild](avl_tree.assets/left_rotate_with_grandchild.png)
 
-根据对称性，我们可以很方便地从「右旋」推导出「左旋」。具体地，把所有的 `left` 替换为 `right` 、所有的 `right` 替换为 `left` 即可。
+观察发现，**「左旋」和「右旋」操作是镜像对称的，两者对应解决的两种失衡情况也是对称的**。根据对称性，我们可以很方便地从「右旋」推导出「左旋」。具体地，只需将「右旋」代码中的把所有的 `left` 替换为 `right` 、所有的 `right` 替换为 `left` ，即可得到「左旋」代码。
 
 === "Java"
 
@@ -467,11 +471,11 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 
 ### 旋转的选择
 
-下图描述的四种失衡情况与上述 Cases 一一对应，分别采用右旋、左旋、先右后左、先左后右的旋转组合。
+下图描述的四种失衡情况与上述 Cases 逐个对应，分别需采用 **右旋、左旋、先右后左、先左后右** 的旋转操作。
 
 ![rotation_cases](avl_tree.assets/rotation_cases.png)
 
-具体地，需要使用 **失衡结点的平衡因子、较高一侧子结点的平衡因子** 来确定失衡结点属于上图中的哪种情况。
+具体地，在代码中使用 **失衡结点的平衡因子、较高一侧子结点的平衡因子** 来确定失衡结点属于上图中的哪种情况。
 
 <div class="center-table" markdown>
 
@@ -484,7 +488,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 
 </div>
 
-根据以上规则，我们将旋转操作封装成一个函数。至此，**我们可以使用此函数来旋转各种失衡情况，使失衡结点重新恢复平衡**。
+为方便使用，我们将旋转操作封装成一个函数。至此，**我们可以使用此函数来旋转各种失衡情况，使失衡结点重新恢复平衡**。
 
 === "Java"
 
@@ -668,7 +672,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
     def insert(self, val) -> TreeNode:
         self.root = self.__insert_helper(self.root, val)
         return self.root
-
+    
     """ 递归插入结点（辅助函数）"""
     def __insert_helper(self, node: typing.Optional[TreeNode], val: int) -> TreeNode:
         if node is None:
@@ -720,7 +724,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         root = insertHelper(root, val);
         return root;
     }
-
+    
     /* 递归插入结点（辅助函数） */
     private TreeNode? insertHelper(TreeNode? node, int val)
     {
@@ -798,7 +802,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
     def remove(self, val: int):
         root = self.__remove_helper(self.root, val)
         return root
-
+    
     """ 递归删除结点（辅助函数） """
     def __remove_helper(self, node: typing.Optional[TreeNode], val: int) -> typing.Optional[TreeNode]:
         if node is None:
@@ -860,7 +864,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         root = removeHelper(root, val);
         return root;
     }
-
+    
     /* 递归删除结点（辅助函数） */
     private TreeNode? removeHelper(TreeNode? node, int val)
     {

From 36e83352b866a84be53d1e4a53eed6466ffd102c Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Tue, 3 Jan 2023 11:17:11 +0800
Subject: [PATCH 076/158] lint: added missing comment

---
 docs/chapter_computational_complexity/time_complexity.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 4328dc6b3..22dc3472a 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -786,6 +786,7 @@ $$
 === "TypeScript"
 
     ```typescript title="time_complexity.ts"
+    /* 常数阶 */
     function constant(n: number): number {
         let count = 0;
         const size = 100000;

From 89a5c6b435674d7d25013c020ff47f0271ff0d25 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Tue, 3 Jan 2023 15:47:06 +0800
Subject: [PATCH 077/158] Add description of the comment format.

---
 docs/chapter_array_and_linkedlist/summary.md  |   2 +-
 docs/chapter_preface/about_the_book.md        | 114 +++++++++++++++++-
 .../contribution.assets/edit_markdown.png     | Bin 214956 -> 204268 bytes
 docs/chapter_searching/binary_search.md       |   2 +-
 docs/chapter_searching/hashing_search.md      |   2 +-
 docs/chapter_searching/linear_search.md       |   2 +-
 docs/index.md                                 |   2 +-
 7 files changed, 116 insertions(+), 8 deletions(-)

diff --git a/docs/chapter_array_and_linkedlist/summary.md b/docs/chapter_array_and_linkedlist/summary.md
index 35e4e17c8..60fe604f0 100644
--- a/docs/chapter_array_and_linkedlist/summary.md
+++ b/docs/chapter_array_and_linkedlist/summary.md
@@ -4,7 +4,7 @@ comments: true
 
 # 小结
 
-- 数组和链表是两种基本数据结构，代表了数据在计算机内存中的两种存储方式，即连续空间存储和离散空间存储。两者的优缺点呈现出此消彼长的关系。
+- 数组和链表是两种基本数据结构，代表了数据在计算机内存中的两种存储方式，即连续空间存储和离散空间存储。两者的优点与缺点呈现出此消彼长的关系。
 - 数组支持随机访问、内存空间占用小；但插入与删除元素效率低，且初始化后长度不可变。
 - 链表可通过更改指针实现高效的结点插入与删除，并且可以灵活地修改长度；但结点访问效率低、占用内存多。常见的链表类型有单向链表、循环链表、双向链表。
 - 列表又称动态数组，是基于数组实现的一种数据结构，其保存了数组的优势，且可以灵活改变长度。列表的出现大大提升了数组的实用性，但副作用是会造成部分内存空间浪费。
diff --git a/docs/chapter_preface/about_the_book.md b/docs/chapter_preface/about_the_book.md
index db70a8acd..bc79115a3 100644
--- a/docs/chapter_preface/about_the_book.md
+++ b/docs/chapter_preface/about_the_book.md
@@ -82,10 +82,118 @@ comments: true
 
 ## 风格约定
 
-- 文章中的重要名词会用「」符号标注，例如「数组 Array」。名词混淆会导致不必要的歧义，因此最好可以记住这类名词（包括中文和英文），以便后续阅读文献时使用。
-- 重点内容、总起句、总结句会被 **加粗** ，此类文字值得更多关注。
-- 专有名词和有特指含义的词句会使用 “ ” 标注，以避免歧义。
 - 标题后标注 * 符号的是选读章节，如果你的时间有限，可以先跳过这些章节。
+- 文章中的重要名词会用「」符号标注，例如「数组 Array」。名词混淆会导致不必要的歧义，因此最好可以记住这类名词（包括中文和英文），以便后续阅读文献时使用。
+- 重点内容、总起句、总结句会被 **加粗** ，此类文字值得特别关注。
+- 专有名词和有特指含义的词句会使用 “ ” 标注，以避免歧义。
+- 在工程应用中，每种语言都有相应的注释规范；而本书放弃了一部分的注释规范性，以换取更加紧凑的内容排版。注释主要分为三种类型：标题注释、内容注释、多行注释。
+
+=== "Java"
+
+    ```java title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "Python"
+
+    ```python title=""
+    """ 标题注释，用于标注函数、类、测试样例等 """
+    
+    # 内容注释，用于详解代码
+
+    """
+    多行
+    注释
+    """
+    ```
+
+=== "Go"
+
+    ```go title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "JavaScript"
+
+    ```js title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "TypeScript"
+
+    ```typescript title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "C"
+
+    ```c title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+"""
+在 Java, C, C++, C#, Go, JS, TS 的代码注释中，`/* ... */` 用于注释函数、类、测试样例等标题， `// ...` 用于解释代码内容；类似地，在 Python 中，`""" ... """` 用于注释标题， `# ...` 用于解释代码。
 
 ## 本书特点 *
 
diff --git a/docs/chapter_preface/contribution.assets/edit_markdown.png b/docs/chapter_preface/contribution.assets/edit_markdown.png
index 02fc6318d793bc2b6ada9cf9c2f5ef3c873a6fbc..25037fce64d1942c2ee41e471d7d8334abcc6b78 100644
GIT binary patch
literal 204268
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

literal 214956
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

diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
index 35d6a3210..6bc53fe5a 100644
--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@@ -466,7 +466,7 @@ $$
 
 **空间复杂度 $O(1)$ ：** 指针 `i` , `j` 使用常数大小空间。
 
-## 优缺点
+## 优点与缺点
 
 二分查找效率很高，体现在：
 
diff --git a/docs/chapter_searching/hashing_search.md b/docs/chapter_searching/hashing_search.md
index a52f72e21..a70a55483 100644
--- a/docs/chapter_searching/hashing_search.md
+++ b/docs/chapter_searching/hashing_search.md
@@ -185,7 +185,7 @@ comments: true
 
 **空间复杂度：** $O(n)$ ，其中 $n$ 为数组或链表长度。
 
-## 优缺点
+## 优点与缺点
 
 在哈希表中，**查找、插入、删除操作的平均时间复杂度都为 $O(1)$** ，这意味着无论是高频增删还是高频查找场景，哈希查找的性能表现都非常好。当然，一切的前提是保证哈希表未退化。
 
diff --git a/docs/chapter_searching/linear_search.md b/docs/chapter_searching/linear_search.md
index 3284db06c..3d592962e 100644
--- a/docs/chapter_searching/linear_search.md
+++ b/docs/chapter_searching/linear_search.md
@@ -244,7 +244,7 @@ comments: true
 
 **空间复杂度 $O(1)$ ：** 无需使用额外空间。
 
-## 优缺点
+## 优点与缺点
 
 **线性查找的通用性极佳。** 由于线性查找是依次访问元素的，即没有跳跃访问元素，因此数组或链表皆适用。
 
diff --git a/docs/index.md b/docs/index.md
index 71c34360d..3b6405202 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -10,7 +10,7 @@ hide:
     ![conceptual_rendering](index.assets/conceptual_rendering.png){ align=left width=350 }
     </br></br></br></br></br>
     <h1 align="center"> 《 Hello，算法 》 </h1>
-    <p align="center"> 动画图解、能运行、可讨论的</br>数据结构与算法快速入门教程 </p>
+    <p align="center"> 动画图解、能运行、可提问的</br>数据结构与算法快速入门教程 </p>
     <p align="center"> [![github-stars](https://img.shields.io/github/stars/krahets/hello-algo?style=social)](https://github.com/krahets/hello-algo)</p>
     <h6 align="center"> [@Krahets](https://leetcode.cn/u/jyd/) </h6>
     </div>

From 1b356ba0a2b0c67b549cee72fe9ea5dd191d24cd Mon Sep 17 00:00:00 2001
From: sjinzh <99076655+sjinzh@users.noreply.github.com>
Date: Tue, 3 Jan 2023 21:19:11 +0800
Subject: [PATCH 078/158] add c code for chapter_computational_complexity

---
 .../time_complexity.c                         | 192 ++++++++++++++++++
 .../worst_best_time_complexity.c              |  65 ++++++
 2 files changed, 257 insertions(+)
 create mode 100644 codes/c/chapter_computational_complexity/time_complexity.c
 create mode 100644 codes/c/chapter_computational_complexity/worst_best_time_complexity.c

diff --git a/codes/c/chapter_computational_complexity/time_complexity.c b/codes/c/chapter_computational_complexity/time_complexity.c
new file mode 100644
index 000000000..b7e6cef9c
--- /dev/null
+++ b/codes/c/chapter_computational_complexity/time_complexity.c
@@ -0,0 +1,192 @@
+// File: time_complexity.c
+// Created Time: 2023-01-03
+// Author: sjinzh (sjinzh@gmail.com)
+
+#include "stdio.h"
+#include "stdlib.h"
+
+// 常数阶
+int constant(int n) 
+{
+    int count = 0;
+    int size = 100000;
+    int i = 0;
+    for(int i = 0; i < size; i++){
+        count ++;
+    }
+    return count;
+}
+
+// 线性阶
+int linear(int n) 
+{
+    int count = 0;
+    for(int i = 0; i < n; i++){
+        count ++;
+    }
+    return count;
+}
+
+// 线性阶（遍历数组）
+int arrayTraversal(int *nums, int n)
+{
+    int count = 0;
+    // 循环次数与数组长度成正比
+    for(int i = 0; i < n; i++){
+        count ++;
+    }
+    return count;
+}
+
+// 平方阶
+int quadratic(int n) 
+{
+    int count = 0;
+    // 循环次数与数组长度成平方关系
+    for(int i = 0; i < n; i++){
+        for(int j = 0; j < n; j++){
+            count ++;
+        }
+    }
+    return count;
+}
+
+// 平方阶（冒泡排序）
+int bubbleSort(int *nums, int n)
+{
+    int count = 0;  // 计数器 
+    // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+    for(int i = n - 1; i > 0; i--){
+        // 内循环：冒泡操作
+        for (int j = 0; j < i; j++)
+        {
+            // 交换 nums[j] 与 nums[j + 1]
+            int tmp = nums[j];
+            nums[j] = nums[j + 1];
+            nums[j + 1] = tmp;
+            count += 3;  // 元素交换包含 3 个单元操作
+        }
+        
+    }
+    return count;
+}
+
+// 指数阶（循环实现）
+int exponential(int n) 
+{
+    int count = 0;
+    int bas = 1;
+    // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+    for (int i = 0; i < n; i++)
+    {
+        for (int j = 0; j < bas; j++)
+        {
+            count++;
+        }
+        bas *= 2;
+    }
+    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+    return count;
+}
+
+// 指数阶（递归实现）
+int expRecur(int n) 
+{
+    if (n == 1) return 1;
+    return expRecur(n - 1) + expRecur(n - 1) + 1;
+}
+
+// 对数阶（循环实现）
+int logarithmic(float n)
+{
+    int count = 0;
+    while (n > 1)
+    {
+        n = n / 2;
+        count++;
+    }
+    return count;
+}
+
+// 对数阶（递归实现）
+int logRecur(float n)
+{
+    if (n <= 1) return 0;
+    return logRecur(n / 2) + 1;
+}
+
+// 线性对数阶
+int linearLogRecur(float n)
+{
+    if (n <= 1) return 1;
+    int count = linearLogRecur(n / 2) +
+                linearLogRecur(n / 2);
+    for (int i = 0; i < n; i++)
+    {
+        count ++;
+    }
+    return count;
+}
+
+// 阶乘阶（递归实现）
+int factorialRecur(int n) 
+{
+    if (n == 0) return 1;
+    int count = 0;
+    for (int i = 0; i < n; i++)
+    {
+        count += factorialRecur(n - 1);
+    }
+    return count;
+}
+
+// Driver Code
+int main(int argc, char *argv[])
+ {
+    // 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
+    int n = 8;
+    printf("输入数据大小 n = %d\n", n);
+
+    int count = constant(n);
+    printf("常数阶的计算操作数量 = %d\n", count);
+
+    count = linear(n);
+    printf("线性阶的计算操作数量 = %d\n", count);
+    // 分配堆区内存（创建一维可变长数组：数组中元素数量为n，元素类型为int）
+    int *nums = (int *)malloc(n * sizeof(int));
+    count = arrayTraversal(nums, n);
+    printf("线性阶（遍历数组）的计算操作数量 = %d\n", count);
+
+    count = quadratic(n);
+    printf("平方阶的计算操作数量 = %d\n", count);
+    for(int i = 0; i < n; i++){
+        nums[i] = n - i;    // [n,n-1,...,2,1]
+    }
+    count = bubbleSort(nums, n);
+    printf("平方阶（冒泡排序）的计算操作数量 = %d\n", count);
+
+    count = exponential(n);
+    printf("指数阶（循环实现）的计算操作数量 = %d\n", count);
+    count = expRecur(n);
+    printf("指数阶（递归实现）的计算操作数量 = %d\n", count);
+
+    count = logarithmic(n);
+    printf("对数阶（循环实现）的计算操作数量 = %d\n", count);
+    count = logRecur(n);
+    printf("对数阶（递归实现）的计算操作数量 = %d\n", count);
+
+    count = linearLogRecur(n);
+    printf("线性对数阶（递归实现）的计算操作数量 = %d\n", count);
+
+    count = factorialRecur(n);
+    printf("阶乘阶（递归实现）的计算操作数量 = %d\n", count);
+
+    // 释放堆区内存
+    if(nums != NULL){
+        free(nums);
+        nums = NULL;
+    }
+    getchar();
+    return 0;
+}
+
diff --git a/codes/c/chapter_computational_complexity/worst_best_time_complexity.c b/codes/c/chapter_computational_complexity/worst_best_time_complexity.c
new file mode 100644
index 000000000..11139630f
--- /dev/null
+++ b/codes/c/chapter_computational_complexity/worst_best_time_complexity.c
@@ -0,0 +1,65 @@
+// File: worst_best_time_complexity.c
+// Created Time: 2023-01-03
+// Author: sjinzh (sjinzh@gmail.com)
+
+#include "stdio.h"
+#include "stdlib.h"
+#include "time.h"
+
+// 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱
+int *randomNumbers(int n)  
+{
+    // 分配堆区内存（创建一维可变长数组：数组中元素数量为n，元素类型为int）
+    int *nums = (int *)malloc(n * sizeof(int));
+    // 生成数组 nums = { 1, 2, 3, ..., n }
+    for (int i = 0; i < n; i++)
+    {
+        nums[i] = i + 1;
+    }
+    // 随机打乱数组元素 
+	for (int i = n - 1; i > 0; i--)
+	{
+		int j = rand() % (i + 1);
+		int temp = nums[i];
+		nums[i] = nums[j];
+		nums[j] = temp; 
+	}
+    return nums;
+}
+
+// 查找数组 nums 中数字 1 所在索引
+int findOne(int *nums, int n) 
+{
+    for (int i = 0; i < n; i++)
+    {
+        if (nums[i] == 1) return i;
+    }
+    return -1;
+}
+
+// Driver Code
+int main(int argc, char *argv[])
+{
+    // 初始化随机数种子
+    srand((unsigned int)time(NULL));
+    for (int i = 0; i < 10; i++)
+    {
+        int n = 100;
+        int *nums = randomNumbers(n);
+        int index = findOne(nums, n);
+        printf("\n数组 [ 1, 2, ..., n ] 被打乱后 = ");
+        for (int j = 0; j < n; j++)
+        {
+            printf("%d%s", nums[j], (j == n-1)? "" : "," );
+        }
+        printf("\n数字 1 的索引为 %d\n", index);
+        // 释放堆区内存
+        if(nums != NULL){
+            free(nums);
+            nums = NULL;
+        }
+    }
+    getchar();
+    return 0;
+}
+

From 377200a39a696974284c1f33a28dddf67945a817 Mon Sep 17 00:00:00 2001
From: nuomi1 <nuomi1@qq.com>
Date: Mon, 2 Jan 2023 21:48:32 +0800
Subject: [PATCH 079/158] refactor: use Package.swift to define executable task

---
 codes/swift/Package.swift                     |  18 +++
 .../space_complexity.swift                    | 110 +++---------------
 .../time_complexity.swift                     |  59 +++++-----
 .../worst_best_time_complexity.swift          |  21 ++--
 codes/swift/utils/ListNode.swift              |  14 +++
 codes/swift/utils/PrintUtil.swift             |  61 ++++++++++
 codes/swift/utils/TreeNode.swift              |  17 +++
 7 files changed, 169 insertions(+), 131 deletions(-)
 create mode 100644 codes/swift/Package.swift
 create mode 100644 codes/swift/utils/ListNode.swift
 create mode 100644 codes/swift/utils/PrintUtil.swift
 create mode 100644 codes/swift/utils/TreeNode.swift

diff --git a/codes/swift/Package.swift b/codes/swift/Package.swift
new file mode 100644
index 000000000..250c09af1
--- /dev/null
+++ b/codes/swift/Package.swift
@@ -0,0 +1,18 @@
+// swift-tools-version: 5.7
+
+import PackageDescription
+
+let package = Package(
+    name: "HelloAlgo",
+    products: [
+        .executable(name: "time_complexity", targets: ["time_complexity"]),
+        .executable(name: "worst_best_time_complexity", targets: ["worst_best_time_complexity"]),
+        .executable(name: "space_complexity", targets: ["space_complexity"]),
+    ],
+    targets: [
+        .target(name: "utils", path: "utils"),
+        .executableTarget(name: "time_complexity", path: "chapter_computational_complexity", sources: ["time_complexity.swift"]),
+        .executableTarget(name: "worst_best_time_complexity", path: "chapter_computational_complexity", sources: ["worst_best_time_complexity.swift"]),
+        .executableTarget(name: "space_complexity", dependencies: ["utils"], path: "chapter_computational_complexity", sources: ["space_complexity.swift"]),
+    ]
+)
diff --git a/codes/swift/chapter_computational_complexity/space_complexity.swift b/codes/swift/chapter_computational_complexity/space_complexity.swift
index 7326c82b4..4931597ca 100644
--- a/codes/swift/chapter_computational_complexity/space_complexity.swift
+++ b/codes/swift/chapter_computational_complexity/space_complexity.swift
@@ -4,82 +4,7 @@
  * Author: nuomi1 (nuomi1@qq.com)
  */
 
-class ListNode {
-    var val: Int
-    var next: ListNode?
-
-    init(x: Int) {
-        val = x
-    }
-}
-
-class TreeNode {
-    var val: Int // 结点值
-    var height: Int // 结点高度
-    var left: TreeNode? // 左子结点引用
-    var right: TreeNode? // 右子结点引用
-
-    init(x: Int) {
-        val = x
-        height = 0
-    }
-}
-
-enum PrintUtil {
-    private class Trunk {
-        var prev: Trunk?
-        var str: String
-
-        init(prev: Trunk?, str: String) {
-            self.prev = prev
-            self.str = str
-        }
-    }
-
-    static func printTree(root: TreeNode?) {
-        printTree(root: root, prev: nil, isLeft: false)
-    }
-
-    private static func printTree(root: TreeNode?, prev: Trunk?, isLeft: Bool) {
-        if root == nil {
-            return
-        }
-
-        var prevStr = "    "
-        let trunk = Trunk(prev: prev, str: prevStr)
-
-        printTree(root: root?.right, prev: trunk, isLeft: true)
-
-        if prev == nil {
-            trunk.str = "———"
-        } else if isLeft {
-            trunk.str = "/———"
-            prevStr = "   |"
-        } else {
-            trunk.str = "\\———"
-            prev?.str = prevStr
-        }
-
-        showTrunks(p: trunk)
-        print(" \(root!.val)")
-
-        if prev != nil {
-            prev?.str = prevStr
-        }
-        trunk.str = "   |"
-
-        printTree(root: root?.left, prev: trunk, isLeft: false)
-    }
-
-    private static func showTrunks(p: Trunk?) {
-        if p == nil {
-            return
-        }
-
-        showTrunks(p: p?.prev)
-        print(p!.str, terminator: "")
-    }
-}
+import utils
 
 // 函数
 @discardableResult
@@ -153,20 +78,21 @@ func buildTree(n: Int) -> TreeNode? {
     return root
 }
 
-// Driver Code
-func main() {
-    let n = 5
-    // 常数阶
-    constant(n: n)
-    // 线性阶
-    linear(n: n)
-    linearRecur(n: n)
-    // 平方阶
-    quadratic(n: n)
-    quadraticRecur(n: n)
-    // 指数阶
-    let root = buildTree(n: n)
-    PrintUtil.printTree(root: root)
+@main
+enum SpaceComplexity {
+    // Driver Code
+    static func main() {
+        let n = 5
+        // 常数阶
+        constant(n: n)
+        // 线性阶
+        linear(n: n)
+        linearRecur(n: n)
+        // 平方阶
+        quadratic(n: n)
+        quadraticRecur(n: n)
+        // 指数阶
+        let root = buildTree(n: n)
+        PrintUtil.printTree(root: root)
+    }
 }
-
-main()
diff --git a/codes/swift/chapter_computational_complexity/time_complexity.swift b/codes/swift/chapter_computational_complexity/time_complexity.swift
index 38bac4fae..322b4f09d 100644
--- a/codes/swift/chapter_computational_complexity/time_complexity.swift
+++ b/codes/swift/chapter_computational_complexity/time_complexity.swift
@@ -131,40 +131,41 @@ func factorialRecur(n: Int) -> Int {
     return count
 }
 
-func main() {
-    // 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
-    let n = 8
-    print("输入数据大小 n =", n)
+@main
+enum TimeComplexity {
+    static func main() {
+        // 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
+        let n = 8
+        print("输入数据大小 n =", n)
 
-    var count = constant(n: n)
-    print("常数阶的计算操作数量 =", count)
+        var count = constant(n: n)
+        print("常数阶的计算操作数量 =", count)
 
-    count = linear(n: n)
-    print("线性阶的计算操作数量 =", count)
-    count = arrayTraversal(nums: Array(repeating: 0, count: n))
-    print("线性阶（遍历数组）的计算操作数量 =", count)
+        count = linear(n: n)
+        print("线性阶的计算操作数量 =", count)
+        count = arrayTraversal(nums: Array(repeating: 0, count: n))
+        print("线性阶（遍历数组）的计算操作数量 =", count)
 
-    count = quadratic(n: n)
-    print("平方阶的计算操作数量 =", count)
-    var nums = Array(sequence(first: n, next: { $0 > 0 ? $0 - 1 : nil })) // [n,n-1,...,2,1]
-    count = bubbleSort(nums: &nums)
-    print("平方阶（冒泡排序）的计算操作数量 =", count)
+        count = quadratic(n: n)
+        print("平方阶的计算操作数量 =", count)
+        var nums = Array(sequence(first: n, next: { $0 > 0 ? $0 - 1 : nil })) // [n,n-1,...,2,1]
+        count = bubbleSort(nums: &nums)
+        print("平方阶（冒泡排序）的计算操作数量 =", count)
 
-    count = exponential(n: n)
-    print("指数阶（循环实现）的计算操作数量 =", count)
-    count = expRecur(n: n)
-    print("指数阶（递归实现）的计算操作数量 =", count)
+        count = exponential(n: n)
+        print("指数阶（循环实现）的计算操作数量 =", count)
+        count = expRecur(n: n)
+        print("指数阶（递归实现）的计算操作数量 =", count)
 
-    count = logarithmic(n: n)
-    print("对数阶（循环实现）的计算操作数量 =", count)
-    count = logRecur(n: n)
-    print("对数阶（递归实现）的计算操作数量 =", count)
+        count = logarithmic(n: n)
+        print("对数阶（循环实现）的计算操作数量 =", count)
+        count = logRecur(n: n)
+        print("对数阶（递归实现）的计算操作数量 =", count)
 
-    count = linearLogRecur(n: Double(n))
-    print("线性对数阶（递归实现）的计算操作数量 =", count)
+        count = linearLogRecur(n: Double(n))
+        print("线性对数阶（递归实现）的计算操作数量 =", count)
 
-    count = factorialRecur(n: n)
-    print("阶乘阶（递归实现）的计算操作数量 =", count)
+        count = factorialRecur(n: n)
+        print("阶乘阶（递归实现）的计算操作数量 =", count)
+    }
 }
-
-main()
diff --git a/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift b/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift
index 73db6954d..4fa2cf2a0 100644
--- a/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift
+++ b/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift
@@ -23,15 +23,16 @@ func findOne(nums: [Int]) -> Int {
     return -1
 }
 
-// Driver Code
-func main() {
-    for _ in 0 ..< 10 {
-        let n = 100
-        let nums = randomNumbers(n: n)
-        let index = findOne(nums: nums)
-        print("数组 [ 1, 2, ..., n ] 被打乱后 =", nums)
-        print("数字 1 的索引为", index)
+@main
+enum WorstBestTimeComplexity {
+    // Driver Code
+    static func main() {
+        for _ in 0 ..< 10 {
+            let n = 100
+            let nums = randomNumbers(n: n)
+            let index = findOne(nums: nums)
+            print("数组 [ 1, 2, ..., n ] 被打乱后 =", nums)
+            print("数字 1 的索引为", index)
+        }
     }
 }
-
-main()
diff --git a/codes/swift/utils/ListNode.swift b/codes/swift/utils/ListNode.swift
new file mode 100644
index 000000000..796ee5125
--- /dev/null
+++ b/codes/swift/utils/ListNode.swift
@@ -0,0 +1,14 @@
+/*
+ * File: ListNode.swift
+ * Created Time: 2023-01-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+public class ListNode {
+    public var val: Int // 结点值
+    public var next: ListNode? // 后继结点引用
+
+    public init(x: Int) {
+        val = x
+    }
+}
diff --git a/codes/swift/utils/PrintUtil.swift b/codes/swift/utils/PrintUtil.swift
new file mode 100644
index 000000000..3f3fc2688
--- /dev/null
+++ b/codes/swift/utils/PrintUtil.swift
@@ -0,0 +1,61 @@
+/*
+ * File: PrintUtil.swift
+ * Created Time: 2023-01-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+public enum PrintUtil {
+    private class Trunk {
+        var prev: Trunk?
+        var str: String
+
+        init(prev: Trunk?, str: String) {
+            self.prev = prev
+            self.str = str
+        }
+    }
+
+    public static func printTree(root: TreeNode?) {
+        printTree(root: root, prev: nil, isLeft: false)
+    }
+
+    private static func printTree(root: TreeNode?, prev: Trunk?, isLeft: Bool) {
+        if root == nil {
+            return
+        }
+
+        var prevStr = "    "
+        let trunk = Trunk(prev: prev, str: prevStr)
+
+        printTree(root: root?.right, prev: trunk, isLeft: true)
+
+        if prev == nil {
+            trunk.str = "———"
+        } else if isLeft {
+            trunk.str = "/———"
+            prevStr = "   |"
+        } else {
+            trunk.str = "\\———"
+            prev?.str = prevStr
+        }
+
+        showTrunks(p: trunk)
+        print(" \(root!.val)")
+
+        if prev != nil {
+            prev?.str = prevStr
+        }
+        trunk.str = "   |"
+
+        printTree(root: root?.left, prev: trunk, isLeft: false)
+    }
+
+    private static func showTrunks(p: Trunk?) {
+        if p == nil {
+            return
+        }
+
+        showTrunks(p: p?.prev)
+        print(p!.str, terminator: "")
+    }
+}
diff --git a/codes/swift/utils/TreeNode.swift b/codes/swift/utils/TreeNode.swift
new file mode 100644
index 000000000..b6ce30575
--- /dev/null
+++ b/codes/swift/utils/TreeNode.swift
@@ -0,0 +1,17 @@
+/*
+ * File: TreeNode.swift
+ * Created Time: 2023-01-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+public class TreeNode {
+    public var val: Int // 结点值
+    public var height: Int // 结点高度
+    public var left: TreeNode? // 左子结点引用
+    public var right: TreeNode? // 右子结点引用
+
+    public init(x: Int) {
+        val = x
+        height = 0
+    }
+}

From 2069dddd3b1c8a5271d269f853c1e3f44e153962 Mon Sep 17 00:00:00 2001
From: nuomi1 <nuomi1@qq.com>
Date: Tue, 3 Jan 2023 22:24:50 +0800
Subject: [PATCH 080/158] feat: add Swift codes for space time tradeoff article

---
 codes/swift/Package.swift                     |  2 +
 .../leetcode_two_sum.swift                    | 46 +++++++++++++++++++
 .../space_time_tradeoff.md                    | 33 +++++++++++++
 3 files changed, 81 insertions(+)
 create mode 100644 codes/swift/chapter_computational_complexity/leetcode_two_sum.swift

diff --git a/codes/swift/Package.swift b/codes/swift/Package.swift
index 250c09af1..a292d9fd3 100644
--- a/codes/swift/Package.swift
+++ b/codes/swift/Package.swift
@@ -8,11 +8,13 @@ let package = Package(
         .executable(name: "time_complexity", targets: ["time_complexity"]),
         .executable(name: "worst_best_time_complexity", targets: ["worst_best_time_complexity"]),
         .executable(name: "space_complexity", targets: ["space_complexity"]),
+        .executable(name: "leetcode_two_sum", targets: ["leetcode_two_sum"]),
     ],
     targets: [
         .target(name: "utils", path: "utils"),
         .executableTarget(name: "time_complexity", path: "chapter_computational_complexity", sources: ["time_complexity.swift"]),
         .executableTarget(name: "worst_best_time_complexity", path: "chapter_computational_complexity", sources: ["worst_best_time_complexity.swift"]),
         .executableTarget(name: "space_complexity", dependencies: ["utils"], path: "chapter_computational_complexity", sources: ["space_complexity.swift"]),
+        .executableTarget(name: "leetcode_two_sum", path: "chapter_computational_complexity", sources: ["leetcode_two_sum.swift"]),
     ]
 )
diff --git a/codes/swift/chapter_computational_complexity/leetcode_two_sum.swift b/codes/swift/chapter_computational_complexity/leetcode_two_sum.swift
new file mode 100644
index 000000000..6ed0e580c
--- /dev/null
+++ b/codes/swift/chapter_computational_complexity/leetcode_two_sum.swift
@@ -0,0 +1,46 @@
+/*
+ * File: leetcode_two_sum.swift
+ * Created Time: 2023-01-03
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+func twoSumBruteForce(nums: [Int], target: Int) -> [Int] {
+    // 两层循环，时间复杂度 O(n^2)
+    for i in nums.indices.dropLast() {
+        for j in nums.indices.dropFirst(i + 1) {
+            if nums[i] + nums[j] == target {
+                return [i, j]
+            }
+        }
+    }
+    return [0]
+}
+
+func twoSumHashTable(nums: [Int], target: Int) -> [Int] {
+    // 辅助哈希表，空间复杂度 O(n)
+    var dic: [Int: Int] = [:]
+    // 单层循环，时间复杂度 O(n)
+    for i in nums.indices {
+        if let j = dic[target - nums[i]] {
+            return [j, i]
+        }
+        dic[nums[i]] = i
+    }
+    return [0]
+}
+
+@main
+enum LeetcodeTwoSum {
+    static func main() {
+        // ======= Test Case =======
+        let nums = [2, 7, 11, 15]
+        let target = 9
+        // ====== Driver Code ======
+        // 方法一
+        var res = twoSumBruteForce(nums: nums, target: target)
+        print("方法一 res = \(res)")
+        // 方法二
+        res = twoSumHashTable(nums: nums, target: target)
+        print("方法二 res = \(res)")
+    }
+}
diff --git a/docs/chapter_computational_complexity/space_time_tradeoff.md b/docs/chapter_computational_complexity/space_time_tradeoff.md
index 651aff148..0b86c11ca 100644
--- a/docs/chapter_computational_complexity/space_time_tradeoff.md
+++ b/docs/chapter_computational_complexity/space_time_tradeoff.md
@@ -149,6 +149,22 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="leetcode_two_sum.swift"
+    func twoSumBruteForce(nums: [Int], target: Int) -> [Int] {
+        // 两层循环，时间复杂度 O(n^2)
+        for i in nums.indices.dropLast() {
+            for j in nums.indices.dropFirst(i + 1) {
+                if nums[i] + nums[j] == target {
+                    return [i, j]
+                }
+            }
+        }
+        return [0]
+    }
+    ```
+
 ### 方法二：辅助哈希表
 
 时间复杂度 $O(N)$ ，空间复杂度 $O(N)$ ，属于「空间换时间」。
@@ -294,3 +310,20 @@ comments: true
         }
     }
     ```
+
+=== "Swift"
+
+    ```swift title="leetcode_two_sum.swift"
+    func twoSumHashTable(nums: [Int], target: Int) -> [Int] {
+        // 辅助哈希表，空间复杂度 O(n)
+        var dic: [Int: Int] = [:]
+        // 单层循环，时间复杂度 O(n)
+        for i in nums.indices {
+            if let j = dic[target - nums[i]] {
+                return [j, i]
+            }
+            dic[nums[i]] = i
+        }
+        return [0]
+    }
+    ```

From 9e4a5fd6d897bb70e049758ef3ccb975e96c30a8 Mon Sep 17 00:00:00 2001
From: sjinzh <99076655+sjinzh@users.noreply.github.com>
Date: Wed, 4 Jan 2023 08:09:22 +0800
Subject: [PATCH 081/158] update c code for chapter_computational_complexity,
 add c code to  time_complexity.md

---
 .../time_complexity.c                         |  35 +--
 .../worst_best_time_complexity.c              |  18 +-
 codes/c/include/include.h                     |   4 +-
 .../time_complexity.md                        | 249 ++++++++++++++++--
 4 files changed, 264 insertions(+), 42 deletions(-)

diff --git a/codes/c/chapter_computational_complexity/time_complexity.c b/codes/c/chapter_computational_complexity/time_complexity.c
index b7e6cef9c..4355ea3ad 100644
--- a/codes/c/chapter_computational_complexity/time_complexity.c
+++ b/codes/c/chapter_computational_complexity/time_complexity.c
@@ -1,11 +1,12 @@
-// File: time_complexity.c
-// Created Time: 2023-01-03
-// Author: sjinzh (sjinzh@gmail.com)
+/*
+ * File: time_complexity.c
+ * Created Time: 2023-01-03
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
 
-#include "stdio.h"
-#include "stdlib.h"
+#include "../include/include.h"
 
-// 常数阶
+/* 常数阶 */
 int constant(int n) 
 {
     int count = 0;
@@ -17,7 +18,7 @@ int constant(int n)
     return count;
 }
 
-// 线性阶
+/* 线性阶 */
 int linear(int n) 
 {
     int count = 0;
@@ -27,7 +28,7 @@ int linear(int n)
     return count;
 }
 
-// 线性阶（遍历数组）
+/* 线性阶（遍历数组） */
 int arrayTraversal(int *nums, int n)
 {
     int count = 0;
@@ -38,7 +39,7 @@ int arrayTraversal(int *nums, int n)
     return count;
 }
 
-// 平方阶
+/* 平方阶 */
 int quadratic(int n) 
 {
     int count = 0;
@@ -51,7 +52,7 @@ int quadratic(int n)
     return count;
 }
 
-// 平方阶（冒泡排序）
+/* 平方阶（冒泡排序） */
 int bubbleSort(int *nums, int n)
 {
     int count = 0;  // 计数器 
@@ -71,7 +72,7 @@ int bubbleSort(int *nums, int n)
     return count;
 }
 
-// 指数阶（循环实现）
+/* 指数阶（循环实现） */
 int exponential(int n) 
 {
     int count = 0;
@@ -89,14 +90,14 @@ int exponential(int n)
     return count;
 }
 
-// 指数阶（递归实现）
+/* 指数阶（递归实现） */
 int expRecur(int n) 
 {
     if (n == 1) return 1;
     return expRecur(n - 1) + expRecur(n - 1) + 1;
 }
 
-// 对数阶（循环实现）
+/* 对数阶（循环实现） */
 int logarithmic(float n)
 {
     int count = 0;
@@ -108,14 +109,14 @@ int logarithmic(float n)
     return count;
 }
 
-// 对数阶（递归实现）
+/* 对数阶（递归实现） */
 int logRecur(float n)
 {
     if (n <= 1) return 0;
     return logRecur(n / 2) + 1;
 }
 
-// 线性对数阶
+/* 线性对数阶 */
 int linearLogRecur(float n)
 {
     if (n <= 1) return 1;
@@ -128,7 +129,7 @@ int linearLogRecur(float n)
     return count;
 }
 
-// 阶乘阶（递归实现）
+/* 阶乘阶（递归实现） */
 int factorialRecur(int n) 
 {
     if (n == 0) return 1;
@@ -140,7 +141,7 @@ int factorialRecur(int n)
     return count;
 }
 
-// Driver Code
+/* Driver Code */
 int main(int argc, char *argv[])
  {
     // 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
diff --git a/codes/c/chapter_computational_complexity/worst_best_time_complexity.c b/codes/c/chapter_computational_complexity/worst_best_time_complexity.c
index 11139630f..fc37ae0f0 100644
--- a/codes/c/chapter_computational_complexity/worst_best_time_complexity.c
+++ b/codes/c/chapter_computational_complexity/worst_best_time_complexity.c
@@ -1,12 +1,12 @@
-// File: worst_best_time_complexity.c
-// Created Time: 2023-01-03
-// Author: sjinzh (sjinzh@gmail.com)
+/*
+ * File: worst_best_time_complexity.c
+ * Created Time: 2023-01-03
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
 
-#include "stdio.h"
-#include "stdlib.h"
-#include "time.h"
+#include "../include/include.h"
 
-// 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱
+/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
 int *randomNumbers(int n)  
 {
     // 分配堆区内存（创建一维可变长数组：数组中元素数量为n，元素类型为int）
@@ -27,7 +27,7 @@ int *randomNumbers(int n)
     return nums;
 }
 
-// 查找数组 nums 中数字 1 所在索引
+/* 查找数组 nums 中数字 1 所在索引 */
 int findOne(int *nums, int n) 
 {
     for (int i = 0; i < n; i++)
@@ -37,7 +37,7 @@ int findOne(int *nums, int n)
     return -1;
 }
 
-// Driver Code
+/* Driver Code */
 int main(int argc, char *argv[])
 {
     // 初始化随机数种子
diff --git a/codes/c/include/include.h b/codes/c/include/include.h
index 44843254e..8ce104cd2 100644
--- a/codes/c/include/include.h
+++ b/codes/c/include/include.h
@@ -1,2 +1,4 @@
 #include <stdio.h>
-#include <stdbool.h>
\ No newline at end of file
+#include <stdbool.h>
+#include <stdlib.h>
+#include <time.h>
\ No newline at end of file
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 539c9b5cb..5d61dc005 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -91,7 +91,17 @@ $$
 === "C"
 
     ```c title=""
-
+    // 在某运行平台下
+    void algorithm(int n) 
+    {
+        int a = 2;  // 1 ns
+        a = a + 1;  // 1 ns
+        a = a * 2;  // 10 ns
+        // 循环 n 次
+        for (int i = 0; i < n; i++) {   // 1 ns ，每轮都要执行 i++
+            printf("%d", 0);            // 5 ns
+        }
+    }
     ```
 
 === "C#"
@@ -232,7 +242,25 @@ $$
 === "C"
 
     ```c title=""
-
+    // 算法 A 时间复杂度：常数阶
+    void algorithm_A(int n) 
+    {
+        printf("%d", 0);
+    }
+    // 算法 B 时间复杂度：线性阶
+    void algorithm_B(int n) 
+    {
+        for (int i = 0; i < n; i++) {
+            printf("%d", 0);
+        }
+    }
+    // 算法 C 时间复杂度：常数阶
+    void algorithm_C(int n) 
+    {
+        for (int i = 0; i < 1000000; i++) {
+            printf("%d", 0);
+        }
+    }
     ```
 
 === "C#"
@@ -373,7 +401,16 @@ $$
 === "C"
 
     ```c title=""
-
+    void algorithm(int n) 
+    {
+        int a = 1;  // +1
+        a = a + 1;  // +1
+        a = a * 2;  // +1
+        // 循环 n 次
+        for (int i = 0; i < n; i++) {   // +1（每轮都执行 i ++）
+            printf("%d", 0);            // +1
+        }
+    }  
     ```
 
 === "C#"
@@ -542,7 +579,21 @@ $$
 === "C"
 
     ```c title=""
-
+    void algorithm(int n) 
+    {
+        int a = 1;  // +0（技巧 1）
+        a = a + n;  // +0（技巧 1）
+        // +n（技巧 2）
+        for (int i = 0; i < 5 * n + 1; i++) {
+            printf("%d", 0);
+        }
+        // +n*n（技巧 3）
+        for (int i = 0; i < 2 * n; i++) {
+            for (int j = 0; j < n + 1; j++) {
+                printf("%d", 0);
+            }
+        }
+    }
     ```
 
 === "C#"
@@ -697,7 +748,17 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-
+    /* 常数阶 */
+    int constant(int n) 
+    {
+        int count = 0;
+        int size = 100000;
+        int i = 0;
+        for(int i = 0; i < size; i++){
+            count ++;
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -795,7 +856,15 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-
+    /* 线性阶 */
+    int linear(int n) 
+    {
+        int count = 0;
+        for(int i = 0; i < n; i++){
+            count ++;
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -899,7 +968,16 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-
+    /* 线性阶（遍历数组） */
+    int arrayTraversal(int *nums, int n)
+    {
+        int count = 0;
+        // 循环次数与数组长度成正比
+        for(int i = 0; i < n; i++){
+            count ++;
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -1012,7 +1090,18 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-
+    /* 平方阶 */
+    int quadratic(int n) 
+    {
+        int count = 0;
+        // 循环次数与数组长度成平方关系
+        for(int i = 0; i < n; i++){
+            for(int j = 0; j < n; j++){
+                count ++;
+            }
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -1163,7 +1252,25 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-
+    /* 平方阶（冒泡排序） */
+    int bubbleSort(int *nums, int n)
+    {
+        int count = 0;  // 计数器 
+        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        for(int i = n - 1; i > 0; i--){
+            // 内循环：冒泡操作
+            for (int j = 0; j < i; j++)
+            {
+                // 交换 nums[j] 与 nums[j + 1]
+                int tmp = nums[j];
+                nums[j] = nums[j + 1];
+                nums[j + 1] = tmp;
+                count += 3;  // 元素交换包含 3 个单元操作
+            }
+            
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -1309,7 +1416,23 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-
+    /* 指数阶（循环实现） */
+    int exponential(int n) 
+    {
+        int count = 0;
+        int bas = 1;
+        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        for (int i = 0; i < n; i++)
+        {
+            for (int j = 0; j < bas; j++)
+            {
+                count++;
+            }
+            bas *= 2;
+        }
+        // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+        return count;
+    }
     ```
 
 === "C#"
@@ -1414,7 +1537,12 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-
+    /* 指数阶（递归实现） */
+    int expRecur(int n) 
+    {
+        if (n == 1) return 1;
+        return expRecur(n - 1) + expRecur(n - 1) + 1;
+    }
     ```
 
 === "C#"
@@ -1517,7 +1645,17 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-
+    /* 对数阶（循环实现） */
+    int logarithmic(float n)
+    {
+        int count = 0;
+        while (n > 1)
+        {
+            n = n / 2;
+            count++;
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -1613,7 +1751,12 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-
+    /* 对数阶（递归实现） */
+    int logRecur(float n)
+    {
+        if (n <= 1) return 0;
+        return logRecur(n / 2) + 1;
+    }
     ```
 
 === "C#"
@@ -1720,7 +1863,18 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-
+    /* 线性对数阶 */
+    int linearLogRecur(float n)
+    {
+        if (n <= 1) return 1;
+        int count = linearLogRecur(n / 2) +
+                    linearLogRecur(n / 2);
+        for (int i = 0; i < n; i++)
+        {
+            count ++;
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -1845,7 +1999,17 @@ $$
 === "C"
 
     ```c title="time_complexity.c"
-
+    /* 阶乘阶（递归实现） */
+    int factorialRecur(int n) 
+    {
+        if (n == 0) return 1;
+        int count = 0;
+        for (int i = 0; i < n; i++)
+        {
+            count += factorialRecur(n - 1);
+        }
+        return count;
+    }
     ```
 
 === "C#"
@@ -2061,7 +2225,62 @@ $$
 === "C"
 
     ```c title="worst_best_time_complexity.c"
+    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
+    int *randomNumbers(int n)  
+    {
+        // 分配堆区内存（创建一维可变长数组：数组中元素数量为n，元素类型为int）
+        int *nums = (int *)malloc(n * sizeof(int));
+        // 生成数组 nums = { 1, 2, 3, ..., n }
+        for (int i = 0; i < n; i++)
+        {
+            nums[i] = i + 1;
+        }
+        // 随机打乱数组元素 
+        for (int i = n - 1; i > 0; i--)
+        {
+            int j = rand() % (i + 1);
+            int temp = nums[i];
+            nums[i] = nums[j];
+            nums[j] = temp; 
+        }
+        return nums;
+    }
 
+    /* 查找数组 nums 中数字 1 所在索引 */
+    int findOne(int *nums, int n) 
+    {
+        for (int i = 0; i < n; i++)
+        {
+            if (nums[i] == 1) return i;
+        }
+        return -1;
+    }
+
+    /* Driver Code */
+    int main(int argc, char *argv[])
+    {
+        // 初始化随机数种子
+        srand((unsigned int)time(NULL));
+        for (int i = 0; i < 10; i++)
+        {
+            int n = 100;
+            int *nums = randomNumbers(n);
+            int index = findOne(nums, n);
+            printf("\n数组 [ 1, 2, ..., n ] 被打乱后 = ");
+            for (int j = 0; j < n; j++)
+            {
+                printf("%d%s", nums[j], (j == n-1)? "" : "," );
+            }
+            printf("\n数字 1 的索引为 %d\n", index);
+            // 释放堆区内存
+            if(nums != NULL){
+                free(nums);
+                nums = NULL;
+            }
+        }
+        getchar();
+        return 0;
+    }
     ```
 
 === "C#"

From e0a3189f91c2af5c0d82d413ddd5c272594951a2 Mon Sep 17 00:00:00 2001
From: MolDuM <39506381+MolDuM@users.noreply.github.com>
Date: Wed, 4 Jan 2023 14:56:16 +0800
Subject: [PATCH 082/158] Update array.c

3 changes:
1. In the enlarge part, I didn't change because I didn't find a good way to deal with the local variable and the clear definition. malloc is commonly used in LeetCode so I think it is not bad for a beginner.
2. I changed the initialization of the second array to make it in the same style as C++.
3. In the enlarge part in main, I deleted the code of pointer free to match the array operations. I also changed the operate array in the later part because the enlarged array cannot be assigned to the older array name.

BTW, sorry for updating so late. Reading different version documents and book are really tiring and boring.
---
 codes/c/chapter_array_and_linkedlist/array.c | 30 ++++++--------------
 1 file changed, 9 insertions(+), 21 deletions(-)

diff --git a/codes/c/chapter_array_and_linkedlist/array.c b/codes/c/chapter_array_and_linkedlist/array.c
index 6217a566f..300124a70 100644
--- a/codes/c/chapter_array_and_linkedlist/array.c
+++ b/codes/c/chapter_array_and_linkedlist/array.c
@@ -76,16 +76,7 @@ int main() {
     printf("数组 arr = ");
     printArray(arr, size);
 
-    int arr2[5] = { 1, 3, 2, 5, 4 };
-    printf("数组 arr2 = ");
-    printArray(arr2, size);
-
-    int* nums = (int *)malloc(sizeof(int) * size);
-    nums[0] = 1;
-    nums[1] = 3;
-    nums[2] = 2;
-    nums[3] = 5;
-    nums[4] = 4;
+    int nums[5] = { 1, 3, 2, 5, 4 };
     printf("数组 nums = ");
     printArray(nums, size);
     
@@ -96,29 +87,26 @@ int main() {
     /* 长度扩展 */
     int enlarge = 3;
     int* res = extend(nums, size, enlarge);
-    int* temp = nums;
-    nums = res;
-    free(temp);
     size += enlarge;
     printf("将数组长度扩展至 8 ，得到 nums = ");
-    printArray(nums, size);
+    printArray(res, size);
     
     /* 插入元素 */
-    insert(nums, size, 6, 3);
+    insert(res, size, 6, 3);
     printf("在索引 3 处插入数字 6 ，得到 nums = ");
-    printArray(nums, size);
+    printArray(res, size);
 
     /* 删除元素 */
-    removeItem(nums, size, 2);
+    removeItem(res, size, 2);
     printf("删除索引 2 处的元素，得到 nums = ");
-    printArray(nums, size);
+    printArray(res, size);
     
     /* 遍历数组 */
-    traverse(nums, size);
+    traverse(res, size);
     
     /* 查找元素 */
-    int index = find(nums, size, 3);
-    printf("在 nums 中查找元素 3 ，得到索引 = %d\n", index);
+    int index = find(res, size, 3);
+    printf("在 res 中查找元素 3 ，得到索引 = %d\n", index);
 
     return 0;
 }

From 57757943511c9fc4577bfd0aa72298dc1603fe85 Mon Sep 17 00:00:00 2001
From: moonache <476681765@qq.com>
Date: Wed, 4 Jan 2023 19:27:35 +0800
Subject: [PATCH 083/158] =?UTF-8?q?=E9=94=99=E5=88=AB=E5=AD=97=EF=BC=9A?=
 =?UTF-8?q?=E4=BB=8E=E9=A1=B6=E7=BD=AE=E5=BA=95=20->=20=E4=BB=8E=E9=A1=B6?=
 =?UTF-8?q?=E8=87=B3=E5=BA=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/chapter_tree/binary_tree.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md
index 0c858fd3a..3e3222222 100644
--- a/docs/chapter_tree/binary_tree.md
+++ b/docs/chapter_tree/binary_tree.md
@@ -120,7 +120,7 @@ comments: true
 
 - 「根结点 Root Node」：二叉树最顶层的结点，其没有父结点；
 - 「叶结点 Leaf Node」：没有子结点的结点，其两个指针都指向 $\text{null}$ ；
-- 结点所处「层 Level」：从顶置底依次增加，根结点所处层为 1 ；
+- 结点所处「层 Level」：从顶至底依次增加，根结点所处层为 1 ；
 - 结点「度 Degree」：结点的子结点数量。二叉树中，度的范围是 0, 1, 2 ；
 - 「边 Edge」：连接两个结点的边，即结点指针；
 - 二叉树「高度」：二叉树中根结点到最远叶结点走过边的数量；

From b5c9db935e8e0904ced4e0e09369a8b3fda13c64 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 01:00:56 +0800
Subject: [PATCH 084/158] Update
 docs/chapter_computational_complexity/time_complexity.md

Co-authored-by: Justin Tse <xiefahit@gmail.com>
---
 docs/chapter_computational_complexity/time_complexity.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 22dc3472a..8ef61d061 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -684,7 +684,7 @@ $$
 
 <div class="center-table" markdown>
 
-| 操作数量 $T(n)$        | 时间复杂度 $O(f(n))$ |
+| 操作数量 $T(n)$         | 时间复杂度 $O(f(n))$   |
 | ---------------------- | -------------------- |
 | $100000$               | $O(1)$               |
 | $3n + 2$               | $O(n)$               |

From abdf1f3117fded4a4721462b37ffb960da869841 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 01:01:03 +0800
Subject: [PATCH 085/158] Update
 codes/javascript/chapter_computational_complexity/time_complexity.js

Co-authored-by: Justin Tse <xiefahit@gmail.com>
---
 .../chapter_computational_complexity/time_complexity.js         | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/codes/javascript/chapter_computational_complexity/time_complexity.js b/codes/javascript/chapter_computational_complexity/time_complexity.js
index c8809caa0..2e4688dd2 100644
--- a/codes/javascript/chapter_computational_complexity/time_complexity.js
+++ b/codes/javascript/chapter_computational_complexity/time_complexity.js
@@ -118,6 +118,8 @@ function factorialRecur(n) {
     return count;
 }
 
+/* Driver Code */
+// 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
 const n = 8;
 console.log("输入数据大小 n = " + n);
 

From c5a9eea0a94b1b5d6c184262bc49236b6489c0de Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 01:01:17 +0800
Subject: [PATCH 086/158] Update
 codes/typescript/chapter_computational_complexity/time_complexity.ts

Co-authored-by: Justin Tse <xiefahit@gmail.com>
---
 .../chapter_computational_complexity/time_complexity.ts         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/codes/typescript/chapter_computational_complexity/time_complexity.ts b/codes/typescript/chapter_computational_complexity/time_complexity.ts
index 900585c81..fbfb470e7 100644
--- a/codes/typescript/chapter_computational_complexity/time_complexity.ts
+++ b/codes/typescript/chapter_computational_complexity/time_complexity.ts
@@ -20,7 +20,7 @@ function linear(n: number): number {
 }
 
 /* 线性阶（遍历数组） */
-function arrayTraversal(nums: number[]) {
+function arrayTraversal(nums: number[]): number {
     let count = 0;
     // 循环次数与数组长度成正比
     for (let i = 0; i < nums.length; i++) {

From a29a584b6f7b6ee3d94dbcdfa8132fdeb6178123 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 01:01:28 +0800
Subject: [PATCH 087/158] Update
 codes/typescript/chapter_computational_complexity/time_complexity.ts

Co-authored-by: Justin Tse <xiefahit@gmail.com>
---
 .../chapter_computational_complexity/time_complexity.ts         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/codes/typescript/chapter_computational_complexity/time_complexity.ts b/codes/typescript/chapter_computational_complexity/time_complexity.ts
index fbfb470e7..136e5e25f 100644
--- a/codes/typescript/chapter_computational_complexity/time_complexity.ts
+++ b/codes/typescript/chapter_computational_complexity/time_complexity.ts
@@ -121,7 +121,7 @@ function factorialRecur(n: number): number {
 var n = 8;
 console.log("输入数据大小 n = " + n);
 
-var count = constant(n);
+let count = constant(n);
 console.log("常数阶的计算操作数量 = " + count);
 
 count = linear(n);

From d5969e407057a1a940aff1c7e0786aa6b66406fd Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 01:01:42 +0800
Subject: [PATCH 088/158] Update
 docs/chapter_computational_complexity/time_complexity.md

Co-authored-by: Justin Tse <xiefahit@gmail.com>
---
 docs/chapter_computational_complexity/time_complexity.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 8ef61d061..5a44a17f1 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -1013,7 +1013,7 @@ $$
 
     ```typescript title="time_complexity.ts"
     /* 线性阶（遍历数组） */
-    function arrayTraversal(nums: number[]) {
+    function arrayTraversal(nums: number[]): number {
         let count = 0;
         // 循环次数与数组长度成正比
         for (let i = 0; i < nums.length; i++) {

From 3906c3df06e4bd33e38dcfcd9131a8f2413e25db Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 01:01:53 +0800
Subject: [PATCH 089/158] Update
 docs/chapter_computational_complexity/time_complexity.md

Co-authored-by: Justin Tse <xiefahit@gmail.com>
---
 docs/chapter_computational_complexity/time_complexity.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 5a44a17f1..e567718a5 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -601,8 +601,8 @@ $$
             console.log(0);
         }
         // +n*n（技巧 3）
-        for (var i = 0; i < 2 * n; i++) {
-            for (var j = 0; j < n + 1; j++) {
+        for (let i = 0; i < 2 * n; i++) {
+            for (let j = 0; j < n + 1; j++) {
                 console.log(0);
             }
         }

From 9f7a9fde20a3cbca9cf5a647c23f46e9f9a04c5d Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 01:02:00 +0800
Subject: [PATCH 090/158] Update
 codes/typescript/chapter_computational_complexity/time_complexity.ts

Co-authored-by: Justin Tse <xiefahit@gmail.com>
---
 .../chapter_computational_complexity/time_complexity.ts       | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/codes/typescript/chapter_computational_complexity/time_complexity.ts b/codes/typescript/chapter_computational_complexity/time_complexity.ts
index 136e5e25f..e5dde67c6 100644
--- a/codes/typescript/chapter_computational_complexity/time_complexity.ts
+++ b/codes/typescript/chapter_computational_complexity/time_complexity.ts
@@ -118,7 +118,9 @@ function factorialRecur(n: number): number {
     return count;
 }
 
-var n = 8;
+/* Driver Code */
+// 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
+const n = 8;
 console.log("输入数据大小 n = " + n);
 
 let count = constant(n);

From 2acf85a6260a2c134aea77b29d7243f0854c2961 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 01:02:09 +0800
Subject: [PATCH 091/158] Update
 docs/chapter_computational_complexity/time_complexity.md

Co-authored-by: Justin Tse <xiefahit@gmail.com>
---
 docs/chapter_computational_complexity/time_complexity.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index e567718a5..b3dc3c35d 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -79,6 +79,7 @@ $$
 === "JavaScript"
 
     ```js title=""
+    // 在某运行平台下
     function algorithm(n) {
         var a = 2; // 1 ns
         a = a + 1; // 1 ns

From 3fa04aeb4a2e7140292efbd2b24d9d3536ffbcd4 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 01:02:19 +0800
Subject: [PATCH 092/158] Update
 docs/chapter_computational_complexity/time_complexity.md

Co-authored-by: Justin Tse <xiefahit@gmail.com>
---
 docs/chapter_computational_complexity/time_complexity.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index b3dc3c35d..b26fdf2bf 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -617,7 +617,7 @@ $$
         var a: number = 1;  // +0（技巧 1）
         a = a + n;  // +0（技巧 1）
         // +n（技巧 2）
-        for (var i = 0; i < 5 * n + 1; i++) {
+        for (let i = 0; i < 5 * n + 1; i++) {
             console.log(0);
         }
         // +n*n（技巧 3）

From 03aeda84e22d2237e17078213e23680f93fb9332 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 01:02:51 +0800
Subject: [PATCH 093/158] Update
 docs/chapter_computational_complexity/time_complexity.md

Co-authored-by: Justin Tse <xiefahit@gmail.com>
---
 docs/chapter_computational_complexity/time_complexity.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index b26fdf2bf..ee1f6f0ce 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -621,8 +621,8 @@ $$
             console.log(0);
         }
         // +n*n（技巧 3）
-        for (var i = 0; i < 2 * n; i++) {
-            for (var j = 0; j < n + 1; j++) {
+        for (let i = 0; i < 2 * n; i++) {
+            for (let j = 0; j < n + 1; j++) {
                 console.log(0);
             }
         }

From 51004b8a85d2a9d2efa35237c58e57994c2a32f0 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 01:05:59 +0800
Subject: [PATCH 094/158] Apply suggestions from code review

Co-authored-by: Justin Tse <xiefahit@gmail.com>
---
 .../time_complexity.md                        | 25 +++++++++++--------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index ee1f6f0ce..9dcb5d84b 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -84,7 +84,8 @@ $$
         var a = 2; // 1 ns
         a = a + 1; // 1 ns
         a = a * 2; // 10 ns
-        for(var i = 0; i < n; i++) { // 1 ns ，每轮都要执行 i++
+        // 循环 n 次
+        for(let i = 0; i < n; i++) { // 1 ns ，每轮都要执行 i++
             console.log(0); // 5 ns
         }
     }
@@ -93,11 +94,13 @@ $$
 === "TypeScript"
 
     ```typescript title=""
+    // 在某运行平台下
     function algorithm(n: number): void {
         var a: number = 2; // 1 ns
         a = a + 1; // 1 ns
         a = a * 2; // 10 ns
-        for(var i = 0; i < n; i++) { // 1 ns ，每轮都要执行 i++
+        // 循环 n 次
+        for(let i = 0; i < n; i++) { // 1 ns ，每轮都要执行 i++
             console.log(0); // 5 ns
         }
     }
@@ -241,13 +244,13 @@ $$
     }
     // 算法 B 时间复杂度：线性阶
     function algorithm_B(n) {
-        for (var i = 0; i < n; i++) {
+        for (let i = 0; i < n; i++) {
             console.log(0);
         }
     }
     // 算法 C 时间复杂度：常数阶
     function algorithm_C(n) {
-        for (var i = 0; i < 1000000; i++) {
+        for (let i = 0; i < 1000000; i++) {
             console.log(0);
         }
     }
@@ -263,13 +266,13 @@ $$
     }
     // 算法 B 时间复杂度：线性阶
     function algorithm_B(n: number): void {
-        for (var i = 0; i < n; i++) {
+        for (let i = 0; i < n; i++) {
             console.log(0);
         }
     }
     // 算法 C 时间复杂度：常数阶
     function algorithm_C(n: number): void {
-        for (var i = 0; i < 1000000; i++) {
+        for (let i = 0; i < 1000000; i++) {
             console.log(0);
         }
     }
@@ -412,7 +415,7 @@ $$
         a += 1; // +1
         a *= 2; // +1
         // 循环 n 次
-        for(var i = 0; i < n; i++){ // +1
+        for(let i = 0; i < n; i++){ // +1（每轮都执行 i ++）
             console.log(0); // +1
         }
 
@@ -427,7 +430,7 @@ $$
         a += 1; // +1
         a *= 2; // +1
         // 循环 n 次
-        for(var i = 0; i < n; i++){ // +1
+        for(let i = 0; i < n; i++){ // +1（每轮都执行 i ++）
             console.log(0); // +1
         }
 
@@ -595,10 +598,10 @@ $$
 
     ```js title=""
     function algorithm(n) {
-        var a = 1;  // +0（技巧 1）
+        let a = 1;  // +0（技巧 1）
         a = a + n;  // +0（技巧 1）
         // +n（技巧 2）
-        for (var i = 0; i < 5 * n + 1; i++) {
+        for (let i = 0; i < 5 * n + 1; i++) {
             console.log(0);
         }
         // +n*n（技巧 3）
@@ -614,7 +617,7 @@ $$
 
     ```typescript title=""
     function algorithm(n: number): void {
-        var a: number = 1;  // +0（技巧 1）
+        let a = 1;  // +0（技巧 1）
         a = a + n;  // +0（技巧 1）
         // +n（技巧 2）
         for (let i = 0; i < 5 * n + 1; i++) {

From 4223cceda1552bba4b8d84e00a28a4eff7e14e9a Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 01:39:22 +0800
Subject: [PATCH 095/158] Update stack.md

---
 docs/chapter_preface/about_the_book.md | 2 +-
 docs/chapter_stack_and_queue/stack.md  | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/docs/chapter_preface/about_the_book.md b/docs/chapter_preface/about_the_book.md
index bc79115a3..54cd2844c 100644
--- a/docs/chapter_preface/about_the_book.md
+++ b/docs/chapter_preface/about_the_book.md
@@ -86,7 +86,7 @@ comments: true
 - 文章中的重要名词会用「」符号标注，例如「数组 Array」。名词混淆会导致不必要的歧义，因此最好可以记住这类名词（包括中文和英文），以便后续阅读文献时使用。
 - 重点内容、总起句、总结句会被 **加粗** ，此类文字值得特别关注。
 - 专有名词和有特指含义的词句会使用 “ ” 标注，以避免歧义。
-- 在工程应用中，每种语言都有相应的注释规范；而本书放弃了一部分的注释规范性，以换取更加紧凑的内容排版。注释主要分为三种类型：标题注释、内容注释、多行注释。
+- 在工程应用中，每种语言都有注释规范；而本书放弃了一部分的注释规范性，以换取更加紧凑的内容排版。注释主要分为三种类型：标题注释、内容注释、多行注释。
 
 === "Java"
 
diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index c982f5a75..a8b06575b 100644
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -236,7 +236,9 @@ comments: true
 
 ### 基于链表的实现
 
-使用「链表」实现栈时，将链表的尾结点看作栈顶即可。
+使用「链表」实现栈时，将链表的头结点看作栈顶，尾结点看作栈底。
+
+对于入栈操作，将元素插入到链表头部即可，这种结点添加方式被称为“头插法”。而对于出栈操作，则将头结点从链表中删除即可。
 
 受益于链表的离散存储方式，栈的扩容更加灵活，删除元素的内存也会被系统自动回收；缺点是无法像数组一样高效地随机访问，并且由于链表结点需存储指针，导致单个元素占用空间更大。
 
@@ -592,7 +594,7 @@ comments: true
 
 ### 基于数组的实现
 
-使用「数组」实现栈时，将数组的尾部当作栈顶。准确地说，我们需要使用「列表」，因为入栈的元素可能是源源不断的，因此使用动态数组可以方便扩容。
+使用「数组」实现栈时，将数组的尾部当作栈顶，这样可以保证入栈与出栈操作的时间复杂度都为 $O(1)$ 。准确地说，由于入栈的元素可能是源源不断的，我们需要使用可以动态扩容的「列表」。
 
 基于数组实现的栈，优点是支持随机访问，缺点是会造成一定的空间浪费，因为列表的容量始终 $\geq$ 元素数量。
 

From 33023549095ae85eab68ab1c0e580a4ef14ad002 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 01:45:08 +0800
Subject: [PATCH 096/158] Update cpp codes for the stack and the queue.

---
 codes/cpp/chapter_stack_and_queue/array_queue.cpp      | 7 +++----
 codes/cpp/chapter_stack_and_queue/array_stack.cpp      | 7 +++----
 codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp | 7 +++----
 codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp | 7 +++----
 4 files changed, 12 insertions(+), 16 deletions(-)

diff --git a/codes/cpp/chapter_stack_and_queue/array_queue.cpp b/codes/cpp/chapter_stack_and_queue/array_queue.cpp
index 387ffd142..8e87da501 100644
--- a/codes/cpp/chapter_stack_and_queue/array_queue.cpp
+++ b/codes/cpp/chapter_stack_and_queue/array_queue.cpp
@@ -50,11 +50,10 @@ public:
     }
 
     /* 出队 */
-    int poll() {
+    void poll() {
         int num = peek();
         // 队头指针向后移动一位，若越过尾部则返回到数组头部
         front = (front + 1) % capacity();
-        return num;
     }
 
     /* 访问队首元素 */
@@ -98,8 +97,8 @@ int main() {
     cout << "队首元素 peek = " << peek << endl;
     
     /* 元素出队 */
-    int poll = queue->poll();
-    cout << "出队元素 poll = " << poll << "，出队后 queue = ";
+    queue->poll();
+    cout << "出队元素 poll = " << peek << "，出队后 queue = ";
     PrintUtil::printVector(queue->toVector());
 
     /* 获取队列的长度 */
diff --git a/codes/cpp/chapter_stack_and_queue/array_stack.cpp b/codes/cpp/chapter_stack_and_queue/array_stack.cpp
index 517a18a4d..e9ecae2a8 100644
--- a/codes/cpp/chapter_stack_and_queue/array_stack.cpp
+++ b/codes/cpp/chapter_stack_and_queue/array_stack.cpp
@@ -28,10 +28,9 @@ public:
     }
 
     /* 出栈 */
-    int pop() {
+    void pop() {
         int oldTop = top();
         stack.pop_back();
-        return oldTop;
     }
 
     /* 访问栈顶元素 */
@@ -67,8 +66,8 @@ int main() {
     cout << "栈顶元素 top = " << top << endl;
 
     /* 元素出栈 */
-    int pop = stack->pop();
-    cout << "出栈元素 pop = " << pop << "，出栈后 stack = ";
+    stack->pop();
+    cout << "出栈元素 pop = " << top << "，出栈后 stack = ";
     PrintUtil::printVector(stack->toVector());
 
     /* 获取栈的长度 */
diff --git a/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp b/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp
index dcaac225f..10cba0aaf 100644
--- a/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp
+++ b/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp
@@ -47,7 +47,7 @@ public:
     }
 
     /* 出队 */
-    int poll() {
+    void poll() {
         int num = peek();
         // 删除头结点
         ListNode *tmp = front;
@@ -55,7 +55,6 @@ public:
         // 释放内存
         delete tmp; 
         queSize--;
-        return num;
     }
 
     /* 访问队首元素 */
@@ -97,8 +96,8 @@ int main() {
     cout << "队首元素 peek = " << peek << endl;
 
     /* 元素出队 */
-    int poll = queue->poll();
-    cout << "出队元素 poll = " << poll << "，出队后 queue = ";
+    queue->poll();
+    cout << "出队元素 poll = " << peek << "，出队后 queue = ";
     PrintUtil::printVector(queue->toVector());
 
     /* 获取队列的长度 */
diff --git a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp
index 312b75135..cf6f6ab3d 100644
--- a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp
+++ b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp
@@ -37,14 +37,13 @@ public:
     }
 
     /* 出栈 */
-    int pop() {
+    void pop() {
         int num = top();
         ListNode *tmp = stackTop;
         stackTop = stackTop->next;
         // 释放内存
         delete tmp;
         stkSize--;
-        return num;
     }
 
     /* 访问栈顶元素 */
@@ -86,8 +85,8 @@ int main() {
     cout << "栈顶元素 top = " << top << endl;
 
     /* 元素出栈 */
-    int pop = stack->pop();
-    cout << "出栈元素 pop = " << pop << "，出栈后 stack = ";
+    stack->pop();
+    cout << "出栈元素 pop = " << top << "，出栈后 stack = ";
     PrintUtil::printVector(stack->toVector());
 
     /* 获取栈的长度 */

From fd3eaaf3fd6ef25080a9c886cd678cd1704bfab1 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 01:59:31 +0800
Subject: [PATCH 097/158] Update stack.md and queue.md

---
 docs/chapter_stack_and_queue/queue.md | 6 ++----
 docs/chapter_stack_and_queue/stack.md | 6 ++----
 2 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/docs/chapter_stack_and_queue/queue.md b/docs/chapter_stack_and_queue/queue.md
index cc815b3ab..cbf854f9c 100644
--- a/docs/chapter_stack_and_queue/queue.md
+++ b/docs/chapter_stack_and_queue/queue.md
@@ -328,7 +328,7 @@ comments: true
             queSize++;
         }
         /* 出队 */
-        int poll() {
+        void poll() {
             int num = peek();
             // 删除头结点
             ListNode *tmp = front;
@@ -336,7 +336,6 @@ comments: true
             // 释放内存
             delete tmp; 
             queSize--;
-            return num;
         }
         /* 访问队首元素 */
         int peek() {
@@ -719,11 +718,10 @@ comments: true
             rear = (rear + 1) % capacity();
         }
         /* 出队 */
-        int poll() {
+        void poll() {
             int num = peek();
             // 队头指针向后移动一位，若越过尾部则返回到数组头部
             front = (front + 1) % capacity();
-            return num;
         }
         /* 访问队首元素 */
         int peek() {
diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index a8b06575b..ac4cf7cca 100644
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -313,14 +313,13 @@ comments: true
             stkSize++;
         }
         /* 出栈 */
-        int pop() {
+        void pop() {
             int num = top();
             ListNode *tmp = stackTop;
             stackTop = stackTop->next;
             // 释放内存
             delete tmp;
             stkSize--;
-            return num;
         }
         /* 访问栈顶元素 */
         int top() {
@@ -657,10 +656,9 @@ comments: true
             stack.push_back(num);
         }
         /* 出栈 */
-        int pop() {
+        void pop() {
             int oldTop = top();
             stack.pop_back();
-            return oldTop;
         }
         /* 访问栈顶元素 */
         int top() {

From 92a89d04dec923746c6ba94368ee01664e391322 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 5 Jan 2023 03:12:46 +0800
Subject: [PATCH 098/158] Update stack.md

---
 docs/chapter_stack_and_queue/stack.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index ac4cf7cca..2bc8b398e 100644
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -872,7 +872,7 @@ comments: true
 
 !!! tip
 
-    实际编程中，我们一般直接将 `ArrayList` 或 `LinkedList` 当作「栈」来使用。我们仅需通过脑补来屏蔽无关操作，而不用专门去包装它。
+    某些语言并未专门提供栈类，但我们可以直接把该语言的「数组」或「链表」看作栈来使用，并通过“脑补”来屏蔽无关操作，而无需像上述代码一样去特意包装一层。
 
 ## 栈典型应用
 

From e9fc6b362e9dedff90b47f0882b55d92dbaffbeb Mon Sep 17 00:00:00 2001
From: nuomi1 <nuomi1@qq.com>
Date: Tue, 3 Jan 2023 23:50:40 +0800
Subject: [PATCH 099/158] feat: add Swift codes for data_and_memory article

---
 docs/chapter_data_structure/data_and_memory.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/docs/chapter_data_structure/data_and_memory.md b/docs/chapter_data_structure/data_and_memory.md
index 3e1e2167c..c620032aa 100644
--- a/docs/chapter_data_structure/data_and_memory.md
+++ b/docs/chapter_data_structure/data_and_memory.md
@@ -114,6 +114,16 @@ comments: true
     bool[] booleans = new bool[5];
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    // 使用多种「基本数据类型」来初始化「数组」
+    let numbers = Array(repeating: Int(), count: 5)
+    let decimals = Array(repeating: Double(), count: 5)
+    let characters = Array(repeating: Character("a"), count: 5)
+    let booleans = Array(repeating: Bool(), count: 5)
+    ```
+
 ## 计算机内存
 
 在计算机中，内存和硬盘是两种主要的存储硬件设备。「硬盘」主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。「内存」用于运行程序时暂存数据，速度更快，但容量较小（通常为 GB 级别）。

From 7cd1347b4453b207c28f12e7d353398cbb4a4b20 Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Thu, 5 Jan 2023 10:16:05 +0800
Subject: [PATCH 100/158] code(js): worst best time complexity

---
 .../worst_best_time_complexity.js             | 41 +++++++++++++++++++
 .../time_complexity.md                        | 34 +++++++++++++++
 2 files changed, 75 insertions(+)
 create mode 100644 codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js

diff --git a/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js b/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
new file mode 100644
index 000000000..db966b6fd
--- /dev/null
+++ b/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
@@ -0,0 +1,41 @@
+/*
+ * File: worst_best_time_complexity.js
+ * Created Time: 2023-01-05
+ * Author: RiverTwilight (contact@rene.wang)
+ */
+
+function randomNumbers(n) {
+    nums = Array(n);
+    for (let i = 0; i < n; i++) {
+        nums[i] = i + 1;
+    }
+    // 随机打乱数组元素
+    for (let i = 0; i < n; i++) {
+        let r = Math.floor(Math.random() * n);
+        let temp = nums[i];
+        nums[i] = nums[r];
+        nums[r] = temp;
+    }
+    return nums;
+}
+
+function findOne(nums) {
+    for (let i = 0; i < nums.length; i++) {
+        if (nums[i] == 1) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+function main() {
+    for (let i = 0; i < 10; i++) {
+        let n = 100;
+        let nums = randomNumbers(n);
+        let index = findOne(nums);
+        console.log(
+            "\n数组 [ 1, 2, ..., n ] 被打乱后 = [" + nums.join(", ") + "]"
+        );
+        console.log("数字 1 的索引为 " + index);
+    }
+}
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 9dcb5d84b..9f9e36c96 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -2328,7 +2328,41 @@ $$
 === "JavaScript"
 
     ```js title="worst_best_time_complexity.js"
+    function randomNumbers(n) {
+        nums = Array(n);
+        for (let i = 0; i < n; i++) {
+            nums[i] = i + 1;
+        }
+        // 随机打乱数组元素
+        for (let i = 0; i < n; i++) {
+            let r = Math.floor(Math.random() * n);
+            let temp = nums[i];
+            nums[i] = nums[r];
+            nums[r] = temp;
+        }
+        return nums;
+    }
 
+    function findOne(nums) {
+        for (let i = 0; i < nums.length; i++) {
+            if (nums[i] == 1) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    function main() {
+        for (let i = 0; i < 10; i++) {
+            let n = 100;
+            let nums = randomNumbers(n);
+            let index = findOne(nums);
+            console.log(
+                "\n数组 [ 1, 2, ..., n ] 被打乱后 = [" + nums.join(", ") + "]"
+            );
+            console.log("数字 1 的索引为 " + index);
+        }
+    }
     ```
 
 === "TypeScript"

From 8031e0e2c541846d90240b72431fca00b04b5c0e Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Thu, 5 Jan 2023 10:20:19 +0800
Subject: [PATCH 101/158] lint: added missing keyword

---
 .../worst_best_time_complexity.js             |  2 +-
 .../worst_best_time_complexity.ts             | 41 +++++++++++++++++++
 2 files changed, 42 insertions(+), 1 deletion(-)
 create mode 100644 codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts

diff --git a/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js b/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
index db966b6fd..f887fe28d 100644
--- a/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
+++ b/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
@@ -5,7 +5,7 @@
  */
 
 function randomNumbers(n) {
-    nums = Array(n);
+    let nums = Array(n);
     for (let i = 0; i < n; i++) {
         nums[i] = i + 1;
     }
diff --git a/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts b/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts
new file mode 100644
index 000000000..b263f994d
--- /dev/null
+++ b/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts
@@ -0,0 +1,41 @@
+/*
+ * File: worst_best_time_complexity.ts
+ * Created Time: 2023-01-05
+ * Author: RiverTwilight (contact@rene.wang)
+ */
+
+function randomNumbers(n: number): number[] {
+    nums = Array(n);
+    for (let i = 0; i < n; i++) {
+        nums[i] = i + 1;
+    }
+    // 随机打乱数组元素
+    for (let i = 0; i < n; i++) {
+        let r = Math.floor(Math.random() * n);
+        let temp = nums[i];
+        nums[i] = nums[r];
+        nums[r] = temp;
+    }
+    return nums;
+}
+
+function findOne(nums) {
+    for (let i = 0; i < nums.length; i++) {
+        if (nums[i] == 1) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+function main() {
+    for (let i = 0; i < 10; i++) {
+        let n = 100;
+        let nums = randomNumbers(n);
+        let index = findOne(nums);
+        console.log(
+            "\n数组 [ 1, 2, ..., n ] 被打乱后 = [" + nums.join(", ") + "]"
+        );
+        console.log("数字 1 的索引为 " + index);
+    }
+}

From c53f64d56ba3d29b04cfc0657032fd76bd195143 Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Thu, 5 Jan 2023 10:23:12 +0800
Subject: [PATCH 102/158] code(ts): worst best time complexity

---
 .../worst_best_time_complexity.ts             |  6 ++--
 .../time_complexity.md                        | 36 ++++++++++++++++++-
 2 files changed, 38 insertions(+), 4 deletions(-)

diff --git a/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts b/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts
index b263f994d..97ca003a1 100644
--- a/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts
+++ b/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts
@@ -5,7 +5,7 @@
  */
 
 function randomNumbers(n: number): number[] {
-    nums = Array(n);
+    let nums = Array(n);
     for (let i = 0; i < n; i++) {
         nums[i] = i + 1;
     }
@@ -19,7 +19,7 @@ function randomNumbers(n: number): number[] {
     return nums;
 }
 
-function findOne(nums) {
+function findOne(nums: number[]): number {
     for (let i = 0; i < nums.length; i++) {
         if (nums[i] == 1) {
             return i;
@@ -28,7 +28,7 @@ function findOne(nums) {
     return -1;
 }
 
-function main() {
+function main(): void {
     for (let i = 0; i < 10; i++) {
         let n = 100;
         let nums = randomNumbers(n);
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 9f9e36c96..815424dd3 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -2329,7 +2329,7 @@ $$
 
     ```js title="worst_best_time_complexity.js"
     function randomNumbers(n) {
-        nums = Array(n);
+        let nums = Array(n);
         for (let i = 0; i < n; i++) {
             nums[i] = i + 1;
         }
@@ -2368,7 +2368,41 @@ $$
 === "TypeScript"
 
     ```typescript title="worst_best_time_complexity.ts"
+    function randomNumbers(n: number): number[] {
+        let nums = Array(n);
+        for (let i = 0; i < n; i++) {
+            nums[i] = i + 1;
+        }
+        // 随机打乱数组元素
+        for (let i = 0; i < n; i++) {
+            let r = Math.floor(Math.random() * n);
+            let temp = nums[i];
+            nums[i] = nums[r];
+            nums[r] = temp;
+        }
+        return nums;
+    }
 
+    function findOne(nums: number[]): number {
+        for (let i = 0; i < nums.length; i++) {
+            if (nums[i] == 1) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    function main(): void {
+        for (let i = 0; i < 10; i++) {
+            let n = 100;
+            let nums = randomNumbers(n);
+            let index = findOne(nums);
+            console.log(
+                "\n数组 [ 1, 2, ..., n ] 被打乱后 = [" + nums.join(", ") + "]"
+            );
+            console.log("数字 1 的索引为 " + index);
+        }
+    }
     ```
 
 === "C"

From 21096c8d0aba4cf68a00b2ce9e3159f0ee27bce4 Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Thu, 5 Jan 2023 10:27:48 +0800
Subject: [PATCH 103/158] lint: added comments

---
 .../worst_best_time_complexity.js                         | 4 ++++
 .../worst_best_time_complexity.ts                         | 4 ++++
 docs/chapter_computational_complexity/time_complexity.md  | 8 ++++++++
 3 files changed, 16 insertions(+)

diff --git a/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js b/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
index f887fe28d..791cfe7a2 100644
--- a/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
+++ b/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
@@ -4,8 +4,10 @@
  * Author: RiverTwilight (contact@rene.wang)
  */
 
+/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
 function randomNumbers(n) {
     let nums = Array(n);
+    // 生成数组 nums = { 1, 2, 3, ..., n }
     for (let i = 0; i < n; i++) {
         nums[i] = i + 1;
     }
@@ -19,6 +21,7 @@ function randomNumbers(n) {
     return nums;
 }
 
+/* 查找数组 nums 中数字 1 所在索引 */
 function findOne(nums) {
     for (let i = 0; i < nums.length; i++) {
         if (nums[i] == 1) {
@@ -28,6 +31,7 @@ function findOne(nums) {
     return -1;
 }
 
+/* Driver Code */
 function main() {
     for (let i = 0; i < 10; i++) {
         let n = 100;
diff --git a/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts b/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts
index 97ca003a1..68ed9bc35 100644
--- a/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts
+++ b/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts
@@ -4,8 +4,10 @@
  * Author: RiverTwilight (contact@rene.wang)
  */
 
+/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
 function randomNumbers(n: number): number[] {
     let nums = Array(n);
+    // 生成数组 nums = { 1, 2, 3, ..., n }
     for (let i = 0; i < n; i++) {
         nums[i] = i + 1;
     }
@@ -19,6 +21,7 @@ function randomNumbers(n: number): number[] {
     return nums;
 }
 
+/* 查找数组 nums 中数字 1 所在索引 */
 function findOne(nums: number[]): number {
     for (let i = 0; i < nums.length; i++) {
         if (nums[i] == 1) {
@@ -28,6 +31,7 @@ function findOne(nums: number[]): number {
     return -1;
 }
 
+/* Driver Code */
 function main(): void {
     for (let i = 0; i < 10; i++) {
         let n = 100;
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 815424dd3..db2c5614d 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -2328,8 +2328,10 @@ $$
 === "JavaScript"
 
     ```js title="worst_best_time_complexity.js"
+    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
     function randomNumbers(n) {
         let nums = Array(n);
+        // 生成数组 nums = { 1, 2, 3, ..., n }
         for (let i = 0; i < n; i++) {
             nums[i] = i + 1;
         }
@@ -2343,6 +2345,7 @@ $$
         return nums;
     }
 
+    /* 查找数组 nums 中数字 1 所在索引 */
     function findOne(nums) {
         for (let i = 0; i < nums.length; i++) {
             if (nums[i] == 1) {
@@ -2352,6 +2355,7 @@ $$
         return -1;
     }
 
+    /* Driver Code */
     function main() {
         for (let i = 0; i < 10; i++) {
             let n = 100;
@@ -2368,8 +2372,10 @@ $$
 === "TypeScript"
 
     ```typescript title="worst_best_time_complexity.ts"
+    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
     function randomNumbers(n: number): number[] {
         let nums = Array(n);
+        // 生成数组 nums = { 1, 2, 3, ..., n }
         for (let i = 0; i < n; i++) {
             nums[i] = i + 1;
         }
@@ -2383,6 +2389,7 @@ $$
         return nums;
     }
 
+    /* 查找数组 nums 中数字 1 所在索引 */
     function findOne(nums: number[]): number {
         for (let i = 0; i < nums.length; i++) {
             if (nums[i] == 1) {
@@ -2392,6 +2399,7 @@ $$
         return -1;
     }
 
+    /* Driver Code */
     function main(): void {
         for (let i = 0; i < 10; i++) {
             let n = 100;

From f34dde9c651c5a854a7829948cc2d2c50ae44ead Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 6 Jan 2023 03:13:06 +0800
Subject: [PATCH 104/158] Add back-to-top button.

---
 docs/chapter_stack_and_queue/stack.md | 2 +-
 mkdocs.yml                            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index 2bc8b398e..825cda9f9 100644
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -872,7 +872,7 @@ comments: true
 
 !!! tip
 
-    某些语言并未专门提供栈类，但我们可以直接把该语言的「数组」或「链表」看作栈来使用，并通过“脑补”来屏蔽无关操作，而无需像上述代码一样去特意包装一层。
+    某些语言并未专门提供栈类，但我们可以直接把该语言的「数组」或「链表」看作栈来使用，并通过“脑补”来屏蔽无关操作，而无需像上述代码去特意包装一层。
 
 ## 栈典型应用
 
diff --git a/mkdocs.yml b/mkdocs.yml
index 4aca74c24..9ddae9f39 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -32,7 +32,7 @@ theme:
     - navigation.sections
     # - navigation.tabs
     # - navigation.tabs.sticky
-    # - navigation.top
+    - navigation.top
     - navigation.footer
     - navigation.tracking
     - search.highlight

From e96272a06fcec961e401daa942cb89c61fd75d8a Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 6 Jan 2023 03:14:52 +0800
Subject: [PATCH 105/158] Apply suggestions from code review

Co-authored-by: Justin Tse <xiefahit@gmail.com>
---
 .../worst_best_time_complexity.js                             | 4 ++--
 .../worst_best_time_complexity.ts                             | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js b/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
index 791cfe7a2..949e50b04 100644
--- a/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
+++ b/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
@@ -13,7 +13,7 @@ function randomNumbers(n) {
     }
     // 随机打乱数组元素
     for (let i = 0; i < n; i++) {
-        let r = Math.floor(Math.random() * n);
+        let r = Math.floor(Math.random() * (i + 1));
         let temp = nums[i];
         nums[i] = nums[r];
         nums[r] = temp;
@@ -24,7 +24,7 @@ function randomNumbers(n) {
 /* 查找数组 nums 中数字 1 所在索引 */
 function findOne(nums) {
     for (let i = 0; i < nums.length; i++) {
-        if (nums[i] == 1) {
+        if (nums[i] === 1) {
             return i;
         }
     }
diff --git a/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts b/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts
index 68ed9bc35..a7318634f 100644
--- a/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts
+++ b/codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts
@@ -13,7 +13,7 @@ function randomNumbers(n: number): number[] {
     }
     // 随机打乱数组元素
     for (let i = 0; i < n; i++) {
-        let r = Math.floor(Math.random() * n);
+        let r = Math.floor(Math.random() * (i + 1));
         let temp = nums[i];
         nums[i] = nums[r];
         nums[r] = temp;
@@ -24,7 +24,7 @@ function randomNumbers(n: number): number[] {
 /* 查找数组 nums 中数字 1 所在索引 */
 function findOne(nums: number[]): number {
     for (let i = 0; i < nums.length; i++) {
-        if (nums[i] == 1) {
+        if (nums[i] === 1) {
             return i;
         }
     }

From 30b4ab6ba7c95a896e305e5091cff7f1b1275179 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 6 Jan 2023 03:28:27 +0800
Subject: [PATCH 106/158] Update array (Go).

---
 codes/go/chapter_array_and_linkedlist/array.go      | 5 -----
 codes/go/chapter_array_and_linkedlist/array_test.go | 5 ++++-
 docs/chapter_array_and_linkedlist/array.md          | 5 ++++-
 3 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/codes/go/chapter_array_and_linkedlist/array.go b/codes/go/chapter_array_and_linkedlist/array.go
index 5740811d8..0cf0d5d84 100644
--- a/codes/go/chapter_array_and_linkedlist/array.go
+++ b/codes/go/chapter_array_and_linkedlist/array.go
@@ -8,11 +8,6 @@ import (
 	"math/rand"
 )
 
-/**
-我们将 Go 中的 Slice 切片看作 Array 数组，降低理解成本，
-有利于我们将关注点放在数据结构与算法上。
-*/
-
 /* 随机返回一个数组元素 */
 func randomAccess(nums []int) (randomNum int) {
 	// 在区间 [0, nums.length) 中随机抽取一个数字
diff --git a/codes/go/chapter_array_and_linkedlist/array_test.go b/codes/go/chapter_array_and_linkedlist/array_test.go
index 7dff6a034..3d4e8f887 100644
--- a/codes/go/chapter_array_and_linkedlist/array_test.go
+++ b/codes/go/chapter_array_and_linkedlist/array_test.go
@@ -17,8 +17,11 @@ import (
 /* Driver Code */
 func TestArray(t *testing.T) {
 	/* 初始化数组 */
-	var arr []int
+	var arr [5]int
 	fmt.Println("数组 arr =", arr)
+	// 在 Go 中，指定长度时（[5]int）为数组，不指定长度时（[]int）为切片
+	// 由于 Go 的数组被设计为在编译期确定长度，因此只能使用常量来指定长度
+	// 为了方便实现扩容 extend() 方法，以下将切片（Slice）看作数组（Array）
 	nums := []int{1, 3, 2, 5, 4}
 	fmt.Println("数组 nums =", nums)
 
diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 7f853a8f5..648a9c753 100644
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -44,7 +44,10 @@ comments: true
 
     ```go title="array.go"
     /* 初始化数组 */
-    var arr []int
+    var arr [5]int
+    // 在 Go 中，指定长度时（[5]int）为数组，不指定长度时（[]int）为切片
+    // 由于 Go 的数组被设计为在编译期确定长度，因此只能使用常量来指定长度
+    // 为了方便实现扩容 extend() 方法，以下将切片（Slice）看作数组（Array）
     nums := []int{1, 3, 2, 5, 4}
     ```
 

From 75217d5e8bf0478ed86da5c24a171d263231b90f Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 6 Jan 2023 03:31:58 +0800
Subject: [PATCH 107/158] Update bubble sort (C) and insertion sort (C).

---
 codes/c/chapter_sorting/bubble_sort.c    | 11 ++++-------
 codes/c/chapter_sorting/insertion_sort.c |  6 ++----
 docs/chapter_sorting/bubble_sort.md      |  6 ++----
 docs/chapter_sorting/insertion_sort.md   |  3 +--
 4 files changed, 9 insertions(+), 17 deletions(-)

diff --git a/codes/c/chapter_sorting/bubble_sort.c b/codes/c/chapter_sorting/bubble_sort.c
index 6b67bd727..5c74d9e4e 100644
--- a/codes/c/chapter_sorting/bubble_sort.c
+++ b/codes/c/chapter_sorting/bubble_sort.c
@@ -7,8 +7,7 @@
 #include "../include/include.h"
 
 /* 冒泡排序 */
-void bubble_sort(int nums[], int size)
-{
+void bubble_sort(int nums[], int size) {
     // 外循环：待排序元素数量为 n-1, n-2, ..., 1
     for (int i = 0; i < size - 1; i++)
     {
@@ -26,8 +25,7 @@ void bubble_sort(int nums[], int size)
 }
 
 /* 冒泡排序（标志优化）*/
-void bubble_sort_with_flag(int nums[], int size)
-{
+void bubble_sort_with_flag(int nums[], int size) {
     // 外循环：待排序元素数量为 n-1, n-2, ..., 1
     for (int i = 0; i < size - 1; i++)
     {
@@ -50,8 +48,7 @@ void bubble_sort_with_flag(int nums[], int size)
 
 
 /* Driver Code */
-int main()
-{
+int main() {
     int nums[6] = {4, 1, 3, 1, 5, 2};
     printf("冒泡排序后:\n");
     bubble_sort(nums, 6);
@@ -69,4 +66,4 @@ int main()
     printf("\n");
 
     return 0;
-}
\ No newline at end of file
+}
diff --git a/codes/c/chapter_sorting/insertion_sort.c b/codes/c/chapter_sorting/insertion_sort.c
index ae1f6e7de..318a40278 100644
--- a/codes/c/chapter_sorting/insertion_sort.c
+++ b/codes/c/chapter_sorting/insertion_sort.c
@@ -7,8 +7,7 @@
 #include "../include/include.h"
 
 /* 插入排序 */
-void insertionSort(int nums[], int size)
-{
+void insertionSort(int nums[], int size) {
     // 外循环：base = nums[1], nums[2], ..., nums[n-1]
     for (int i = 1; i < size; i++)
     {
@@ -26,8 +25,7 @@ void insertionSort(int nums[], int size)
 }
 
 /* Driver Code */
-int main()
-{
+int main() {
     int nums[] = {4, 1, 3, 1, 5, 2};
     insertionSort(nums, 6);
     printf("插入排序完成后 nums = \n");
diff --git a/docs/chapter_sorting/bubble_sort.md b/docs/chapter_sorting/bubble_sort.md
index 336f3c2d5..bb35fabe4 100644
--- a/docs/chapter_sorting/bubble_sort.md
+++ b/docs/chapter_sorting/bubble_sort.md
@@ -170,8 +170,7 @@ comments: true
 
     ```c title="bubble_sort.c"
     /* 冒泡排序 */
-    void bubble_sort(int nums[], int size)
-    {
+    void bubble_sort(int nums[], int size) {
         // 外循环：待排序元素数量为 n-1, n-2, ..., 1
         for (int i = 0; i < size - 1; i++)
         {
@@ -368,8 +367,7 @@ comments: true
 
     ```c title="bubble_sort.c"
     /* 冒泡排序 */
-    void bubble_sort(int nums[], int size)
-    {
+    void bubble_sort(int nums[], int size) {
         // 外循环：待排序元素数量为 n-1, n-2, ..., 1
         for (int i = 0; i < size - 1; i++)
         {
diff --git a/docs/chapter_sorting/insertion_sort.md b/docs/chapter_sorting/insertion_sort.md
index faaf38358..85016f718 100644
--- a/docs/chapter_sorting/insertion_sort.md
+++ b/docs/chapter_sorting/insertion_sort.md
@@ -136,8 +136,7 @@ comments: true
 
     ```c title="insertion_sort.c"
     /* 插入排序 */
-    void insertionSort(int nums[], int size)
-    {
+    void insertionSort(int nums[], int size) {
         // 外循环：base = nums[1], nums[2], ..., nums[n-1]
         for (int i = 1; i < size; i++)
         {

From 0e49f0053a866f512235c55cf52b0f49044502e9 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 6 Jan 2023 03:39:19 +0800
Subject: [PATCH 108/158] Update the format of the file headers of c, cpp,
 java, js, ts, swift.

---
 codes/c/chapter_array_and_linkedlist/array.c                  | 2 +-
 codes/c/chapter_computational_complexity/time_complexity.c    | 3 +--
 .../worst_best_time_complexity.c                              | 3 +--
 codes/c/chapter_sorting/insertion_sort.c                      | 2 +-
 codes/c/include/PrintUtil.h                                   | 4 +---
 codes/c/include/include.h                                     | 4 +---
 codes/cpp/chapter_array_and_linkedlist/array.cpp              | 2 +-
 codes/cpp/chapter_array_and_linkedlist/linked_list.cpp        | 2 +-
 codes/cpp/chapter_array_and_linkedlist/list.cpp               | 2 +-
 codes/cpp/chapter_array_and_linkedlist/my_list.cpp            | 2 +-
 .../cpp/chapter_computational_complexity/leetcode_two_sum.cpp | 2 +-
 .../cpp/chapter_computational_complexity/space_complexity.cpp | 2 +-
 .../cpp/chapter_computational_complexity/time_complexity.cpp  | 2 +-
 .../worst_best_time_complexity.cpp                            | 2 +-
 codes/cpp/chapter_hashing/array_hash_map.cpp                  | 2 +-
 codes/cpp/chapter_hashing/hash_map.cpp                        | 2 +-
 codes/cpp/chapter_searching/binary_search.cpp                 | 2 +-
 codes/cpp/chapter_searching/hashing_search.cpp                | 2 +-
 codes/cpp/chapter_searching/linear_search.cpp                 | 2 +-
 codes/cpp/chapter_sorting/bubble_sort.cpp                     | 2 +-
 codes/cpp/chapter_sorting/insertion_sort.cpp                  | 2 +-
 codes/cpp/chapter_sorting/merge_sort.cpp                      | 2 +-
 codes/cpp/chapter_sorting/quick_sort.cpp                      | 2 +-
 codes/cpp/chapter_stack_and_queue/array_queue.cpp             | 2 +-
 codes/cpp/chapter_stack_and_queue/array_stack.cpp             | 2 +-
 codes/cpp/chapter_stack_and_queue/deque.cpp                   | 2 +-
 codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp        | 2 +-
 codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp        | 2 +-
 codes/cpp/chapter_stack_and_queue/queue.cpp                   | 2 +-
 codes/cpp/chapter_stack_and_queue/stack.cpp                   | 2 +-
 codes/cpp/chapter_tree/avl_tree.cpp                           | 2 +-
 codes/cpp/chapter_tree/binary_search_tree.cpp                 | 2 +-
 codes/cpp/chapter_tree/binary_tree.cpp                        | 2 +-
 codes/cpp/chapter_tree/binary_tree_bfs.cpp                    | 2 +-
 codes/cpp/chapter_tree/binary_tree_dfs.cpp                    | 2 +-
 codes/cpp/include/ListNode.hpp                                | 2 +-
 codes/cpp/include/PrintUtil.hpp                               | 2 +-
 codes/cpp/include/TreeNode.hpp                                | 2 +-
 codes/cpp/include/include.hpp                                 | 2 +-
 codes/java/chapter_array_and_linkedlist/array.java            | 2 +-
 codes/java/chapter_array_and_linkedlist/linked_list.java      | 2 +-
 codes/java/chapter_array_and_linkedlist/list.java             | 2 +-
 codes/java/chapter_array_and_linkedlist/my_list.java          | 2 +-
 .../chapter_computational_complexity/leetcode_two_sum.java    | 2 +-
 .../chapter_computational_complexity/space_complexity.java    | 2 +-
 .../chapter_computational_complexity/time_complexity.java     | 2 +-
 .../worst_best_time_complexity.java                           | 2 +-
 codes/java/chapter_hashing/array_hash_map.java                | 2 +-
 codes/java/chapter_hashing/hash_map.java                      | 2 +-
 codes/java/chapter_searching/binary_search.java               | 2 +-
 codes/java/chapter_searching/hashing_search.java              | 2 +-
 codes/java/chapter_searching/linear_search.java               | 2 +-
 codes/java/chapter_sorting/bubble_sort.java                   | 2 +-
 codes/java/chapter_sorting/insertion_sort.java                | 2 +-
 codes/java/chapter_sorting/merge_sort.java                    | 2 +-
 codes/java/chapter_sorting/quick_sort.java                    | 2 +-
 codes/java/chapter_stack_and_queue/array_queue.java           | 2 +-
 codes/java/chapter_stack_and_queue/array_stack.java           | 2 +-
 codes/java/chapter_stack_and_queue/deque.java                 | 2 +-
 codes/java/chapter_stack_and_queue/linkedlist_queue.java      | 2 +-
 codes/java/chapter_stack_and_queue/linkedlist_stack.java      | 2 +-
 codes/java/chapter_stack_and_queue/queue.java                 | 2 +-
 codes/java/chapter_stack_and_queue/stack.java                 | 2 +-
 codes/java/chapter_tree/avl_tree.java                         | 2 +-
 codes/java/chapter_tree/binary_search_tree.java               | 2 +-
 codes/java/chapter_tree/binary_tree.java                      | 2 +-
 codes/java/chapter_tree/binary_tree_bfs.java                  | 2 +-
 codes/java/chapter_tree/binary_tree_dfs.java                  | 2 +-
 codes/java/include/ListNode.java                              | 2 +-
 codes/java/include/PrintUtil.java                             | 2 +-
 codes/java/include/TreeNode.java                              | 2 +-
 codes/javascript/chapter_array_and_linkedlist/list.js         | 2 +-
 codes/javascript/chapter_array_and_linkedlist/my_list.js      | 2 +-
 codes/javascript/chapter_hashing/array_hash_map.js            | 2 +-
 codes/javascript/chapter_hashing/hash_map.js                  | 2 +-
 .../chapter_computational_complexity/leetcode_two_sum.swift   | 2 +-
 .../chapter_computational_complexity/space_complexity.swift   | 2 +-
 .../chapter_computational_complexity/time_complexity.swift    | 2 +-
 .../worst_best_time_complexity.swift                          | 2 +-
 codes/swift/utils/ListNode.swift                              | 2 +-
 codes/swift/utils/PrintUtil.swift                             | 2 +-
 codes/swift/utils/TreeNode.swift                              | 2 +-
 codes/typescript/chapter_array_and_linkedlist/array.ts        | 2 +-
 codes/typescript/chapter_array_and_linkedlist/linked_list.ts  | 2 +-
 codes/typescript/chapter_array_and_linkedlist/list.ts         | 2 +-
 codes/typescript/chapter_array_and_linkedlist/my_list.ts      | 2 +-
 .../chapter_computational_complexity/leetcode_two_sum.ts      | 2 +-
 codes/typescript/chapter_hashing/array_hash_map.ts            | 2 +-
 codes/typescript/chapter_hashing/hash_map.ts                  | 2 +-
 codes/typescript/module/ListNode.ts                           | 2 +-
 codes/typescript/module/PrintUtil.ts                          | 2 +-
 codes/typescript/module/TreeNode.ts                           | 2 +-
 92 files changed, 92 insertions(+), 98 deletions(-)

diff --git a/codes/c/chapter_array_and_linkedlist/array.c b/codes/c/chapter_array_and_linkedlist/array.c
index 300124a70..33dc99903 100644
--- a/codes/c/chapter_array_and_linkedlist/array.c
+++ b/codes/c/chapter_array_and_linkedlist/array.c
@@ -1,4 +1,4 @@
-/*
+/**
  * File: array.c
  * Created Time: 2022-12-20
  * Author: MolDuM (moldum@163.com)
diff --git a/codes/c/chapter_computational_complexity/time_complexity.c b/codes/c/chapter_computational_complexity/time_complexity.c
index 8df06a756..b8821ec6a 100644
--- a/codes/c/chapter_computational_complexity/time_complexity.c
+++ b/codes/c/chapter_computational_complexity/time_complexity.c
@@ -1,4 +1,4 @@
-/*
+/**
  * File: time_complexity.c
  * Created Time: 2023-01-03
  * Author: sjinzh (sjinzh@gmail.com)
@@ -172,4 +172,3 @@ int main(int argc, char *argv[]) {
     getchar();
     return 0;
 }
-
diff --git a/codes/c/chapter_computational_complexity/worst_best_time_complexity.c b/codes/c/chapter_computational_complexity/worst_best_time_complexity.c
index 88ed4dd2d..9173f32d4 100644
--- a/codes/c/chapter_computational_complexity/worst_best_time_complexity.c
+++ b/codes/c/chapter_computational_complexity/worst_best_time_complexity.c
@@ -1,4 +1,4 @@
-/*
+/**
  * File: worst_best_time_complexity.c
  * Created Time: 2023-01-03
  * Author: sjinzh (sjinzh@gmail.com)
@@ -52,4 +52,3 @@ int main(int argc, char *argv[]) {
     getchar();
     return 0;
 }
-
diff --git a/codes/c/chapter_sorting/insertion_sort.c b/codes/c/chapter_sorting/insertion_sort.c
index 318a40278..80e8b127b 100644
--- a/codes/c/chapter_sorting/insertion_sort.c
+++ b/codes/c/chapter_sorting/insertion_sort.c
@@ -1,4 +1,4 @@
-/*
+/**
  * File: insertion_sort.c
  * Created Time: 2022-12-29
  * Author: Listening (https://github.com/L-Super)
diff --git a/codes/c/include/PrintUtil.h b/codes/c/include/PrintUtil.h
index e471f0388..59a8eac1b 100644
--- a/codes/c/include/PrintUtil.h
+++ b/codes/c/include/PrintUtil.h
@@ -1,4 +1,4 @@
-/*
+/**
  * File: PrintUtil.h
  * Created Time: 2022-12-21
  * Author: MolDum (moldum@163.com)
@@ -26,5 +26,3 @@ static void printArray(int* arr, int n)
     }
     printf("%d]\n", arr[n-1]);
 }
-
-
diff --git a/codes/c/include/include.h b/codes/c/include/include.h
index c567aa2ec..2c4fd9252 100644
--- a/codes/c/include/include.h
+++ b/codes/c/include/include.h
@@ -1,4 +1,4 @@
-/*
+/**
  * File: include.h
  * Created Time: 2022-12-20
  * Author: MolDuM (moldum@163.com)
@@ -11,5 +11,3 @@
 #include <time.h>
 
 #include "PrintUtil.h"
-
-
diff --git a/codes/cpp/chapter_array_and_linkedlist/array.cpp b/codes/cpp/chapter_array_and_linkedlist/array.cpp
index 22c5e50dd..6cf4919be 100644
--- a/codes/cpp/chapter_array_and_linkedlist/array.cpp
+++ b/codes/cpp/chapter_array_and_linkedlist/array.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: array.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp b/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp
index 4cf049204..13fa68691 100644
--- a/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp
+++ b/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: linked_list.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_array_and_linkedlist/list.cpp b/codes/cpp/chapter_array_and_linkedlist/list.cpp
index 287cae1bb..44bbf88c8 100644
--- a/codes/cpp/chapter_array_and_linkedlist/list.cpp
+++ b/codes/cpp/chapter_array_and_linkedlist/list.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: list.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_array_and_linkedlist/my_list.cpp b/codes/cpp/chapter_array_and_linkedlist/my_list.cpp
index f64bd27c8..0b550475e 100644
--- a/codes/cpp/chapter_array_and_linkedlist/my_list.cpp
+++ b/codes/cpp/chapter_array_and_linkedlist/my_list.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: my_list.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_computational_complexity/leetcode_two_sum.cpp b/codes/cpp/chapter_computational_complexity/leetcode_two_sum.cpp
index 9df3b0a43..dd561d544 100644
--- a/codes/cpp/chapter_computational_complexity/leetcode_two_sum.cpp
+++ b/codes/cpp/chapter_computational_complexity/leetcode_two_sum.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: leetcode_two_sum.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_computational_complexity/space_complexity.cpp b/codes/cpp/chapter_computational_complexity/space_complexity.cpp
index 136e85bf6..6352b9d47 100644
--- a/codes/cpp/chapter_computational_complexity/space_complexity.cpp
+++ b/codes/cpp/chapter_computational_complexity/space_complexity.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: space_complexity.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_computational_complexity/time_complexity.cpp b/codes/cpp/chapter_computational_complexity/time_complexity.cpp
index 68408bcc8..cb1a20779 100644
--- a/codes/cpp/chapter_computational_complexity/time_complexity.cpp
+++ b/codes/cpp/chapter_computational_complexity/time_complexity.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: time_complexity.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_computational_complexity/worst_best_time_complexity.cpp b/codes/cpp/chapter_computational_complexity/worst_best_time_complexity.cpp
index 9b215cf81..c2916cb40 100644
--- a/codes/cpp/chapter_computational_complexity/worst_best_time_complexity.cpp
+++ b/codes/cpp/chapter_computational_complexity/worst_best_time_complexity.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: worst_best_time_complexity.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_hashing/array_hash_map.cpp b/codes/cpp/chapter_hashing/array_hash_map.cpp
index 394e36810..8b92174e2 100644
--- a/codes/cpp/chapter_hashing/array_hash_map.cpp
+++ b/codes/cpp/chapter_hashing/array_hash_map.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: array_hash_map.cpp
  * Created Time: 2022-12-14
  * Author: msk397 (machangxinq@gmail.com)
diff --git a/codes/cpp/chapter_hashing/hash_map.cpp b/codes/cpp/chapter_hashing/hash_map.cpp
index 898f679a0..829265d69 100644
--- a/codes/cpp/chapter_hashing/hash_map.cpp
+++ b/codes/cpp/chapter_hashing/hash_map.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: hash_map.cpp
  * Created Time: 2022-12-14
  * Author: msk397 (machangxinq@gmail.com)
diff --git a/codes/cpp/chapter_searching/binary_search.cpp b/codes/cpp/chapter_searching/binary_search.cpp
index 9729128a6..8d727ab40 100644
--- a/codes/cpp/chapter_searching/binary_search.cpp
+++ b/codes/cpp/chapter_searching/binary_search.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: binary_search.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_searching/hashing_search.cpp b/codes/cpp/chapter_searching/hashing_search.cpp
index 674376ff0..ebc2fb01c 100644
--- a/codes/cpp/chapter_searching/hashing_search.cpp
+++ b/codes/cpp/chapter_searching/hashing_search.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: hashing_search.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_searching/linear_search.cpp b/codes/cpp/chapter_searching/linear_search.cpp
index e1f2a567b..7b5092762 100644
--- a/codes/cpp/chapter_searching/linear_search.cpp
+++ b/codes/cpp/chapter_searching/linear_search.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: linear_search.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_sorting/bubble_sort.cpp b/codes/cpp/chapter_sorting/bubble_sort.cpp
index 87ca305d1..27427cae3 100644
--- a/codes/cpp/chapter_sorting/bubble_sort.cpp
+++ b/codes/cpp/chapter_sorting/bubble_sort.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: bubble_sort.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_sorting/insertion_sort.cpp b/codes/cpp/chapter_sorting/insertion_sort.cpp
index 9ae5988ce..a40e4a5f7 100644
--- a/codes/cpp/chapter_sorting/insertion_sort.cpp
+++ b/codes/cpp/chapter_sorting/insertion_sort.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: insertion_sort.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_sorting/merge_sort.cpp b/codes/cpp/chapter_sorting/merge_sort.cpp
index b406529a3..89b5b09cd 100644
--- a/codes/cpp/chapter_sorting/merge_sort.cpp
+++ b/codes/cpp/chapter_sorting/merge_sort.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: merge_sort.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_sorting/quick_sort.cpp b/codes/cpp/chapter_sorting/quick_sort.cpp
index 4e4430e77..c298f5be8 100644
--- a/codes/cpp/chapter_sorting/quick_sort.cpp
+++ b/codes/cpp/chapter_sorting/quick_sort.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: quick_sort.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_stack_and_queue/array_queue.cpp b/codes/cpp/chapter_stack_and_queue/array_queue.cpp
index 8e87da501..de5e780f6 100644
--- a/codes/cpp/chapter_stack_and_queue/array_queue.cpp
+++ b/codes/cpp/chapter_stack_and_queue/array_queue.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: array_queue.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_stack_and_queue/array_stack.cpp b/codes/cpp/chapter_stack_and_queue/array_stack.cpp
index e9ecae2a8..e6159e8cf 100644
--- a/codes/cpp/chapter_stack_and_queue/array_stack.cpp
+++ b/codes/cpp/chapter_stack_and_queue/array_stack.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: array_stack.cpp
  * Created Time: 2022-11-28
  * Author: qualifier1024 (2539244001@qq.com)
diff --git a/codes/cpp/chapter_stack_and_queue/deque.cpp b/codes/cpp/chapter_stack_and_queue/deque.cpp
index 96cf58111..e60af11e1 100644
--- a/codes/cpp/chapter_stack_and_queue/deque.cpp
+++ b/codes/cpp/chapter_stack_and_queue/deque.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: deque.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp b/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp
index 10cba0aaf..ae22740d6 100644
--- a/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp
+++ b/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: linkedlist_queue.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp
index cf6f6ab3d..495f2660f 100644
--- a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp
+++ b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: linkedlist_stack.cpp
  * Created Time: 2022-11-28
  * Author: qualifier1024 (2539244001@qq.com)
diff --git a/codes/cpp/chapter_stack_and_queue/queue.cpp b/codes/cpp/chapter_stack_and_queue/queue.cpp
index 2ca504a20..6bc37302c 100644
--- a/codes/cpp/chapter_stack_and_queue/queue.cpp
+++ b/codes/cpp/chapter_stack_and_queue/queue.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: queue.cpp
  * Created Time: 2022-11-28
  * Author: qualifier1024 (2539244001@qq.com)
diff --git a/codes/cpp/chapter_stack_and_queue/stack.cpp b/codes/cpp/chapter_stack_and_queue/stack.cpp
index cc0276970..7bbfd6b9f 100644
--- a/codes/cpp/chapter_stack_and_queue/stack.cpp
+++ b/codes/cpp/chapter_stack_and_queue/stack.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: stack.cpp
  * Created Time: 2022-11-28
  * Author: qualifier1024 (2539244001@qq.com)
diff --git a/codes/cpp/chapter_tree/avl_tree.cpp b/codes/cpp/chapter_tree/avl_tree.cpp
index b816f9752..8bc0741dc 100644
--- a/codes/cpp/chapter_tree/avl_tree.cpp
+++ b/codes/cpp/chapter_tree/avl_tree.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: avl_tree.cpp
  * Created Time: 2022-12-2
  * Author: mgisr (maguagua0706@gmail.com)
diff --git a/codes/cpp/chapter_tree/binary_search_tree.cpp b/codes/cpp/chapter_tree/binary_search_tree.cpp
index c7f8734da..78e797746 100644
--- a/codes/cpp/chapter_tree/binary_search_tree.cpp
+++ b/codes/cpp/chapter_tree/binary_search_tree.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: binary_search_tree.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_tree/binary_tree.cpp b/codes/cpp/chapter_tree/binary_tree.cpp
index fb00431eb..cd06778ad 100644
--- a/codes/cpp/chapter_tree/binary_tree.cpp
+++ b/codes/cpp/chapter_tree/binary_tree.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: binary_tree.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_tree/binary_tree_bfs.cpp b/codes/cpp/chapter_tree/binary_tree_bfs.cpp
index 30c2d6007..236f62449 100644
--- a/codes/cpp/chapter_tree/binary_tree_bfs.cpp
+++ b/codes/cpp/chapter_tree/binary_tree_bfs.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: binary_tree_bfs.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/chapter_tree/binary_tree_dfs.cpp b/codes/cpp/chapter_tree/binary_tree_dfs.cpp
index 08a0a331e..51287b736 100644
--- a/codes/cpp/chapter_tree/binary_tree_dfs.cpp
+++ b/codes/cpp/chapter_tree/binary_tree_dfs.cpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: binary_tree_dfs.cpp
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/include/ListNode.hpp b/codes/cpp/include/ListNode.hpp
index bd91f2558..9e6bd0692 100644
--- a/codes/cpp/include/ListNode.hpp
+++ b/codes/cpp/include/ListNode.hpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: PrintUtil.hpp
  * Created Time: 2021-12-19
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/include/PrintUtil.hpp b/codes/cpp/include/PrintUtil.hpp
index 544ee85db..06397855b 100644
--- a/codes/cpp/include/PrintUtil.hpp
+++ b/codes/cpp/include/PrintUtil.hpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: PrintUtil.hpp
  * Created Time: 2021-12-19
  * Author: Krahets (krahets@163.com), msk397 (machangxinq@gmail.com)
diff --git a/codes/cpp/include/TreeNode.hpp b/codes/cpp/include/TreeNode.hpp
index b3b27a65b..ab54c7746 100644
--- a/codes/cpp/include/TreeNode.hpp
+++ b/codes/cpp/include/TreeNode.hpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: PrintUtil.hpp
  * Created Time: 2021-12-19
  * Author: Krahets (krahets@163.com)
diff --git a/codes/cpp/include/include.hpp b/codes/cpp/include/include.hpp
index 28eab2cdf..8e4a8070d 100644
--- a/codes/cpp/include/include.hpp
+++ b/codes/cpp/include/include.hpp
@@ -1,4 +1,4 @@
-/*
+/**
  * File: PrintUtil.hpp
  * Created Time: 2021-12-19
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_array_and_linkedlist/array.java b/codes/java/chapter_array_and_linkedlist/array.java
index 6afd3dfdb..d3cb176c6 100644
--- a/codes/java/chapter_array_and_linkedlist/array.java
+++ b/codes/java/chapter_array_and_linkedlist/array.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: array.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_array_and_linkedlist/linked_list.java b/codes/java/chapter_array_and_linkedlist/linked_list.java
index 3d4451178..570778ff5 100644
--- a/codes/java/chapter_array_and_linkedlist/linked_list.java
+++ b/codes/java/chapter_array_and_linkedlist/linked_list.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: linked_list.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_array_and_linkedlist/list.java b/codes/java/chapter_array_and_linkedlist/list.java
index 1f13bc2ef..dc4d897f7 100644
--- a/codes/java/chapter_array_and_linkedlist/list.java
+++ b/codes/java/chapter_array_and_linkedlist/list.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: list.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_array_and_linkedlist/my_list.java b/codes/java/chapter_array_and_linkedlist/my_list.java
index 1f9fdc3eb..cce8da683 100644
--- a/codes/java/chapter_array_and_linkedlist/my_list.java
+++ b/codes/java/chapter_array_and_linkedlist/my_list.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: my_list.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_computational_complexity/leetcode_two_sum.java b/codes/java/chapter_computational_complexity/leetcode_two_sum.java
index 45106867a..b9f8bf4d7 100644
--- a/codes/java/chapter_computational_complexity/leetcode_two_sum.java
+++ b/codes/java/chapter_computational_complexity/leetcode_two_sum.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: leetcode_two_sum.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_computational_complexity/space_complexity.java b/codes/java/chapter_computational_complexity/space_complexity.java
index a81026d8d..275a37ec0 100644
--- a/codes/java/chapter_computational_complexity/space_complexity.java
+++ b/codes/java/chapter_computational_complexity/space_complexity.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: space_complexity.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_computational_complexity/time_complexity.java b/codes/java/chapter_computational_complexity/time_complexity.java
index d303c5107..5a232e5b8 100644
--- a/codes/java/chapter_computational_complexity/time_complexity.java
+++ b/codes/java/chapter_computational_complexity/time_complexity.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: time_complexity.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_computational_complexity/worst_best_time_complexity.java b/codes/java/chapter_computational_complexity/worst_best_time_complexity.java
index 536bf3af0..c0fe0baa7 100644
--- a/codes/java/chapter_computational_complexity/worst_best_time_complexity.java
+++ b/codes/java/chapter_computational_complexity/worst_best_time_complexity.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: worst_best_time_complexity.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_hashing/array_hash_map.java b/codes/java/chapter_hashing/array_hash_map.java
index fb0073abd..68df1f3b9 100644
--- a/codes/java/chapter_hashing/array_hash_map.java
+++ b/codes/java/chapter_hashing/array_hash_map.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: hash_map.java
  * Created Time: 2022-12-04
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_hashing/hash_map.java b/codes/java/chapter_hashing/hash_map.java
index bb72a4b0f..fe3f822f4 100644
--- a/codes/java/chapter_hashing/hash_map.java
+++ b/codes/java/chapter_hashing/hash_map.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: hash_map.java
  * Created Time: 2022-12-04
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_searching/binary_search.java b/codes/java/chapter_searching/binary_search.java
index cb5bd9419..05c2a4d32 100644
--- a/codes/java/chapter_searching/binary_search.java
+++ b/codes/java/chapter_searching/binary_search.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: binary_search.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_searching/hashing_search.java b/codes/java/chapter_searching/hashing_search.java
index c68025de0..cfd015313 100644
--- a/codes/java/chapter_searching/hashing_search.java
+++ b/codes/java/chapter_searching/hashing_search.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: hashing_search.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_searching/linear_search.java b/codes/java/chapter_searching/linear_search.java
index 2e8e410ec..c33b51178 100644
--- a/codes/java/chapter_searching/linear_search.java
+++ b/codes/java/chapter_searching/linear_search.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: linear_search.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_sorting/bubble_sort.java b/codes/java/chapter_sorting/bubble_sort.java
index f006a3ab8..082d2d909 100644
--- a/codes/java/chapter_sorting/bubble_sort.java
+++ b/codes/java/chapter_sorting/bubble_sort.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: bubble_sort.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_sorting/insertion_sort.java b/codes/java/chapter_sorting/insertion_sort.java
index 9a6a03102..fb5b2cd66 100644
--- a/codes/java/chapter_sorting/insertion_sort.java
+++ b/codes/java/chapter_sorting/insertion_sort.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: insertion_sort.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_sorting/merge_sort.java b/codes/java/chapter_sorting/merge_sort.java
index fe9f183a5..68f76c9b1 100644
--- a/codes/java/chapter_sorting/merge_sort.java
+++ b/codes/java/chapter_sorting/merge_sort.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: merge_sort.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_sorting/quick_sort.java b/codes/java/chapter_sorting/quick_sort.java
index d65aa8e4b..b121b757b 100644
--- a/codes/java/chapter_sorting/quick_sort.java
+++ b/codes/java/chapter_sorting/quick_sort.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: quick_sort.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_stack_and_queue/array_queue.java b/codes/java/chapter_stack_and_queue/array_queue.java
index 198c90714..5a1ab645d 100644
--- a/codes/java/chapter_stack_and_queue/array_queue.java
+++ b/codes/java/chapter_stack_and_queue/array_queue.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: array_queue.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_stack_and_queue/array_stack.java b/codes/java/chapter_stack_and_queue/array_stack.java
index 12ac52831..e32b16404 100644
--- a/codes/java/chapter_stack_and_queue/array_stack.java
+++ b/codes/java/chapter_stack_and_queue/array_stack.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: array_stack.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_stack_and_queue/deque.java b/codes/java/chapter_stack_and_queue/deque.java
index a29e6e7c3..1a8f196b1 100644
--- a/codes/java/chapter_stack_and_queue/deque.java
+++ b/codes/java/chapter_stack_and_queue/deque.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: deque.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_stack_and_queue/linkedlist_queue.java b/codes/java/chapter_stack_and_queue/linkedlist_queue.java
index 92cdfab0e..82e2571c2 100644
--- a/codes/java/chapter_stack_and_queue/linkedlist_queue.java
+++ b/codes/java/chapter_stack_and_queue/linkedlist_queue.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: linkedlist_queue.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_stack_and_queue/linkedlist_stack.java b/codes/java/chapter_stack_and_queue/linkedlist_stack.java
index 794c80c31..b1a78aa4a 100644
--- a/codes/java/chapter_stack_and_queue/linkedlist_stack.java
+++ b/codes/java/chapter_stack_and_queue/linkedlist_stack.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: linkedlist_stack.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_stack_and_queue/queue.java b/codes/java/chapter_stack_and_queue/queue.java
index 232943fb1..25457fbdb 100644
--- a/codes/java/chapter_stack_and_queue/queue.java
+++ b/codes/java/chapter_stack_and_queue/queue.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: queue.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_stack_and_queue/stack.java b/codes/java/chapter_stack_and_queue/stack.java
index 9c94eb62b..2a7259220 100644
--- a/codes/java/chapter_stack_and_queue/stack.java
+++ b/codes/java/chapter_stack_and_queue/stack.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: stack.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_tree/avl_tree.java b/codes/java/chapter_tree/avl_tree.java
index 2f731b7e4..9120262f4 100644
--- a/codes/java/chapter_tree/avl_tree.java
+++ b/codes/java/chapter_tree/avl_tree.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: avl_tree.java
  * Created Time: 2022-12-10
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_tree/binary_search_tree.java b/codes/java/chapter_tree/binary_search_tree.java
index 4a7c53dba..4a7f3194e 100644
--- a/codes/java/chapter_tree/binary_search_tree.java
+++ b/codes/java/chapter_tree/binary_search_tree.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: binary_search_tree.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_tree/binary_tree.java b/codes/java/chapter_tree/binary_tree.java
index 8f25a9a16..65a511e8c 100644
--- a/codes/java/chapter_tree/binary_tree.java
+++ b/codes/java/chapter_tree/binary_tree.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: binary_tree.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_tree/binary_tree_bfs.java b/codes/java/chapter_tree/binary_tree_bfs.java
index 524274a68..c000eacea 100644
--- a/codes/java/chapter_tree/binary_tree_bfs.java
+++ b/codes/java/chapter_tree/binary_tree_bfs.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: binary_tree_bfs.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/chapter_tree/binary_tree_dfs.java b/codes/java/chapter_tree/binary_tree_dfs.java
index fa866d965..1d3026dfb 100644
--- a/codes/java/chapter_tree/binary_tree_dfs.java
+++ b/codes/java/chapter_tree/binary_tree_dfs.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: binary_tree_dfs.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/include/ListNode.java b/codes/java/include/ListNode.java
index 14308feb4..60590100a 100755
--- a/codes/java/include/ListNode.java
+++ b/codes/java/include/ListNode.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: ListNode.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/include/PrintUtil.java b/codes/java/include/PrintUtil.java
index b8c970504..f21bc17c9 100755
--- a/codes/java/include/PrintUtil.java
+++ b/codes/java/include/PrintUtil.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: PrintUtil.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/java/include/TreeNode.java b/codes/java/include/TreeNode.java
index 98b9f826e..b98252665 100644
--- a/codes/java/include/TreeNode.java
+++ b/codes/java/include/TreeNode.java
@@ -1,4 +1,4 @@
-/*
+/**
  * File: TreeNode.java
  * Created Time: 2022-11-25
  * Author: Krahets (krahets@163.com)
diff --git a/codes/javascript/chapter_array_and_linkedlist/list.js b/codes/javascript/chapter_array_and_linkedlist/list.js
index 19318337f..593917589 100644
--- a/codes/javascript/chapter_array_and_linkedlist/list.js
+++ b/codes/javascript/chapter_array_and_linkedlist/list.js
@@ -1,4 +1,4 @@
-/*
+/**
  * File: list.js
  * Created Time: 2022-12-12
  * Author: Justin (xiefahit@gmail.com)
diff --git a/codes/javascript/chapter_array_and_linkedlist/my_list.js b/codes/javascript/chapter_array_and_linkedlist/my_list.js
index a861b1f0d..388bb1f3d 100644
--- a/codes/javascript/chapter_array_and_linkedlist/my_list.js
+++ b/codes/javascript/chapter_array_and_linkedlist/my_list.js
@@ -1,4 +1,4 @@
-/*
+/**
  * File: my_list.js
  * Created Time: 2022-12-12
  * Author: Justin (xiefahit@gmail.com)
diff --git a/codes/javascript/chapter_hashing/array_hash_map.js b/codes/javascript/chapter_hashing/array_hash_map.js
index f5c77aa2b..405d0f318 100644
--- a/codes/javascript/chapter_hashing/array_hash_map.js
+++ b/codes/javascript/chapter_hashing/array_hash_map.js
@@ -1,4 +1,4 @@
-/*
+/**
  * File: array_hash_map.js
  * Created Time: 2022-12-26
  * Author: Justin (xiefahit@gmail.com)
diff --git a/codes/javascript/chapter_hashing/hash_map.js b/codes/javascript/chapter_hashing/hash_map.js
index 197fb7dd9..9157b3159 100644
--- a/codes/javascript/chapter_hashing/hash_map.js
+++ b/codes/javascript/chapter_hashing/hash_map.js
@@ -1,4 +1,4 @@
-/*
+/**
  * File: hash_map.js
  * Created Time: 2022-12-26
  * Author: Justin (xiefahit@gmail.com)
diff --git a/codes/swift/chapter_computational_complexity/leetcode_two_sum.swift b/codes/swift/chapter_computational_complexity/leetcode_two_sum.swift
index 6ed0e580c..e82872d38 100644
--- a/codes/swift/chapter_computational_complexity/leetcode_two_sum.swift
+++ b/codes/swift/chapter_computational_complexity/leetcode_two_sum.swift
@@ -1,4 +1,4 @@
-/*
+/**
  * File: leetcode_two_sum.swift
  * Created Time: 2023-01-03
  * Author: nuomi1 (nuomi1@qq.com)
diff --git a/codes/swift/chapter_computational_complexity/space_complexity.swift b/codes/swift/chapter_computational_complexity/space_complexity.swift
index 4931597ca..92a1187a0 100644
--- a/codes/swift/chapter_computational_complexity/space_complexity.swift
+++ b/codes/swift/chapter_computational_complexity/space_complexity.swift
@@ -1,4 +1,4 @@
-/*
+/**
  * File: space_complexity.swift
  * Created Time: 2023-01-01
  * Author: nuomi1 (nuomi1@qq.com)
diff --git a/codes/swift/chapter_computational_complexity/time_complexity.swift b/codes/swift/chapter_computational_complexity/time_complexity.swift
index 322b4f09d..44addb800 100644
--- a/codes/swift/chapter_computational_complexity/time_complexity.swift
+++ b/codes/swift/chapter_computational_complexity/time_complexity.swift
@@ -1,4 +1,4 @@
-/*
+/**
  * File: time_complexity.swift
  * Created Time: 2022-12-26
  * Author: nuomi1 (nuomi1@qq.com)
diff --git a/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift b/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift
index 4fa2cf2a0..09d7de1f4 100644
--- a/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift
+++ b/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift
@@ -1,4 +1,4 @@
-/*
+/**
  * File: worst_best_time_complexity.swift
  * Created Time: 2022-12-26
  * Author: nuomi1 (nuomi1@qq.com)
diff --git a/codes/swift/utils/ListNode.swift b/codes/swift/utils/ListNode.swift
index 796ee5125..5fa3671eb 100644
--- a/codes/swift/utils/ListNode.swift
+++ b/codes/swift/utils/ListNode.swift
@@ -1,4 +1,4 @@
-/*
+/**
  * File: ListNode.swift
  * Created Time: 2023-01-02
  * Author: nuomi1 (nuomi1@qq.com)
diff --git a/codes/swift/utils/PrintUtil.swift b/codes/swift/utils/PrintUtil.swift
index 3f3fc2688..f2b54693d 100644
--- a/codes/swift/utils/PrintUtil.swift
+++ b/codes/swift/utils/PrintUtil.swift
@@ -1,4 +1,4 @@
-/*
+/**
  * File: PrintUtil.swift
  * Created Time: 2023-01-02
  * Author: nuomi1 (nuomi1@qq.com)
diff --git a/codes/swift/utils/TreeNode.swift b/codes/swift/utils/TreeNode.swift
index b6ce30575..161cebd57 100644
--- a/codes/swift/utils/TreeNode.swift
+++ b/codes/swift/utils/TreeNode.swift
@@ -1,4 +1,4 @@
-/*
+/**
  * File: TreeNode.swift
  * Created Time: 2023-01-02
  * Author: nuomi1 (nuomi1@qq.com)
diff --git a/codes/typescript/chapter_array_and_linkedlist/array.ts b/codes/typescript/chapter_array_and_linkedlist/array.ts
index 237a04385..a85816b97 100644
--- a/codes/typescript/chapter_array_and_linkedlist/array.ts
+++ b/codes/typescript/chapter_array_and_linkedlist/array.ts
@@ -1,4 +1,4 @@
-/*
+/**
  * File: array.ts
  * Created Time: 2022-12-04
  * Author: Justin (xiefahit@gmail.com)
diff --git a/codes/typescript/chapter_array_and_linkedlist/linked_list.ts b/codes/typescript/chapter_array_and_linkedlist/linked_list.ts
index 484322581..b5eb988ae 100644
--- a/codes/typescript/chapter_array_and_linkedlist/linked_list.ts
+++ b/codes/typescript/chapter_array_and_linkedlist/linked_list.ts
@@ -1,4 +1,4 @@
-/*
+/**
  * File: linked_list.ts
  * Created Time: 2022-12-10
  * Author: Justin (xiefahit@gmail.com)
diff --git a/codes/typescript/chapter_array_and_linkedlist/list.ts b/codes/typescript/chapter_array_and_linkedlist/list.ts
index 8fca2bfa1..e1d2d518a 100644
--- a/codes/typescript/chapter_array_and_linkedlist/list.ts
+++ b/codes/typescript/chapter_array_and_linkedlist/list.ts
@@ -1,4 +1,4 @@
-/*
+/**
  * File: list.ts
  * Created Time: 2022-12-10
  * Author: Justin (xiefahit@gmail.com)
diff --git a/codes/typescript/chapter_array_and_linkedlist/my_list.ts b/codes/typescript/chapter_array_and_linkedlist/my_list.ts
index b2ce46840..e60075daf 100644
--- a/codes/typescript/chapter_array_and_linkedlist/my_list.ts
+++ b/codes/typescript/chapter_array_and_linkedlist/my_list.ts
@@ -1,4 +1,4 @@
-/*
+/**
  * File: my_list.ts
  * Created Time: 2022-12-11
  * Author: Justin (xiefahit@gmail.com)
diff --git a/codes/typescript/chapter_computational_complexity/leetcode_two_sum.ts b/codes/typescript/chapter_computational_complexity/leetcode_two_sum.ts
index 8e3c4cd76..47c52d80d 100644
--- a/codes/typescript/chapter_computational_complexity/leetcode_two_sum.ts
+++ b/codes/typescript/chapter_computational_complexity/leetcode_two_sum.ts
@@ -1,4 +1,4 @@
-/*
+/**
  * File: leetcode_two_sum.ts
  * Created Time: 2022-12-15
  * Author: gyt95 (gytkwan@gmail.com) 
diff --git a/codes/typescript/chapter_hashing/array_hash_map.ts b/codes/typescript/chapter_hashing/array_hash_map.ts
index 627205f7f..027cdc8e1 100644
--- a/codes/typescript/chapter_hashing/array_hash_map.ts
+++ b/codes/typescript/chapter_hashing/array_hash_map.ts
@@ -1,4 +1,4 @@
-/*
+/**
  * File: array_hash_map.ts
  * Created Time: 2022-12-20
  * Author: Daniel (better.sunjian@gmail.com)
diff --git a/codes/typescript/chapter_hashing/hash_map.ts b/codes/typescript/chapter_hashing/hash_map.ts
index 7e54cf5cb..8d73da0c0 100644
--- a/codes/typescript/chapter_hashing/hash_map.ts
+++ b/codes/typescript/chapter_hashing/hash_map.ts
@@ -1,4 +1,4 @@
-/*
+/**
  * File: hash_map.ts
  * Created Time: 2022-12-20
  * Author: Daniel (better.sunjian@gmail.com)
diff --git a/codes/typescript/module/ListNode.ts b/codes/typescript/module/ListNode.ts
index d6d60616d..17fdbb955 100644
--- a/codes/typescript/module/ListNode.ts
+++ b/codes/typescript/module/ListNode.ts
@@ -1,4 +1,4 @@
-/*
+/**
  * File: ListNode.ts
  * Created Time: 2022-12-10
  * Author: Justin (xiefahit@gmail.com)
diff --git a/codes/typescript/module/PrintUtil.ts b/codes/typescript/module/PrintUtil.ts
index 9174be159..59f1af0e5 100644
--- a/codes/typescript/module/PrintUtil.ts
+++ b/codes/typescript/module/PrintUtil.ts
@@ -1,4 +1,4 @@
-/*
+/**
  * File: PrintUtil.ts
  * Created Time: 2022-12-13
  * Author: Justin (xiefahit@gmail.com)
diff --git a/codes/typescript/module/TreeNode.ts b/codes/typescript/module/TreeNode.ts
index 0bc783aa9..5a886763e 100644
--- a/codes/typescript/module/TreeNode.ts
+++ b/codes/typescript/module/TreeNode.ts
@@ -1,4 +1,4 @@
-/*
+/**
  * File: TreeNode.ts
  * Created Time: 2022-12-13
  * Author: Justin (xiefahit@gmail.com)

From 52927cadad684a0d9e1d9583892566cf1ed185be Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Fri, 6 Jan 2023 08:28:59 +0800
Subject: [PATCH 109/158] fix: change shuffle algo in the doc

---
 docs/chapter_computational_complexity/time_complexity.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index db2c5614d..fa07bd542 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -2337,7 +2337,7 @@ $$
         }
         // 随机打乱数组元素
         for (let i = 0; i < n; i++) {
-            let r = Math.floor(Math.random() * n);
+            let r = Math.floor(Math.random() * (i + 1));
             let temp = nums[i];
             nums[i] = nums[r];
             nums[r] = temp;
@@ -2381,7 +2381,7 @@ $$
         }
         // 随机打乱数组元素
         for (let i = 0; i < n; i++) {
-            let r = Math.floor(Math.random() * n);
+            let r = Math.floor(Math.random() * (i + 1));
             let temp = nums[i];
             nums[i] = nums[r];
             nums[r] = temp;

From 5a24254f6b95d19bae6a366e0695df6ee91d026a Mon Sep 17 00:00:00 2001
From: RiverTwilight <wrj2014@126.com>
Date: Fri, 6 Jan 2023 08:32:10 +0800
Subject: [PATCH 110/158] lint

---
 docs/chapter_computational_complexity/time_complexity.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index fa07bd542..b6b68c443 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -2348,7 +2348,7 @@ $$
     /* 查找数组 nums 中数字 1 所在索引 */
     function findOne(nums) {
         for (let i = 0; i < nums.length; i++) {
-            if (nums[i] == 1) {
+            if (nums[i] === 1) {
                 return i;
             }
         }
@@ -2392,7 +2392,7 @@ $$
     /* 查找数组 nums 中数字 1 所在索引 */
     function findOne(nums: number[]): number {
         for (let i = 0; i < nums.length; i++) {
-            if (nums[i] == 1) {
+            if (nums[i] === 1) {
                 return i;
             }
         }

From 98d1244e32df673959deb2ddd1484b72ed61d1c8 Mon Sep 17 00:00:00 2001
From: dumingyu <dumingyu@coding.net>
Date: Fri, 6 Jan 2023 11:00:12 +0800
Subject: [PATCH 111/158] fix(codes/cpp): add climits headers

This fixes clang++ compile error when using INT_MAX in PrintUtil.
---
 codes/cpp/include/PrintUtil.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/codes/cpp/include/PrintUtil.hpp b/codes/cpp/include/PrintUtil.hpp
index 06397855b..e788d1650 100644
--- a/codes/cpp/include/PrintUtil.hpp
+++ b/codes/cpp/include/PrintUtil.hpp
@@ -9,6 +9,7 @@
 #include <iostream>
 #include <string>
 #include <sstream>
+#include <climits>
 #include "ListNode.hpp"
 #include "TreeNode.hpp"
 

From c8dac9b5c136874bdc310d224417cbd4f532861a Mon Sep 17 00:00:00 2001
From: Yuelin Xin <sc20yx2@leeds.ac.uk>
Date: Fri, 6 Jan 2023 20:08:25 +0000
Subject: [PATCH 112/158] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E9=94=99=E5=88=AB?=
 =?UTF-8?q?=E5=AD=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/chapter_sorting/intro_to_sort.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/chapter_sorting/intro_to_sort.md b/docs/chapter_sorting/intro_to_sort.md
index df84ce13e..a3cb071dc 100644
--- a/docs/chapter_sorting/intro_to_sort.md
+++ b/docs/chapter_sorting/intro_to_sort.md
@@ -22,7 +22,7 @@ comments: true
 - 「稳定排序」在完成排序后，**不改变** 相等元素在数组中的相对顺序。
 - 「非稳定排序」在完成排序后，相等元素在数组中的相对位置 **可能被改变**。
 
-假设我们有一个存储学生信息当表格，第 1, 2 列分别是姓名和年龄。那么在以下示例中，「非稳定排序」会导致输入数据的有序性丢失。因此「稳定排序」是很好的特性，**在多级排序中是必须的**。
+假设我们有一个存储学生信息的表格，第 1, 2 列分别是姓名和年龄。那么在以下示例中，「非稳定排序」会导致输入数据的有序性丢失。因此「稳定排序」是很好的特性，**在多级排序中是必须的**。
 
 ```shell
 # 输入数据是按照姓名排序好的

From e1d561bc088b9f4623f06f3ba49420cc815ef56b Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Sat, 7 Jan 2023 16:38:13 +1100
Subject: [PATCH 113/158] added: linear search for Typescript

---
 .../chapter_searching/linear_search.ts        | 47 +++++++++++++++++++
 codes/typescript/module/ListNode.ts           | 15 ++++++
 2 files changed, 62 insertions(+)
 create mode 100644 codes/typescript/chapter_searching/linear_search.ts

diff --git a/codes/typescript/chapter_searching/linear_search.ts b/codes/typescript/chapter_searching/linear_search.ts
new file mode 100644
index 000000000..05620f913
--- /dev/null
+++ b/codes/typescript/chapter_searching/linear_search.ts
@@ -0,0 +1,47 @@
+/**
+ * File: linear_search.ts
+ * Created Time: 2023-01-07
+ * Author: Daniel (better.sunjian@gmail.com)
+ */
+
+import ListNode from '../module/ListNode.ts';
+
+/* 线性查找（数组） */
+function linearSearchArray(nums: number[], target: number): number {
+    // 遍历数组
+    for (let i = 0; i < nums.length; i++) {
+        // 找到目标元素，返回其索引
+        if (nums[i] === target) {
+            return i;
+        }
+    }
+    // 未找到目标元素，返回 -1
+    return -1;
+}
+
+/* 线性查找（链表）*/
+function linearSearchLinkedList(head: ListNode | null, target: number): ListNode | null {
+    // 遍历链表
+    while (head) {
+        // 找到目标结点，返回之
+        if (head.val === target) {
+            return head;
+        }
+        head = head.next;
+    }
+    // 未找到目标结点，返回 null
+    return null;
+}
+
+/* Driver Code */
+const target = 3;
+
+/* 在数组中执行线性查找 */
+const nums = [ 1, 5, 3, 2, 4, 7, 5, 9, 10, 8 ];
+const index = linearSearchArray(nums, target);
+console.log('目标元素 3 的索引 =', index);
+
+/* 在链表中执行线性查找 */
+const head = ListNode.arrToLinkedList(nums);
+const node = linearSearchLinkedList(head, target);
+console.log('目标结点值 3 的对应结点对象为', node);
diff --git a/codes/typescript/module/ListNode.ts b/codes/typescript/module/ListNode.ts
index 17fdbb955..84f1822f8 100644
--- a/codes/typescript/module/ListNode.ts
+++ b/codes/typescript/module/ListNode.ts
@@ -14,4 +14,19 @@ export default class ListNode {
         this.val = val === undefined ? 0 : val;
         this.next = next === undefined ? null : next;
     }
+
+    /**
+     * Generate a linked-list with an array
+     * @param arr
+     * @return ListNode
+     */
+    public static arrToLinkedList(arr: number[]): ListNode | null {
+        const dum = new ListNode(0);
+        let head = dum;
+        for (const val of arr) {
+            head.next = new ListNode(val);
+            head = head.next;
+        }
+        return dum.next;
+    }
 }

From 2b0d7d1c1b1a9d1eda3efd6300782d4179ab27a7 Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Sat, 7 Jan 2023 16:41:46 +1100
Subject: [PATCH 114/158] Added linear search docs for Typescript

---
 .../chapter_searching/linear_search.ts        |  2 +-
 docs/chapter_searching/linear_search.md       | 27 +++++++++++++++++--
 2 files changed, 26 insertions(+), 3 deletions(-)

diff --git a/codes/typescript/chapter_searching/linear_search.ts b/codes/typescript/chapter_searching/linear_search.ts
index 05620f913..f0de33f78 100644
--- a/codes/typescript/chapter_searching/linear_search.ts
+++ b/codes/typescript/chapter_searching/linear_search.ts
@@ -6,7 +6,7 @@
 
 import ListNode from '../module/ListNode.ts';
 
-/* 线性查找（数组） */
+/* 线性查找（数组）*/
 function linearSearchArray(nums: number[], target: number): number {
     // 遍历数组
     for (let i = 0; i < nums.length; i++) {
diff --git a/docs/chapter_searching/linear_search.md b/docs/chapter_searching/linear_search.md
index 3d592962e..777d2d53b 100644
--- a/docs/chapter_searching/linear_search.md
+++ b/docs/chapter_searching/linear_search.md
@@ -94,7 +94,18 @@ comments: true
 === "TypeScript"
 
     ```typescript title="linear_search.ts"
-
+    /* 线性查找（数组）*/
+    function linearSearchArray(nums: number[], target: number): number {
+        // 遍历数组
+        for (let i = 0; i < nums.length; i++) {
+            // 找到目标元素，返回其索引
+            if (nums[i] === target) {
+                return i;
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 === "C"
@@ -210,7 +221,19 @@ comments: true
 === "TypeScript"
 
     ```typescript title="linear_search.ts"
-
+    /* 线性查找（链表）*/
+    function linearSearchLinkedList(head: ListNode | null, target: number): ListNode | null {
+        // 遍历链表
+        while (head) {
+            // 找到目标结点，返回之
+            if (head.val === target) {
+                return head;
+            }
+            head = head.next;
+        }
+        // 未找到目标结点，返回 null
+        return null;
+    }
     ```
 
 === "C"

From 1c3b4aea8bff7a0fcfe06e2ec56d8ce361b6a3a5 Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Sat, 7 Jan 2023 16:46:18 +1100
Subject: [PATCH 115/158] Added .editorconfig for default code format

---
 .editorconfig | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 .editorconfig

diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 000000000..3ccd9ac0c
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,14 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+[codes/**.{java,js,ts,go,py,cpp,c,cs,swift,zig}]
+charset = utf-8
+indent_style = space
+indent_size = 2

From f29f6c460ee5bbd4dc91373730d6f02741eb15a1 Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Sat, 7 Jan 2023 16:47:45 +1100
Subject: [PATCH 116/158] Added .editorconfig for default code format

---
 .editorconfig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.editorconfig b/.editorconfig
index 3ccd9ac0c..f57b4f2fb 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -11,4 +11,4 @@ insert_final_newline = true
 [codes/**.{java,js,ts,go,py,cpp,c,cs,swift,zig}]
 charset = utf-8
 indent_style = space
-indent_size = 2
+indent_size = 4

From 0b778f27a112824e21f1b8b8e3b16142868a4008 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Sat, 7 Jan 2023 17:12:25 +0800
Subject: [PATCH 117/158] Update time complexity.

---
 .../performance_evaluation.md                                 | 2 +-
 docs/chapter_computational_complexity/time_complexity.md      | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/chapter_computational_complexity/performance_evaluation.md b/docs/chapter_computational_complexity/performance_evaluation.md
index c664a2083..3244f41d8 100644
--- a/docs/chapter_computational_complexity/performance_evaluation.md
+++ b/docs/chapter_computational_complexity/performance_evaluation.md
@@ -16,7 +16,7 @@ comments: true
 - **时间效率** ，即算法的运行速度的快慢。
 - **空间效率** ，即算法占用的内存空间大小。
 
-数据结构与算法追求“运行得快、内存占用少”，而如何去评价算法效率则是非常重要的问题，因为只有知道如何评价算法，才能去做算法之间的对比分析，以及优化算法设计。
+数据结构与算法追求“运行速度快、占用内存少”，而如何去评价算法效率则是非常重要的问题，因为只有知道如何评价算法，才能去做算法之间的对比分析，以及优化算法设计。
 
 ## 效率评估方法
 
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 42d43624b..03e59e256 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -365,9 +365,9 @@ $$
 
 **时间复杂度可以有效评估算法效率。** 算法 `B` 运行时间的增长是线性的，在 $n > 1$ 时慢于算法 `A` ，在 $n > 1000000$ 时慢于算法 `C` 。实质上，只要输入数据大小 $n$ 足够大，复杂度为「常数阶」的算法一定优于「线性阶」的算法，这也正是时间增长趋势的含义。
 
-**时间复杂度分析将统计「计算操作的运行时间」简化为统计「计算操作的数量」。** 这是因为，无论是运行平台、还是计算操作类型，都与算法运行时间的增长趋势无关。因此，我们可以简单地将所有计算操作的执行时间统一看作是相同的“单位时间”。
+**时间复杂度的推算方法更加简便。** 在时间复杂度分析中，我们可以将统计「计算操作的运行时间」简化为统计「计算操作的数量」，这是因为，无论是运行平台还是计算操作类型，都与算法运行时间的增长趋势无关。因而，我们可以简单地将所有计算操作的执行时间统一看作是相同的“单位时间”，这样的简化做法大大降低了估算难度。
 
-**时间复杂度也存在一定的局限性。** 比如，虽然算法 `A` 和 `C` 的时间复杂度相同，但是实际的运行时间有非常大的差别。再比如，虽然算法 `B` 比 `C` 的时间复杂度要更高，但在输入数据大小 $n$ 比较小时，算法 `B` 是要明显优于算法 `C` 的。即使存在这些问题，计算复杂度仍然是评判算法效率的最有效、最常用方法。
+**时间复杂度也存在一定的局限性。** 比如，虽然算法 `A` 和 `C` 的时间复杂度相同，但是实际的运行时间有非常大的差别。再比如，虽然算法 `B` 比 `C` 的时间复杂度要更高，但在输入数据大小 $n$ 比较小时，算法 `B` 是要明显优于算法 `C` 的。对于以上情况，我们很难仅凭时间复杂度来判定算法效率高低。然而，即使存在这些问题，计算复杂度仍然是评判算法效率的最有效且常用的方法。
 
 ## 函数渐近上界
 

From 694ea4f665733ca81fa0a21f72c5bae2f5aae8c5 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Sat, 7 Jan 2023 20:34:32 +0800
Subject: [PATCH 118/158] =?UTF-8?q?Modify=20`=E3=80=82**=20`=20to=20`**?=
 =?UTF-8?q?=E3=80=82`=20for=20better=20visualization.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/chapter_array_and_linkedlist/array.md    |  18 +--
 .../linked_list.md                            |  16 +--
 docs/chapter_array_and_linkedlist/list.md     |  14 +-
 .../performance_evaluation.md                 |  10 +-
 .../space_complexity.md                       |   6 +-
 .../space_time_tradeoff.md                    |   2 +-
 .../time_complexity.md                        |  18 +--
 .../classification_of_data_structure.md       |   6 +-
 .../chapter_data_structure/data_and_memory.md |   6 +-
 docs/chapter_heap/heap.md                     |  32 +++++
 .../algorithms_are_everywhere.md              |   6 +-
 docs/chapter_preface/about_the_book.md        |   6 +-
 docs/chapter_preface/suggestions.md           |   6 +-
 docs/chapter_searching/binary_search.md       |  10 +-
 docs/chapter_searching/linear_search.md       |   4 +-
 docs/chapter_sorting/quick_sort.md            |   4 +-
 docs/chapter_stack_and_queue/deque.md         |  58 ++++----
 docs/chapter_stack_and_queue/queue.md         | 104 +++++++-------
 docs/chapter_stack_and_queue/stack.md         | 132 +++++++++---------
 docs/chapter_tree/avl_tree.md                 |   2 +-
 docs/chapter_tree/binary_search_tree.md       |   6 +-
 docs/chapter_tree/binary_tree.md              |   6 +-
 22 files changed, 252 insertions(+), 220 deletions(-)
 create mode 100644 docs/chapter_heap/heap.md

diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 648a9c753..8befdbea6 100644
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -14,7 +14,7 @@ comments: true
 
     观察上图，我们发现 **数组首元素的索引为 $0$** 。你可能会想，这并不符合日常习惯，首个元素的索引为什么不是 $1$ 呢，这不是更加自然吗？我认同你的想法，但请先记住这个设定，后面讲内存地址计算时，我会尝试解答这个问题。
 
-**数组有多种初始化写法。** 根据实际需要，选代码最短的那一种就好。
+**数组有多种初始化写法**。根据实际需要，选代码最短的那一种就好。
 
 === "Java"
 
@@ -83,7 +83,7 @@ comments: true
 
 ## 数组优点
 
-**在数组中访问元素非常高效。** 这是因为在数组中，计算元素的内存地址非常容易。给定数组首个元素的地址、和一个元素的索引，利用以下公式可以直接计算得到该元素的内存地址，从而直接访问此元素。
+**在数组中访问元素非常高效**。这是因为在数组中，计算元素的内存地址非常容易。给定数组首个元素的地址、和一个元素的索引，利用以下公式可以直接计算得到该元素的内存地址，从而直接访问此元素。
 
 ![array_memory_location_calculation](array.assets/array_memory_location_calculation.png)
 
@@ -195,7 +195,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 ## 数组缺点
 
-**数组在初始化后长度不可变。** 由于系统无法保证数组之后的内存空间是可用的，因此数组长度无法扩展。而若希望扩容数组，则需新建一个数组，然后把原数组元素依次拷贝到新数组，在数组很大的情况下，这是非常耗时的。
+**数组在初始化后长度不可变**。由于系统无法保证数组之后的内存空间是可用的，因此数组长度无法扩展。而若希望扩容数组，则需新建一个数组，然后把原数组元素依次拷贝到新数组，在数组很大的情况下，这是非常耗时的。
 
 === "Java"
 
@@ -317,7 +317,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     }
     ```
 
-**数组中插入或删除元素效率低下。** 假设我们想要在数组中间某位置插入一个元素，由于数组元素在内存中是“紧挨着的”，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。删除元素也是类似，需要把此索引之后的元素都向前移动一位。总体看有以下缺点：
+**数组中插入或删除元素效率低下**。假设我们想要在数组中间某位置插入一个元素，由于数组元素在内存中是“紧挨着的”，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。删除元素也是类似，需要把此索引之后的元素都向前移动一位。总体看有以下缺点：
 
 - **时间复杂度高：** 数组的插入和删除的平均时间复杂度均为 $O(N)$ ，其中 $N$ 为数组长度。
 - **丢失元素：** 由于数组的长度不可变，因此在插入元素后，超出数组长度范围的元素会被丢失。
@@ -488,7 +488,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 ## 数组常用操作
 
-**数组遍历。** 以下介绍两种常用的遍历方法。
+**数组遍历**。以下介绍两种常用的遍历方法。
 
 === "Java"
 
@@ -611,7 +611,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     }
     ```
 
-**数组查找。** 通过遍历数组，查找数组内的指定元素，并输出对应索引。
+**数组查找**。通过遍历数组，查找数组内的指定元素，并输出对应索引。
 
 === "Java"
 
@@ -715,8 +715,8 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 ## 数组典型应用
 
-**随机访问。** 如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。
+**随机访问**。如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。
 
-**二分查找。** 例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的“翻开中间，排除一半”的方式，来实现一个查电子字典的算法。
+**二分查找**。例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的“翻开中间，排除一半”的方式，来实现一个查电子字典的算法。
 
-**深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
+**深度学习**。神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
diff --git a/docs/chapter_array_and_linkedlist/linked_list.md b/docs/chapter_array_and_linkedlist/linked_list.md
index 5b6888c06..f054802d4 100644
--- a/docs/chapter_array_and_linkedlist/linked_list.md
+++ b/docs/chapter_array_and_linkedlist/linked_list.md
@@ -114,7 +114,7 @@ comments: true
 
 **尾结点指向什么？** 我们一般将链表的最后一个结点称为「尾结点」，其指向的是「空」，在 Java / C++ / Python 中分别记为 `null` / `nullptr` / `None` 。在不引起歧义下，本书都使用 `null` 来表示空。
 
-**链表初始化方法。** 建立链表分为两步，第一步是初始化各个结点对象，第二步是构建引用指向关系。完成后，即可以从链表的首个结点（即头结点）出发，访问其余所有的结点。
+**链表初始化方法**。建立链表分为两步，第一步是初始化各个结点对象，第二步是构建引用指向关系。完成后，即可以从链表的首个结点（即头结点）出发，访问其余所有的结点。
 
 !!! tip
 
@@ -248,7 +248,7 @@ comments: true
 
 ## 链表优点
 
-**在链表中，插入与删除结点的操作效率高。** 例如，如果想在链表中间的两个结点 `A` , `B` 之间插入一个新结点 `P` ，我们只需要改变两个结点指针即可，时间复杂度为 $O(1)$ ，相比数组的插入操作高效很多。在链表中删除某个结点也很方便，只需要改变一个结点指针即可。
+**在链表中，插入与删除结点的操作效率高**。例如，如果想在链表中间的两个结点 `A` , `B` 之间插入一个新结点 `P` ，我们只需要改变两个结点指针即可，时间复杂度为 $O(1)$ ，相比数组的插入操作高效很多。在链表中删除某个结点也很方便，只需要改变一个结点指针即可。
 
 ![linkedlist_insert_remove_node](linked_list.assets/linkedlist_insert_remove_node.png)
 
@@ -412,7 +412,7 @@ comments: true
 
 ## 链表缺点
 
-**链表访问结点效率低。** 上节提到，数组可以在 $O(1)$ 时间下访问任意元素，但链表无法直接访问任意结点。这是因为计算机需要从头结点出发，一个一个地向后遍历到目标结点。例如，倘若想要访问链表索引为 `index` （即第 `index + 1` 个）的结点，那么需要 `index` 次访问操作。
+**链表访问结点效率低**。上节提到，数组可以在 $O(1)$ 时间下访问任意元素，但链表无法直接访问任意结点。这是因为计算机需要从头结点出发，一个一个地向后遍历到目标结点。例如，倘若想要访问链表索引为 `index` （即第 `index + 1` 个）的结点，那么需要 `index` 次访问操作。
 
 === "Java"
 
@@ -520,11 +520,11 @@ comments: true
     }
     ```
 
-**链表的内存占用多。** 链表以结点为单位，每个结点除了保存值外，还需额外保存指针（引用）。这意味着同样数据量下，链表比数组需要占用更多内存空间。
+**链表的内存占用多**。链表以结点为单位，每个结点除了保存值外，还需额外保存指针（引用）。这意味着同样数据量下，链表比数组需要占用更多内存空间。
 
 ## 链表常用操作
 
-**遍历链表查找。** 遍历链表，查找链表内值为 `target` 的结点，输出结点在链表中的索引。
+**遍历链表查找**。遍历链表，查找链表内值为 `target` 的结点，输出结点在链表中的索引。
 
 === "Java"
 
@@ -649,11 +649,11 @@ comments: true
 
 ## 常见链表类型
 
-**单向链表。** 即上述介绍的普通链表。单向链表的结点有「值」和指向下一结点的「指针（引用）」两项数据。我们将首个结点称为头结点，尾结点指向 `null` 。
+**单向链表**。即上述介绍的普通链表。单向链表的结点有「值」和指向下一结点的「指针（引用）」两项数据。我们将首个结点称为头结点，尾结点指向 `null` 。
 
-**环形链表。** 如果我们令单向链表的尾结点指向头结点（即首尾相接），则得到一个环形链表。在环形链表中，我们可以将任意结点看作是头结点。
+**环形链表**。如果我们令单向链表的尾结点指向头结点（即首尾相接），则得到一个环形链表。在环形链表中，我们可以将任意结点看作是头结点。
 
-**双向链表。** 单向链表仅记录了一个方向的指针（引用），在双向链表的结点定义中，同时有指向下一结点（后继结点）和上一结点（前驱结点）的「指针（引用）」。双向链表相对于单向链表更加灵活，即可以朝两个方向遍历链表，但也需要占用更多的内存空间。
+**双向链表**。单向链表仅记录了一个方向的指针（引用），在双向链表的结点定义中，同时有指向下一结点（后继结点）和上一结点（前驱结点）的「指针（引用）」。双向链表相对于单向链表更加灵活，即可以朝两个方向遍历链表，但也需要占用更多的内存空间。
 
 === "Java"
 
diff --git a/docs/chapter_array_and_linkedlist/list.md b/docs/chapter_array_and_linkedlist/list.md
index 749b19482..19de6d778 100644
--- a/docs/chapter_array_and_linkedlist/list.md
+++ b/docs/chapter_array_and_linkedlist/list.md
@@ -4,13 +4,13 @@ comments: true
 
 # 列表
 
-**由于长度不可变，数组的实用性大大降低。** 在很多情况下，我们事先并不知道会输入多少数据，这就为数组长度的选择带来了很大困难。长度选小了，需要在添加数据中频繁地扩容数组；长度选大了，又造成内存空间的浪费。
+**由于长度不可变，数组的实用性大大降低**。在很多情况下，我们事先并不知道会输入多少数据，这就为数组长度的选择带来了很大困难。长度选小了，需要在添加数据中频繁地扩容数组；长度选大了，又造成内存空间的浪费。
 
 为了解决此问题，诞生了一种被称为「列表 List」的数据结构。列表可以被理解为长度可变的数组，因此也常被称为「动态数组 Dynamic Array」。列表基于数组实现，继承了数组的优点，同时还可以在程序运行中实时扩容。在列表中，我们可以自由地添加元素，而不用担心超过容量限制。
 
 ## 列表常用操作
 
-**初始化列表。** 我们通常会使用到“无初始值”和“有初始值”的两种初始化方法。
+**初始化列表**。我们通常会使用到“无初始值”和“有初始值”的两种初始化方法。
 
 === "Java"
 
@@ -91,7 +91,7 @@ comments: true
     List<int> list = numbers.ToList();
     ```
 
-**访问与更新元素。** 列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。
+**访问与更新元素**。列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。
 
 === "Java"
 
@@ -169,7 +169,7 @@ comments: true
     list[1] = 0;  // 将索引 1 处的元素更新为 0
     ```
 
-**在列表中添加、插入、删除元素。** 相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
+**在列表中添加、插入、删除元素**。相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
 
 === "Java"
 
@@ -317,7 +317,7 @@ comments: true
     list.RemoveAt(3);
     ```
 
-**遍历列表。** 与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
+**遍历列表**。与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
 
 === "Java"
 
@@ -437,7 +437,7 @@ comments: true
     }
     ```
 
-**拼接两个列表。** 再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。
+**拼接两个列表**。再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。
 
 === "Java"
 
@@ -502,7 +502,7 @@ comments: true
     list.AddRange(list1);  // 将列表 list1 拼接到 list 之后
     ```
 
-**排序列表。** 排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
+**排序列表**。排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
 
 === "Java"
 
diff --git a/docs/chapter_computational_complexity/performance_evaluation.md b/docs/chapter_computational_complexity/performance_evaluation.md
index 3244f41d8..f75b4d8d4 100644
--- a/docs/chapter_computational_complexity/performance_evaluation.md
+++ b/docs/chapter_computational_complexity/performance_evaluation.md
@@ -8,8 +8,8 @@ comments: true
 
 在开始学习算法之前，我们首先要想清楚算法的设计目标是什么，或者说，如何来评判算法的好与坏。整体上看，我们设计算法时追求两个层面的目标。
 
-1. **找到问题解法。** 算法需要能够在规定的输入范围下，可靠地求得问题的正确解。
-2. **寻求最优解法。** 同一个问题可能存在多种解法，而我们希望算法效率尽可能的高。
+1. **找到问题解法**。算法需要能够在规定的输入范围下，可靠地求得问题的正确解。
+2. **寻求最优解法**。同一个问题可能存在多种解法，而我们希望算法效率尽可能的高。
 
 换言之，在可以解决问题的前提下，算法效率则是主要评价维度，包括：
 
@@ -24,9 +24,9 @@ comments: true
 
 假设我们现在有算法 A 和 算法 B ，都能够解决同一问题，现在需要对比两个算法之间的效率。我们能够想到的最直接的方式，就是找一台计算机，把两个算法都完整跑一遍，并监控记录运行时间和内存占用情况。这种评估方式能够反映真实情况，但是也存在很大的硬伤。
 
-**难以排除测试环境的干扰因素。** 硬件配置会影响到算法的性能表现。例如，在某台计算机中，算法 A 比算法 B 运行时间更短；但换到另一台配置不同的计算机中，可能会得到相反的测试结果。这意味着我们需要在各种机器上展开测试，而这是不现实的。
+**难以排除测试环境的干扰因素**。硬件配置会影响到算法的性能表现。例如，在某台计算机中，算法 A 比算法 B 运行时间更短；但换到另一台配置不同的计算机中，可能会得到相反的测试结果。这意味着我们需要在各种机器上展开测试，而这是不现实的。
 
-**展开完整测试非常耗费资源。** 随着输入数据量的大小变化，算法会呈现出不同的效率表现。比如，有可能输入数据量较小时，算法 A 运行时间短于算法 B ，而在输入数据量较大时，测试结果截然相反。因此，若想要达到具有说服力的对比结果，那么需要输入各种体量数据，这样的测试需要占用大量计算资源。
+**展开完整测试非常耗费资源**。随着输入数据量的大小变化，算法会呈现出不同的效率表现。比如，有可能输入数据量较小时，算法 A 运行时间短于算法 B ，而在输入数据量较大时，测试结果截然相反。因此，若想要达到具有说服力的对比结果，那么需要输入各种体量数据，这样的测试需要占用大量计算资源。
 
 ### 理论估算
 
@@ -34,7 +34,7 @@ comments: true
 
 **复杂度分析评估随着输入数据量的增长，算法的运行时间和占用空间的增长趋势** 。根据时间和空间两方面，复杂度可分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。
 
-**复杂度分析克服了实际测试方法的弊端。** 一是独立于测试环境，分析结果适用于所有运行平台。二是可以体现不同数据量下的算法效率，尤其是可以反映大数据量下的算法性能。
+**复杂度分析克服了实际测试方法的弊端**。一是独立于测试环境，分析结果适用于所有运行平台。二是可以体现不同数据量下的算法效率，尤其是可以反映大数据量下的算法性能。
 
 ## 复杂度分析的重要性
 
diff --git a/docs/chapter_computational_complexity/space_complexity.md b/docs/chapter_computational_complexity/space_complexity.md
index 1d561792b..1756f2e24 100644
--- a/docs/chapter_computational_complexity/space_complexity.md
+++ b/docs/chapter_computational_complexity/space_complexity.md
@@ -208,8 +208,8 @@ comments: true
 
 **最差空间复杂度中的“最差”有两层含义**，分别为输入数据的最差分布、算法运行中的最差时间点。
 
-- **以最差输入数据为准。** 当 $n < 10$ 时，空间复杂度为 $O(1)$ ；但是当 $n > 10$ 时，初始化的数组 `nums` 使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
-- **以算法运行过程中的峰值内存为准。** 程序在执行最后一行之前，使用 $O(1)$ 空间；当初始化数组 `nums` 时，程序使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
+- **以最差输入数据为准**。当 $n < 10$ 时，空间复杂度为 $O(1)$ ；但是当 $n > 10$ 时，初始化的数组 `nums` 使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
+- **以算法运行过程中的峰值内存为准**。程序在执行最后一行之前，使用 $O(1)$ 空间；当初始化数组 `nums` 时，程序使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
 
 === "Java"
 
@@ -301,7 +301,7 @@ comments: true
     }
     ```
 
-**在递归函数中，需要注意统计栈帧空间。** 例如函数 `loop()`，在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行中会同时存在 $n$ 个未返回的 `recur()` ，从而使用 $O(n)$ 的栈帧空间。
+**在递归函数中，需要注意统计栈帧空间**。例如函数 `loop()`，在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行中会同时存在 $n$ 个未返回的 `recur()` ，从而使用 $O(n)$ 的栈帧空间。
 
 === "Java"
 
diff --git a/docs/chapter_computational_complexity/space_time_tradeoff.md b/docs/chapter_computational_complexity/space_time_tradeoff.md
index 0b86c11ca..49cf33778 100644
--- a/docs/chapter_computational_complexity/space_time_tradeoff.md
+++ b/docs/chapter_computational_complexity/space_time_tradeoff.md
@@ -6,7 +6,7 @@ comments: true
 
 理想情况下，我们希望算法的时间复杂度和空间复杂度都能够达到最优，而实际上，同时优化时间复杂度和空间复杂度是非常困难的。
 
-**降低时间复杂度，往往是以提升空间复杂度为代价的，反之亦然。** 我们把牺牲内存空间来提升算法运行速度的思路称为「以空间换时间」；反之，称之为「以时间换空间」。选择哪种思路取决于我们更看重哪个方面。
+**降低时间复杂度，往往是以提升空间复杂度为代价的，反之亦然**。我们把牺牲内存空间来提升算法运行速度的思路称为「以空间换时间」；反之，称之为「以时间换空间」。选择哪种思路取决于我们更看重哪个方面。
 
 大多数情况下，时间都是比空间更宝贵的，只要空间复杂度不要太离谱、能接受就行，**因此以空间换时间最为常用**。
 
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 03e59e256..217981ae8 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -153,7 +153,7 @@ $$
     }
     ```
 
-但实际上， **统计算法的运行时间既不合理也不现实。** 首先，我们不希望预估时间和运行平台绑定，毕竟算法需要跑在各式各样的平台之上。其次，我们很难获知每一种操作的运行时间，这为预估过程带来了极大的难度。
+但实际上， **统计算法的运行时间既不合理也不现实**。首先，我们不希望预估时间和运行平台绑定，毕竟算法需要跑在各式各样的平台之上。其次，我们很难获知每一种操作的运行时间，这为预估过程带来了极大的难度。
 
 ## 统计时间增长趋势
 
@@ -363,11 +363,11 @@ $$
 
 相比直接统计算法运行时间，时间复杂度分析的做法有什么好处呢？以及有什么不足？
 
-**时间复杂度可以有效评估算法效率。** 算法 `B` 运行时间的增长是线性的，在 $n > 1$ 时慢于算法 `A` ，在 $n > 1000000$ 时慢于算法 `C` 。实质上，只要输入数据大小 $n$ 足够大，复杂度为「常数阶」的算法一定优于「线性阶」的算法，这也正是时间增长趋势的含义。
+**时间复杂度可以有效评估算法效率**。算法 `B` 运行时间的增长是线性的，在 $n > 1$ 时慢于算法 `A` ，在 $n > 1000000$ 时慢于算法 `C` 。实质上，只要输入数据大小 $n$ 足够大，复杂度为「常数阶」的算法一定优于「线性阶」的算法，这也正是时间增长趋势的含义。
 
-**时间复杂度的推算方法更加简便。** 在时间复杂度分析中，我们可以将统计「计算操作的运行时间」简化为统计「计算操作的数量」，这是因为，无论是运行平台还是计算操作类型，都与算法运行时间的增长趋势无关。因而，我们可以简单地将所有计算操作的执行时间统一看作是相同的“单位时间”，这样的简化做法大大降低了估算难度。
+**时间复杂度的推算方法更加简便**。在时间复杂度分析中，我们可以将统计「计算操作的运行时间」简化为统计「计算操作的数量」，这是因为，无论是运行平台还是计算操作类型，都与算法运行时间的增长趋势无关。因而，我们可以简单地将所有计算操作的执行时间统一看作是相同的“单位时间”，这样的简化做法大大降低了估算难度。
 
-**时间复杂度也存在一定的局限性。** 比如，虽然算法 `A` 和 `C` 的时间复杂度相同，但是实际的运行时间有非常大的差别。再比如，虽然算法 `B` 比 `C` 的时间复杂度要更高，但在输入数据大小 $n$ 比较小时，算法 `B` 是要明显优于算法 `C` 的。对于以上情况，我们很难仅凭时间复杂度来判定算法效率高低。然而，即使存在这些问题，计算复杂度仍然是评判算法效率的最有效且常用的方法。
+**时间复杂度也存在一定的局限性**。比如，虽然算法 `A` 和 `C` 的时间复杂度相同，但是实际的运行时间有非常大的差别。再比如，虽然算法 `B` 比 `C` 的时间复杂度要更高，但在输入数据大小 $n$ 比较小时，算法 `B` 是要明显优于算法 `C` 的。对于以上情况，我们很难仅凭时间复杂度来判定算法效率高低。然而，即使存在这些问题，计算复杂度仍然是评判算法效率的最有效且常用的方法。
 
 ## 函数渐近上界
 
@@ -538,9 +538,9 @@ $T(n)$ 是个一次函数，说明时间增长趋势是线性的，因此易得
 
 对着代码，从上到下一行一行地计数即可。然而，**由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数偷懒技巧：
 
-1. **跳过数量与 $n$ 无关的操作。** 因为他们都是 $T(n)$ 中的常数项，对时间复杂度不产生影响。
-2. **省略所有系数。** 例如，循环 $2n$ 次、$5n + 1$ 次、……，都可以化简记为 $n$ 次，因为 $n$ 前面的系数对时间复杂度也不产生影响。
-3. **循环嵌套时使用乘法。** 总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用上述 `1.` 和 `2.` 技巧。
+1. **跳过数量与 $n$ 无关的操作**。因为他们都是 $T(n)$ 中的常数项，对时间复杂度不产生影响。
+2. **省略所有系数**。例如，循环 $2n$ 次、$5n + 1$ 次、……，都可以化简记为 $n$ 次，因为 $n$ 前面的系数对时间复杂度也不产生影响。
+3. **循环嵌套时使用乘法**。总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用上述 `1.` 和 `2.` 技巧。
 
 根据以下示例，使用上述技巧前、后的统计结果分别为
 
@@ -1004,7 +1004,7 @@ $$
 
 !!! tip
 
-    **数据大小 $n$ 是根据输入数据的类型来确定的。** 比如，在上述示例中，我们直接将 $n$ 看作输入数据大小；以下遍历数组示例中，数据大小 $n$ 为数组的长度。
+    **数据大小 $n$ 是根据输入数据的类型来确定的**。比如，在上述示例中，我们直接将 $n$ 看作输入数据大小；以下遍历数组示例中，数据大小 $n$ 为数组的长度。
 
 === "Java"
 
@@ -2308,7 +2308,7 @@ $$
 
 ## 最差、最佳、平均时间复杂度
 
-**某些算法的时间复杂度不是恒定的，而是与输入数据的分布有关。** 举一个例子，输入一个长度为 $n$ 数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的；算法的任务是返回元素 $1$ 的索引。我们可以得出以下结论：
+**某些算法的时间复杂度不是恒定的，而是与输入数据的分布有关**。举一个例子，输入一个长度为 $n$ 数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的；算法的任务是返回元素 $1$ 的索引。我们可以得出以下结论：
 
 - 当 `nums = [?, ?, ..., 1]`，即当末尾元素是 $1$ 时，则需完整遍历数组，此时达到 **最差时间复杂度 $O(n)$** ；
 - 当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，此时达到 **最佳时间复杂度 $\Omega(1)$** ；
diff --git a/docs/chapter_data_structure/classification_of_data_structure.md b/docs/chapter_data_structure/classification_of_data_structure.md
index d4397c5da..749542eb9 100644
--- a/docs/chapter_data_structure/classification_of_data_structure.md
+++ b/docs/chapter_data_structure/classification_of_data_structure.md
@@ -8,7 +8,7 @@ comments: true
 
 ## 逻辑结构：线性与非线性
 
-**「逻辑结构」反映了数据之间的逻辑关系。** 数组和链表的数据按照顺序依次排列，反映了数据间的线性关系；树从顶至底按层级排列，反映了祖先与后代之间的派生关系；图由结点和边组成，反映了复杂网络关系。
+**「逻辑结构」反映了数据之间的逻辑关系**。数组和链表的数据按照顺序依次排列，反映了数据间的线性关系；树从顶至底按层级排列，反映了祖先与后代之间的派生关系；图由结点和边组成，反映了复杂网络关系。
 
 我们一般将逻辑结构分为「线性」和「非线性」两种。“线性”这个概念很直观，即表明数据在逻辑关系上是排成一条线的；而如果数据之间的逻辑关系是非线形的（例如是网状或树状的），那么就是非线性数据结构。
 
@@ -25,13 +25,13 @@ comments: true
 
     若感到阅读困难，建议先看完下个章节「数组与链表」，再回过头来理解物理结构的含义。
 
-**「物理结构」反映了数据在计算机内存中的存储方式。** 从本质上看，分别是 **数组的连续空间存储** 和 **链表的离散空间存储** 。物理结构从底层上决定了数据的访问、更新、增删等操作方法，在时间效率和空间效率方面呈现出此消彼长的特性。
+**「物理结构」反映了数据在计算机内存中的存储方式**。从本质上看，分别是 **数组的连续空间存储** 和 **链表的离散空间存储** 。物理结构从底层上决定了数据的访问、更新、增删等操作方法，在时间效率和空间效率方面呈现出此消彼长的特性。
 
 ![classification_phisical_structure](classification_of_data_structure.assets/classification_phisical_structure.png)
 
 <p align="center"> Fig. 连续空间存储与离散空间存储 </p>
 
-**所有数据结构都是基于数组、或链表、或两者组合实现的。** 例如栈和队列，既可以使用数组实现、也可以使用链表实现，而例如哈希表，其实现同时包含了数组和链表。
+**所有数据结构都是基于数组、或链表、或两者组合实现的**。例如栈和队列，既可以使用数组实现、也可以使用链表实现，而例如哈希表，其实现同时包含了数组和链表。
 
 - **基于数组可实现：** 栈、队列、堆、哈希表、矩阵、张量（维度 $\geq 3$ 的数组）等；
 - **基于链表可实现：** 栈、队列、堆、哈希表、树、图等；
diff --git a/docs/chapter_data_structure/data_and_memory.md b/docs/chapter_data_structure/data_and_memory.md
index c620032aa..3a11fdf36 100644
--- a/docs/chapter_data_structure/data_and_memory.md
+++ b/docs/chapter_data_structure/data_and_memory.md
@@ -128,12 +128,12 @@ comments: true
 
 在计算机中，内存和硬盘是两种主要的存储硬件设备。「硬盘」主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。「内存」用于运行程序时暂存数据，速度更快，但容量较小（通常为 GB 级别）。
 
-**算法运行中，相关数据都被存储在内存中。** 下图展示了一个计算机内存条，其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格，其中每个单元格都可以存储 1 byte 的数据，在算法运行时，所有数据都被存储在这些单元格中。
+**算法运行中，相关数据都被存储在内存中**。下图展示了一个计算机内存条，其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格，其中每个单元格都可以存储 1 byte 的数据，在算法运行时，所有数据都被存储在这些单元格中。
 
-**系统通过「内存地址 Memory Location」来访问目标内存位置的数据。** 计算机根据特定规则给表格中每个单元格编号，保证每块内存空间都有独立的内存地址。自此，程序便通过这些地址，访问内存中的数据。
+**系统通过「内存地址 Memory Location」来访问目标内存位置的数据**。计算机根据特定规则给表格中每个单元格编号，保证每块内存空间都有独立的内存地址。自此，程序便通过这些地址，访问内存中的数据。
 
 ![computer_memory_location](data_and_memory.assets/computer_memory_location.png)
 
 <p align="center"> Fig. 内存条、内存空间、内存地址 </p>
 
-**内存资源是设计数据结构与算法的重要考虑因素。** 内存是所有程序的公共资源，当内存被某程序占用时，不能被其它程序同时使用。我们需要根据剩余内存资源的情况来设计算法。例如，若剩余内存空间有限，则要求算法占用的峰值内存不能超过系统剩余内存；若运行的程序很多、缺少大块连续的内存空间，则要求选取的数据结构必须能够存储在离散的内存空间内。
+**内存资源是设计数据结构与算法的重要考虑因素**。内存是所有程序的公共资源，当内存被某程序占用时，不能被其它程序同时使用。我们需要根据剩余内存资源的情况来设计算法。例如，若剩余内存空间有限，则要求算法占用的峰值内存不能超过系统剩余内存；若运行的程序很多、缺少大块连续的内存空间，则要求选取的数据结构必须能够存储在离散的内存空间内。
diff --git a/docs/chapter_heap/heap.md b/docs/chapter_heap/heap.md
new file mode 100644
index 000000000..def4cde5b
--- /dev/null
+++ b/docs/chapter_heap/heap.md
@@ -0,0 +1,32 @@
+# 堆
+
+「堆 Heap」是一种特殊的树状数据结构，并且是一颗「完全二叉树」。堆主要分为两种：
+
+- 「大顶堆 Max Heap」，任意父结点的值 > 其子结点的值，因此根结点的值最大；
+- 「小顶堆 Min Heap」，任意父结点的值 < 其子结点的值，因此根结点的值最小；
+
+（图）
+
+!!! tip ""
+
+    大顶堆和小顶堆的定义、性质、操作本质上是一样的。区别只是大顶堆在求最大值，小顶堆在求最小值。在下文中，我们将统一用「大顶堆」来举例，「小顶堆」的用法与实现可以简单地将所有 $>$ ($<$) 替换为 $<$ ($>$) 即可。
+
+## 堆常用操作
+
+堆的初始化。
+
+获取堆顶元素。
+
+添加与删除元素。
+
+## 堆的实现
+
+在二叉树章节中，我们讲过二叉树的数组表示方法，并且提到完全二叉树非常适合用数组来表示，因此我们一般使用「数组」来存储「堆」。
+
+
+
+## 堆常见应用
+
+- 优先队列。
+- 堆排序。
+- 获取数据 Top K 大（小）元素。
diff --git a/docs/chapter_introduction/algorithms_are_everywhere.md b/docs/chapter_introduction/algorithms_are_everywhere.md
index b80a525b0..5d80f9c92 100644
--- a/docs/chapter_introduction/algorithms_are_everywhere.md
+++ b/docs/chapter_introduction/algorithms_are_everywhere.md
@@ -6,13 +6,13 @@ comments: true
 
 听到“算法”这个词，我们一般会联想到数学。但实际上，大多数算法并不包含复杂的数学，而更像是在考察基本逻辑，而这些逻辑在我们日常生活中处处可见。
 
-在正式介绍算法之前，我想告诉你一件有趣的事：**其实，你在过去已经学会了很多算法，并且已经习惯将它们应用到日常生活中。** 接下来，我将介绍两个具体例子来佐证。
+在正式介绍算法之前，我想告诉你一件有趣的事：**其实，你在过去已经学会了很多算法，并且已经习惯将它们应用到日常生活中**。接下来，我将介绍两个具体例子来佐证。
 
-**例一：拼积木。** 一套积木，除了有许多部件之外，还会附送详细的拼装说明书。我们按照说明书上一步步操作，即可拼出复杂的积木模型。
+**例一：拼积木**。一套积木，除了有许多部件之外，还会附送详细的拼装说明书。我们按照说明书上一步步操作，即可拼出复杂的积木模型。
 
 如果从数据结构与算法的角度看，大大小小的「积木」就是数据结构，而「拼装说明书」上的一系列步骤就是算法。
 
-**例二：查字典。** 在字典中，每个汉字都有一个对应的拼音，而字典是按照拼音的英文字母表顺序排列的。假设需要在字典中查询任意一个拼音首字母为 $r$ 的字，一般我们会这样做：
+**例二：查字典**。在字典中，每个汉字都有一个对应的拼音，而字典是按照拼音的英文字母表顺序排列的。假设需要在字典中查询任意一个拼音首字母为 $r$ 的字，一般我们会这样做：
 
 1. 打开字典大致一半页数的位置，查看此页的首字母是什么（假设为 $m$ ）；
 2. 由于在英文字母表中 $r$ 在 $m$ 的后面，因此应排除字典前半部分，查找范围仅剩后半部分；
diff --git a/docs/chapter_preface/about_the_book.md b/docs/chapter_preface/about_the_book.md
index 54cd2844c..cb926b941 100644
--- a/docs/chapter_preface/about_the_book.md
+++ b/docs/chapter_preface/about_the_book.md
@@ -199,19 +199,19 @@ comments: true
 
 ??? abstract "默认折叠，可以跳过"
 
-    **以实践为主。** 我们知道，学习英语期间光啃书本是远远不够的，需要多听、多说、多写，在实践中培养语感、积累经验。编程语言也是一门语言，因此学习方法也应是类似的，需要多看优秀代码、多敲键盘、多思考代码逻辑。
+    **以实践为主**。我们知道，学习英语期间光啃书本是远远不够的，需要多听、多说、多写，在实践中培养语感、积累经验。编程语言也是一门语言，因此学习方法也应是类似的，需要多看优秀代码、多敲键盘、多思考代码逻辑。
     
     本书的理论部分占少量篇幅，主要分为两类：一是基础且必要的概念知识，以培养读者对于算法的感性认识；二是重要的分类、对比或总结，这是为了帮助你站在更高视角俯瞰各个知识点，形成连点成面的效果。
     
     实践部分主要由示例和代码组成。代码配有简要注释，复杂示例会尽可能地使用视觉化的形式呈现。我强烈建议读者对照着代码自己敲一遍，如果时间有限，也至少逐行读、复制并运行一遍，配合着讲解将代码吃透。
     
-    **视觉化学习。** 信息时代以来，视觉化的脚步从未停止。媒体形式经历了文字短信、图文 Email 、动图、短（长）视频、交互式 Web 、3D 游戏等演变过程，信息的视觉化程度越来越高、愈加符合人类感官、信息传播效率大大提升。科技界也在向视觉化迈进，iPhone 就是一个典型例子，其相对于传统手机是高度视觉化的，包含精心设计的字体、主题配色、交互动画等。
+    **视觉化学习**。信息时代以来，视觉化的脚步从未停止。媒体形式经历了文字短信、图文 Email 、动图、短（长）视频、交互式 Web 、3D 游戏等演变过程，信息的视觉化程度越来越高、愈加符合人类感官、信息传播效率大大提升。科技界也在向视觉化迈进，iPhone 就是一个典型例子，其相对于传统手机是高度视觉化的，包含精心设计的字体、主题配色、交互动画等。
     
     近两年，短视频成为最受欢迎的信息媒介，可以在短时间内将高密度的信息“灌”给我们，有着极其舒适的观看体验。阅读则不然，读者与书本之间天然存在一种“疏离感”，我们看书会累、会走神、会停下来想其他事、会划下喜欢的句子、会思考某一片段的含义，这种疏离感给了读者与书本之间对话的可能，拓宽了想象空间。
     
     本书作为一本入门教材，希望可以保有书本的“慢节奏”，但也会避免与读者产生过多“疏离感”，而是努力将知识完整清晰地推送到你聪明的小脑袋瓜中。我将采用视觉化的方式（例如配图、动画），尽我可能清晰易懂地讲解复杂概念和抽象示例。
     
-    **内容精简化。** 大多数的经典教科书，会把每个主题都讲的很透彻。虽然透彻性正是其获得读者青睐的原因，但对于想要快速入门的初学者来说，这些教材的实用性不足。本书会避免引入非必要的概念、名词、定义等，也避免展开不必要的理论分析，毕竟这不是一本真正意义上的教材，主要任务是尽快地带领读者入门。
+    **内容精简化**。大多数的经典教科书，会把每个主题都讲的很透彻。虽然透彻性正是其获得读者青睐的原因，但对于想要快速入门的初学者来说，这些教材的实用性不足。本书会避免引入非必要的概念、名词、定义等，也避免展开不必要的理论分析，毕竟这不是一本真正意义上的教材，主要任务是尽快地带领读者入门。
     
     引入一些生活案例或趣味内容，非常适合作为知识点的引子或者解释的补充，但当融入过多额外元素时，内容会稍显冗长，也许反而使读者容易迷失、抓不住重点，这也是本书需要避免的。
     
diff --git a/docs/chapter_preface/suggestions.md b/docs/chapter_preface/suggestions.md
index c0377ee34..d4dbd24bc 100644
--- a/docs/chapter_preface/suggestions.md
+++ b/docs/chapter_preface/suggestions.md
@@ -54,10 +54,10 @@ git clone https://github.com/krahets/hello-algo.git
 
 ## 算法学习“三步走”
 
-**第一阶段，算法入门，也正是本书的定位。** 熟悉各种数据结构的特点、用法，学习各种算法的工作原理、用途、效率等。
+**第一阶段，算法入门，也正是本书的定位**。熟悉各种数据结构的特点、用法，学习各种算法的工作原理、用途、效率等。
 
-**第二阶段，刷算法题。** 可以先从热门题单开刷，推荐 [剑指 Offer](https://leetcode.cn/problem-list/xb9nqhhg/)、[LeetCode 热题 HOT 100](https://leetcode.cn/problem-list/2cktkvj/) ，先积累至少 100 道题量，熟悉大多数的算法问题。刚开始刷题时，“遗忘”是最大的困扰点，但这是很正常的，请不要担心。学习中有一种概念叫“周期性回顾”，同一道题隔段时间做一次，当做了三遍以上，往往就能牢记于心了。
+**第二阶段，刷算法题**。可以先从热门题单开刷，推荐 [剑指 Offer](https://leetcode.cn/problem-list/xb9nqhhg/)、[LeetCode 热题 HOT 100](https://leetcode.cn/problem-list/2cktkvj/) ，先积累至少 100 道题量，熟悉大多数的算法问题。刚开始刷题时，“遗忘”是最大的困扰点，但这是很正常的，请不要担心。学习中有一种概念叫“周期性回顾”，同一道题隔段时间做一次，当做了三遍以上，往往就能牢记于心了。
 
-**第三阶段，搭建知识体系。** 在学习方面，可以阅读算法专栏文章、解题框架、算法教材，不断地丰富知识体系。在刷题方面，可以开始采用进阶刷题方案，例如按专题分类、一题多解、一解多题等，刷题方案在社区中可以找到一些讲解，在此不做赘述。
+**第三阶段，搭建知识体系**。在学习方面，可以阅读算法专栏文章、解题框架、算法教材，不断地丰富知识体系。在刷题方面，可以开始采用进阶刷题方案，例如按专题分类、一题多解、一解多题等，刷题方案在社区中可以找到一些讲解，在此不做赘述。
 
 ![learning_route](suggestions.assets/learning_route.png)
diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
index 6bc53fe5a..8827588ef 100644
--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@@ -470,11 +470,11 @@ $$
 
 二分查找效率很高，体现在：
 
-- **二分查找时间复杂度低。** 对数阶在数据量很大时具有巨大优势，例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需要 $\log_2 2^{20} = 20$ 轮循环。
-- **二分查找不需要额外空间。** 相对于借助额外数据结构来实现查找的算法来说，其更加节约空间使用。
+- **二分查找时间复杂度低**。对数阶在数据量很大时具有巨大优势，例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需要 $\log_2 2^{20} = 20$ 轮循环。
+- **二分查找不需要额外空间**。相对于借助额外数据结构来实现查找的算法来说，其更加节约空间使用。
 
 但并不意味着所有情况下都应使用二分查找，这是因为：
 
-- **二分查找仅适用于有序数据。** 如果输入数据是无序的，为了使用二分查找而专门执行数据排序，那么是得不偿失的，因为排序算法的时间复杂度一般为 $O(n \log n)$ ，比线性查找和二分查找都更差。再例如，对于频繁插入元素的场景，为了保持数组的有序性，需要将元素插入到特定位置，时间复杂度为 $O(n)$ ，也是非常昂贵的。
-- **二分查找仅适用于数组。** 由于在二分查找中，访问索引是 ”非连续“ 的，因此链表或者基于链表实现的数据结构都无法使用。
-- **在小数据量下，线性查找的性能更好。** 在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，在数据量 $n$ 较小时，线性查找反而比二分查找更快。
+- **二分查找仅适用于有序数据**。如果输入数据是无序的，为了使用二分查找而专门执行数据排序，那么是得不偿失的，因为排序算法的时间复杂度一般为 $O(n \log n)$ ，比线性查找和二分查找都更差。再例如，对于频繁插入元素的场景，为了保持数组的有序性，需要将元素插入到特定位置，时间复杂度为 $O(n)$ ，也是非常昂贵的。
+- **二分查找仅适用于数组**。由于在二分查找中，访问索引是 ”非连续“ 的，因此链表或者基于链表实现的数据结构都无法使用。
+- **在小数据量下，线性查找的性能更好**。在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，在数据量 $n$ 较小时，线性查找反而比二分查找更快。
diff --git a/docs/chapter_searching/linear_search.md b/docs/chapter_searching/linear_search.md
index 3d592962e..1c07027e6 100644
--- a/docs/chapter_searching/linear_search.md
+++ b/docs/chapter_searching/linear_search.md
@@ -246,6 +246,6 @@ comments: true
 
 ## 优点与缺点
 
-**线性查找的通用性极佳。** 由于线性查找是依次访问元素的，即没有跳跃访问元素，因此数组或链表皆适用。
+**线性查找的通用性极佳**。由于线性查找是依次访问元素的，即没有跳跃访问元素，因此数组或链表皆适用。
 
-**线性查找的时间复杂度太高。** 在数据量 $n$ 很大时，查找效率很低。
+**线性查找的时间复杂度太高**。在数据量 $n$ 很大时，查找效率很低。
diff --git a/docs/chapter_sorting/quick_sort.md b/docs/chapter_sorting/quick_sort.md
index b7b607f27..ebc161caa 100644
--- a/docs/chapter_sorting/quick_sort.md
+++ b/docs/chapter_sorting/quick_sort.md
@@ -383,7 +383,7 @@ comments: true
 
 ## 基准数优化
 
-**普通快速排序在某些输入下的时间效率变差。** 举个极端例子，假设输入数组是完全倒序的，由于我们选取最左端元素为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，从而 **左子数组长度为 $n - 1$ 、右子数组长度为 $0$** 。这样进一步递归下去，**每轮哨兵划分后的右子数组长度都为 $0$** ，分治策略失效，快速排序退化为「冒泡排序」了。
+**普通快速排序在某些输入下的时间效率变差**。举个极端例子，假设输入数组是完全倒序的，由于我们选取最左端元素为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，从而 **左子数组长度为 $n - 1$ 、右子数组长度为 $0$** 。这样进一步递归下去，**每轮哨兵划分后的右子数组长度都为 $0$** ，分治策略失效，快速排序退化为「冒泡排序」了。
 
 为了尽量避免这种情况发生，我们可以优化一下基准数的选取策略。首先，在哨兵划分中，我们可以 **随机选取一个元素作为基准数** 。但如果运气很差，每次都选择到比较差的基准数，那么效率依然不好。
 
@@ -576,7 +576,7 @@ comments: true
 
 ## 尾递归优化
 
-**普通快速排序在某些输入下的空间效率变差。** 仍然以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 0 ，那么将形成一个高度为 $n - 1$ 的递归树，此时使用的栈帧空间大小劣化至 $O(n)$ 。
+**普通快速排序在某些输入下的空间效率变差**。仍然以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 0 ，那么将形成一个高度为 $n - 1$ 的递归树，此时使用的栈帧空间大小劣化至 $O(n)$ 。
 
 为了避免栈帧空间的累积，我们可以在每轮哨兵排序完成后，判断两个子数组的长度大小，仅递归排序较短的子数组。由于较短的子数组长度不会超过 $\frac{n}{2}$ ，因此这样做能保证递归深度不超过 $\log n$ ，即最差空间复杂度被优化至 $O(\log n)$ 。
 
diff --git a/docs/chapter_stack_and_queue/deque.md b/docs/chapter_stack_and_queue/deque.md
index 72106360f..c178c0e0a 100644
--- a/docs/chapter_stack_and_queue/deque.md
+++ b/docs/chapter_stack_and_queue/deque.md
@@ -12,7 +12,7 @@ comments: true
 
 ## 双向队列常用操作
 
-双向队列的常用操作见下表，方法名需根据编程语言设定来具体确定。
+双向队列的常用操作见下表（方法命名以 Java 为例）。
 
 <p align="center"> Table. 双向队列的常用操作 </p>
 
@@ -38,25 +38,25 @@ comments: true
     ```java title="deque.java"
     /* 初始化双向队列 */
     Deque<Integer> deque = new LinkedList<>();
-
+    
     /* 元素入队 */
     deque.offerLast(2);   // 添加至队尾
     deque.offerLast(5);
     deque.offerLast(4);
     deque.offerFirst(3);  // 添加至队首
     deque.offerFirst(1);
-
+    
     /* 访问元素 */
     int peekFirst = deque.peekFirst();  // 队首元素
     int peekLast = deque.peekLast();    // 队尾元素
-
+    
     /* 元素出队 */
     int pollFirst = deque.pollFirst();  // 队首元素出队
     int pollLast = deque.pollLast();    // 队尾元素出队
-
+    
     /* 获取双向队列的长度 */
     int size = deque.size();
-
+    
     /* 判断双向队列是否为空 */
     boolean isEmpty = deque.isEmpty();
     ```
@@ -66,25 +66,25 @@ comments: true
     ```cpp title="deque.cpp"
     /* 初始化双向队列 */
     deque<int> deque;
-
+    
     /* 元素入队 */
     deque.push_back(2);   // 添加至队尾
     deque.push_back(5);
     deque.push_back(4);
     deque.push_front(3);  // 添加至队首
     deque.push_front(1);
-
+    
     /* 访问元素 */
     int front = deque.front(); // 队首元素
     int back = deque.back();   // 队尾元素
-
+    
     /* 元素出队 */
     deque.pop_front();  // 队首元素出队
     deque.pop_back();   // 队尾元素出队
-
+    
     /* 获取双向队列的长度 */
     int size = deque.size();
-
+    
     /* 判断双向队列是否为空 */
     bool empty = deque.empty();
     ```
@@ -94,25 +94,25 @@ comments: true
     ```python title="deque.py"
     """ 初始化双向队列 """
     duque = deque()
-
+    
     """ 元素入队 """
     duque.append(2)      # 添加至队尾
     duque.append(5)
     duque.append(4)
     duque.appendleft(3)  # 添加至队首
     duque.appendleft(1)
-
+    
     """ 访问元素 """
     front = duque[0]  # 队首元素
     rear = duque[-1]  # 队尾元素
-
+    
     """ 元素出队 """
     pop_front = duque.popleft()  # 队首元素出队
     pop_rear = duque.pop()       # 队尾元素出队
-
+    
     """ 获取双向队列的长度 """
     size = len(duque)
-
+    
     """ 判断双向队列是否为空 """
     is_empty = len(duque) == 0
     ```
@@ -123,25 +123,25 @@ comments: true
     /* 初始化双向队列 */
     // 在 Go 中，将 list 作为双向队列使用
     deque := list.New()
-
+    
     /* 元素入队 */
     deque.PushBack(2)      // 添加至队尾
     deque.PushBack(5)
     deque.PushBack(4)
     deque.PushFront(3)     // 添加至队首
     deque.PushFront(1)
-
+    
     /* 访问元素 */
     front := deque.Front() // 队首元素
     rear := deque.Back()   // 队尾元素
-
+    
     /* 元素出队 */
     deque.Remove(front)    // 队首元素出队
     deque.Remove(rear)     // 队尾元素出队
-
+    
     /* 获取双向队列的长度 */
     size := deque.Len()
-
+    
     /* 判断双向队列是否为空 */
     isEmpty := deque.Len() == 0
     ```
@@ -149,19 +149,19 @@ comments: true
 === "JavaScript"
 
     ```js title="deque.js"
-
+    
     ```
 
 === "TypeScript"
 
     ```typescript title="deque.ts"
-
+    
     ```
 
 === "C"
 
     ```c title="deque.c"
-
+    
     ```
 
 === "C#"
@@ -170,25 +170,25 @@ comments: true
     /* 初始化双向队列 */
     // 在 C# 中，将链表 LinkedList 看作双向队列来使用
     LinkedList<int> deque = new LinkedList<int>();
-
+    
     /* 元素入队 */
     deque.AddLast(2);   // 添加至队尾
     deque.AddLast(5);
     deque.AddLast(4);
     deque.AddFirst(3);  // 添加至队首
     deque.AddFirst(1);
-
+    
     /* 访问元素 */
     int peekFirst = deque.First.Value;  // 队首元素
     int peekLast = deque.Last.Value;    // 队尾元素
-
+    
     /* 元素出队 */
     deque.RemoveFirst();  // 队首元素出队
     deque.RemoveLast();   // 队尾元素出队
-
+    
     /* 获取双向队列的长度 */
     int size = deque.Count;
-
+    
     /* 判断双向队列是否为空 */
     bool isEmpty = deque.Count == 0;
     ```
diff --git a/docs/chapter_stack_and_queue/queue.md b/docs/chapter_stack_and_queue/queue.md
index cbf854f9c..8a964d3b7 100644
--- a/docs/chapter_stack_and_queue/queue.md
+++ b/docs/chapter_stack_and_queue/queue.md
@@ -14,7 +14,7 @@ comments: true
 
 ## 队列常用操作
 
-队列的常用操作见下表，方法命名需根据编程语言的设定来具体确定。
+队列的常用操作见下表（方法命名以 Java 为例）。
 
 <p align="center"> Table. 队列的常用操作 </p>
 
@@ -37,23 +37,23 @@ comments: true
     ```java title="queue.java"
     /* 初始化队列 */
     Queue<Integer> queue = new LinkedList<>();
-
+    
     /* 元素入队 */
     queue.offer(1);
     queue.offer(3);
     queue.offer(2);
     queue.offer(5);
     queue.offer(4);
-
+    
     /* 访问队首元素 */
     int peek = queue.peek();
-
+    
     /* 元素出队 */
     int poll = queue.poll();
-
+    
     /* 获取队列的长度 */
     int size = queue.size();
-
+    
     /* 判断队列是否为空 */
     boolean isEmpty = queue.isEmpty();
     ```
@@ -91,23 +91,23 @@ comments: true
     # 在 Python 中，我们一般将双向队列类 deque 看作队列使用
     # 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不建议
     que = collections.deque()
-
+    
     """ 元素入队 """
     que.append(1)
     que.append(3)
     que.append(2)
     que.append(5)
     que.append(4)
-
+    
     """ 访问队首元素 """
     front = que[0];
-
+    
     """ 元素出队 """
     pop = que.popleft()
-
+    
     """ 获取队列的长度 """
     size = len(que)
-
+    
     """ 判断队列是否为空 """
     is_empty = len(que) == 0
     ```
@@ -118,24 +118,24 @@ comments: true
     /* 初始化队列 */
     // 在 Go 中，将 list 作为队列来使用
     queue := list.New()
-
+    
     /* 元素入队 */
     queue.PushBack(1)
     queue.PushBack(3)
     queue.PushBack(2)
     queue.PushBack(5)
     queue.PushBack(4)
-
+    
     /* 访问队首元素 */
     peek := queue.Front()
-
+    
     /* 元素出队 */
     poll := queue.Front()
     queue.Remove(poll)
-
+    
     /* 获取队列的长度 */
     size := queue.Len()
-
+    
     /* 判断队列是否为空 */
     isEmpty := queue.Len() == 0
     ```
@@ -146,24 +146,24 @@ comments: true
     /* 初始化队列 */
     // JavaScript 没有内置的队列，可以把 Array 当作队列来使用
     const queue = [];
-
+    
     /* 元素入队 */
     queue.push(1);
     queue.push(3);
     queue.push(2);
     queue.push(5);
     queue.push(4);
-
+    
     /* 访问队首元素 */
     const peek = queue[0];
-
+    
     /* 元素出队 */
     // 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
     const poll = queue.shift();
-
+    
     /* 获取队列的长度 */
     const size = queue.length;
-
+    
     /* 判断队列是否为空 */
     const empty = queue.length === 0;
     ```
@@ -174,24 +174,24 @@ comments: true
     /* 初始化队列 */
     // TypeScript 没有内置的队列，可以把 Array 当作队列来使用 
     const queue: number[] = [];
-
+    
     /* 元素入队 */
     queue.push(1);
     queue.push(3);
     queue.push(2);
     queue.push(5);
     queue.push(4);
-
+    
     /* 访问队首元素 */
     const peek = queue[0];
-
+    
     /* 元素出队 */
     // 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
     const poll = queue.shift();
-
+    
     /* 获取队列的长度 */
     const size = queue.length;
-
+    
     /* 判断队列是否为空 */
     const empty = queue.length === 0;
     ```
@@ -199,7 +199,7 @@ comments: true
 === "C"
 
     ```c title="queue.c"
-
+    
     ```
 
 === "C#"
@@ -207,23 +207,23 @@ comments: true
     ```csharp title="queue.cs"
     /* 初始化队列 */
     Queue<int> queue = new();
-
+    
     /* 元素入队 */
     queue.Enqueue(1);
     queue.Enqueue(3);
     queue.Enqueue(2);
     queue.Enqueue(5);
     queue.Enqueue(4);
-
+    
     /* 访问队首元素 */
     int peek = queue.Peek();
-
+    
     /* 元素出队 */
     int poll = queue.Dequeue();
-
+    
     /* 获取队列的长度 */
     int size = queue.Count();
-
+    
     /* 判断队列是否为空 */
     bool isEmpty = queue.Count() == 0;
     ```
@@ -243,7 +243,7 @@ comments: true
     class LinkedListQueue {
         private ListNode front, rear;  // 头结点 front ，尾结点 rear 
         private int queSize = 0;
-
+    
         public LinkedListQueue() {
             front = null;
             rear = null;
@@ -296,7 +296,7 @@ comments: true
     private:
         ListNode *front, *rear;  // 头结点 front ，尾结点 rear 
         int queSize;
-
+    
     public:
         LinkedListQueue() {
             front = nullptr;
@@ -355,15 +355,15 @@ comments: true
             self.__front = None  # 头结点 front
             self.__rear = None   # 尾结点 rear
             self.__size = 0
-
+    
         """ 获取队列的长度 """
         def size(self):
             return self.__size
-
+    
         """ 判断队列是否为空 """
         def is_empty(self):
             return not self.__front
-
+    
         """ 入队 """
         def push(self, num):
             # 尾结点后添加 num
@@ -377,7 +377,7 @@ comments: true
                 self.__rear.next = node
                 self.__rear = node
             self.__size += 1
-
+    
         """ 出队 """
         def poll(self):
             num = self.peek()
@@ -385,7 +385,7 @@ comments: true
             self.__front = self.__front.next
             self.__size -= 1
             return num
-
+    
         """ 访问队首元素 """
         def peek(self):
             if self.size() == 0:
@@ -548,7 +548,7 @@ comments: true
 === "C"
 
     ```c title="linkedlist_queue.c"
-
+    
     ```
 
 === "C#"
@@ -630,7 +630,7 @@ comments: true
         private int[] nums;     // 用于存储队列元素的数组
         private int front = 0;  // 头指针，指向队首
         private int rear = 0;   // 尾指针，指向队尾 + 1
-
+    
         public ArrayQueue(int capacity) {
             // 初始化数组
             nums = new int[capacity];
@@ -686,7 +686,7 @@ comments: true
         int cap;        // 队列容量
         int front = 0;  // 头指针，指向队首
         int rear = 0;   // 尾指针，指向队尾 + 1
-
+    
     public:
         ArrayQueue(int capacity) {
             // 初始化数组
@@ -741,20 +741,20 @@ comments: true
             self.__nums = [0] * size  # 用于存储队列元素的数组
             self.__front = 0             # 头指针，指向队首
             self.__rear = 0              # 尾指针，指向队尾 + 1
-
+    
         """ 获取队列的容量 """
         def capacity(self):
             return len(self.__nums)
-
+    
         """ 获取队列的长度 """
         def size(self):
             # 由于将数组看作为环形，可能 rear < front ，因此需要取余数
             return (self.capacity() + self.__rear - self.__front) % self.capacity()
-
+    
         """ 判断队列是否为空 """
         def is_empty(self):
             return (self.__rear - self.__front) == 0
-
+    
         """ 入队 """
         def push(self, val):
             if self.size() == self.capacity():
@@ -764,21 +764,21 @@ comments: true
             self.__nums[self.__rear] = val
             # 尾指针向后移动一位，越过尾部后返回到数组头部
             self.__rear = (self.__rear + 1) % self.capacity()
-
+    
         """ 出队 """
         def poll(self):
             num = self.peek()
             # 队头指针向后移动一位，若越过尾部则返回到数组头部
             self.__front = (self.__front + 1) % self.capacity()
             return num
-
+    
         """ 访问队首元素 """
         def peek(self):
             if self.is_empty():
                 print("队列为空")
                 return False
             return self.__nums[self.__front]
-
+    
         """ 返回列表用于打印 """
         def to_list(self):
             res = [0] * self.size()
@@ -950,7 +950,7 @@ comments: true
 === "C"
 
     ```c title="array_queue.c"
-
+    
     ```
 
 === "C#"
@@ -1017,5 +1017,5 @@ comments: true
 
 ## 队列典型应用
 
-- **淘宝订单。** 购物者下单后，订单就被加入到队列之中，随后系统再根据顺序依次处理队列中的订单。在双十一时，在短时间内会产生海量的订单，如何处理「高并发」则是工程师们需要重点思考的问题。
-- **各种待办事项。** 例如打印机的任务队列、餐厅的出餐队列等等。
+- **淘宝订单**。购物者下单后，订单就被加入到队列之中，随后系统再根据顺序依次处理队列中的订单。在双十一时，在短时间内会产生海量的订单，如何处理「高并发」则是工程师们需要重点思考的问题。
+- **各种待办事项**。例如打印机的任务队列、餐厅的出餐队列等等。
diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index 825cda9f9..985a4cf66 100644
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -16,7 +16,7 @@ comments: true
 
 ## 栈常用操作
 
-栈的常用操作见下表，方法名需根据编程语言设定来具体确定。
+栈的常用操作见下表（方法命名以 Java 为例）。
 
 <p align="center"> Table. 栈的常用操作 </p>
 
@@ -40,23 +40,23 @@ comments: true
     /* 初始化栈 */
     // 在 Java 中，推荐将 LinkedList 当作栈来使用
     LinkedList<Integer> stack = new LinkedList<>();
-
+    
     /* 元素入栈 */
     stack.addLast(1);
     stack.addLast(3);
     stack.addLast(2);
     stack.addLast(5);
     stack.addLast(4);
-
+    
     /* 访问栈顶元素 */
     int peek = stack.peekLast();
-
+    
     /* 元素出栈 */
     int pop = stack.removeLast();
-
+    
     /* 获取栈的长度 */
     int size = stack.size();
-
+    
     /* 判断是否为空 */
     boolean isEmpty = stack.isEmpty();
     ```
@@ -66,23 +66,23 @@ comments: true
     ```cpp title="stack.cpp"
     /* 初始化栈 */
     stack<int> stack;
-
+    
     /* 元素入栈 */
     stack.push(1);
     stack.push(3);
     stack.push(2);
     stack.push(5);
     stack.push(4);
-
+    
     /* 访问栈顶元素 */
     int top = stack.top();
-
+    
     /* 元素出栈 */
     stack.pop();
-
+    
     /* 获取栈的长度 */
     int size = stack.size();
-
+    
     /* 判断是否为空 */
     bool empty = stack.empty();
     ```
@@ -93,23 +93,23 @@ comments: true
     """ 初始化栈 """
     # Python 没有内置的栈类，可以把 List 当作栈来使用 
     stack = []
-
+    
     """ 元素入栈 """
     stack.append(1)
     stack.append(3)
     stack.append(2)
     stack.append(5)
     stack.append(4)
-
+    
     """ 访问栈顶元素 """
     peek = stack[-1]
-
+    
     """ 元素出栈 """
     pop = stack.pop()
-
+    
     """ 获取栈的长度 """
     size = len(stack)
-
+    
     """ 判断是否为空 """
     is_empty = len(stack) == 0
     ```
@@ -120,24 +120,24 @@ comments: true
     /* 初始化栈 */
     // 在 Go 中，推荐将 Slice 当作栈来使用
     var stack []int
-
+    
     /* 元素入栈 */
     stack = append(stack, 1)
     stack = append(stack, 3)
     stack = append(stack, 2)
     stack = append(stack, 5)
     stack = append(stack, 4)
-
+    
     /* 访问栈顶元素 */
     peek := stack[len(stack)-1]
-
+    
     /* 元素出栈 */
     pop := stack[len(stack)-1]
     stack = stack[:len(stack)-1]
-
+    
     /* 获取栈的长度 */
     size := len(stack)
-
+    
     /* 判断是否为空 */
     isEmpty := len(stack) == 0
     ```
@@ -148,23 +148,23 @@ comments: true
     /* 初始化栈 */
     // Javascript 没有内置的栈类，可以把 Array 当作栈来使用 
     const stack = [];
-
+    
     /* 元素入栈 */
     stack.push(1);
     stack.push(3);
     stack.push(2);
     stack.push(5);
     stack.push(4);
-
+    
     /* 访问栈顶元素 */
     const peek = stack[stack.length-1];
-
+    
     /* 元素出栈 */
     const pop = stack.pop();
-
+    
     /* 获取栈的长度 */
     const size = stack.length;
-
+    
     /* 判断是否为空 */
     const is_empty = stack.length === 0;
     ```
@@ -175,23 +175,23 @@ comments: true
     /* 初始化栈 */
     // Typescript 没有内置的栈类，可以把 Array 当作栈来使用 
     const stack: number[] = [];
-
+    
     /* 元素入栈 */
     stack.push(1);
     stack.push(3);
     stack.push(2);
     stack.push(5);
     stack.push(4);
-
+    
     /* 访问栈顶元素 */
     const peek = stack[stack.length - 1];
-
+    
     /* 元素出栈 */
     const pop = stack.pop();
-
+    
     /* 获取栈的长度 */
     const size = stack.length;
-
+    
     /* 判断是否为空 */
     const is_empty = stack.length === 0;
     ```
@@ -199,7 +199,7 @@ comments: true
 === "C"
 
     ```c title="stack.c"
-
+    
     ```
 
 === "C#"
@@ -207,23 +207,23 @@ comments: true
     ```csharp title="stack.cs"
     /* 初始化栈 */
     Stack<int> stack = new ();
-
+    
     /* 元素入栈 */
     stack.Push(1);
     stack.Push(3);
     stack.Push(2);
     stack.Push(5);
     stack.Push(4);
-
+    
     /* 访问栈顶元素 */
     int peek = stack.Peek();
-
+    
     /* 元素出栈 */
     int pop = stack.Pop();
-
+    
     /* 获取栈的长度 */
     int size = stack.Count();
-
+    
     /* 判断是否为空 */
     bool isEmpty = stack.Count()==0;
     ```
@@ -291,7 +291,7 @@ comments: true
     private:
         ListNode* stackTop; // 将头结点作为栈顶
         int stkSize;        // 栈的长度
-
+    
     public:
         LinkedListStack() {
             stackTop = nullptr;
@@ -338,29 +338,29 @@ comments: true
         def __init__(self):
             self.__peek = None
             self.__size = 0
-
+    
         """ 获取栈的长度 """
         def size(self):
             return self.__size
-
+    
         """ 判断栈是否为空 """
         def is_empty(self):
             return not self.__peek
-
+    
         """ 入栈 """
         def push(self, val):
             node = ListNode(val)
             node.next = self.__peek
             self.__peek = node
             self.__size += 1
-
+    
         """ 出栈 """
         def pop(self):
             num = self.peek()
             self.__peek = self.__peek.next
             self.__size -= 1
             return num
-
+    
         """ 访问栈顶元素 """
         def peek(self):
             # 判空处理
@@ -420,21 +420,21 @@ comments: true
     class LinkedListStack {
         #stackPeek;  // 将头结点作为栈顶
         #stkSize = 0;   // 栈的长度
-
+    
         constructor() {
             this.#stackPeek = null;
         }
-
+    
         /* 获取栈的长度 */
         get size() {
             return this.#stkSize;
         }
-
+    
         /* 判断栈是否为空 */
         isEmpty() {
             return this.size == 0;
         }
-
+    
         /* 入栈 */
         push(num) {
             const node = new ListNode(num);
@@ -442,7 +442,7 @@ comments: true
             this.#stackPeek = node;
             this.#stkSize++;
         }
-
+    
         /* 出栈 */
         pop() {
             const num = this.peek();
@@ -453,7 +453,7 @@ comments: true
             this.#stkSize--;
             return num;
         }
-
+    
         /* 访问栈顶元素 */
         peek() {
             if (!this.#stackPeek) {
@@ -461,7 +461,7 @@ comments: true
             }
             return this.#stackPeek.val;
         }
-
+    
         /* 将链表转化为 Array 并返回 */
         toArray() {
             let node = this.#stackPeek;
@@ -482,21 +482,21 @@ comments: true
     class LinkedListStack {
         private stackPeek: ListNode | null;  // 将头结点作为栈顶
         private stkSize: number = 0;   // 栈的长度
-
+    
         constructor() {
             this.stackPeek = null;
         }
-
+    
         /* 获取栈的长度 */
         get size(): number {
             return this.stkSize;
         }
-
+    
         /* 判断栈是否为空 */
         isEmpty(): boolean {
             return this.size == 0;
         }
-
+    
         /* 入栈 */
         push(num: number): void {
             const node = new ListNode(num);
@@ -504,7 +504,7 @@ comments: true
             this.stackPeek = node;
             this.stkSize++;
         }
-
+    
         /* 出栈 */
         pop(): number {
             const num = this.peek();
@@ -515,7 +515,7 @@ comments: true
             this.stkSize--;
             return num;
         }
-
+    
         /* 访问栈顶元素 */
         peek(): number {
             if (!this.stackPeek) {
@@ -523,7 +523,7 @@ comments: true
             }
             return this.stackPeek.val;
         }
-
+    
         /* 将链表转化为 Array 并返回 */
         toArray(): number[] {
             let node = this.stackPeek;
@@ -540,7 +540,7 @@ comments: true
 === "C"
 
     ```c title="linkedlist_stack.c"
-
+    
     ```
 
 === "C#"
@@ -676,24 +676,24 @@ comments: true
     class ArrayStack:
         def __init__(self):
             self.__stack = []
-
+    
         """ 获取栈的长度 """
         def size(self):
             return len(self.__stack)
-
+    
         """ 判断栈是否为空 """
         def is_empty(self):
             return self.__stack == []
-
+    
         """ 入栈 """
         def push(self, item):
             self.__stack.append(item)
-
+    
         """ 出栈 """
         def pop(self):
             assert not self.is_empty(), "栈为空"
             return self.__stack.pop()
-
+    
         """ 访问栈顶元素 """
         def peek(self):
             assert not self.is_empty(), "栈为空"
@@ -821,7 +821,7 @@ comments: true
 === "C"
 
     ```c title="array_stack.c"
-
+    
     ```
 
 === "C#"
@@ -876,5 +876,5 @@ comments: true
 
 ## 栈典型应用
 
-- **浏览器中的后退与前进、软件中的撤销与反撤销。** 每当我们打开新的网页，浏览器就讲上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。
-- **程序内存管理。** 每当调用函数时，系统就会在栈顶添加一个栈帧，用来记录函数的上下文信息。在递归函数中，向下递推会不断执行入栈，向上回溯阶段时出栈。
+- **浏览器中的后退与前进、软件中的撤销与反撤销**。每当我们打开新的网页，浏览器就讲上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。
+- **程序内存管理**。每当调用函数时，系统就会在栈顶添加一个栈帧，用来记录函数的上下文信息。在递归函数中，向下递推会不断执行入栈，向上回溯阶段时出栈。
diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md
index d969c66d7..fe08828c1 100644
--- a/docs/chapter_tree/avl_tree.md
+++ b/docs/chapter_tree/avl_tree.md
@@ -253,7 +253,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 
 ## AVL 树旋转
 
-AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影响二叉树中序遍历序列的前提下，使失衡结点重新恢复平衡。** 换言之，旋转操作既可以使树保持为「二叉搜索树」，也可以使树重新恢复为「平衡二叉树」。
+AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影响二叉树中序遍历序列的前提下，使失衡结点重新恢复平衡**。换言之，旋转操作既可以使树保持为「二叉搜索树」，也可以使树重新恢复为「平衡二叉树」。
 
 我们将平衡因子的绝对值 $> 1$ 的结点称为「失衡结点」。根据结点的失衡情况，旋转操作分为 **右旋、左旋、先右旋后左旋、先左旋后右旋**，接下来我们来一起来看看它们是如何操作的。
 
diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md
index cc7c2f51c..60a5598bd 100644
--- a/docs/chapter_tree/binary_search_tree.md
+++ b/docs/chapter_tree/binary_search_tree.md
@@ -430,15 +430,15 @@ comments: true
 
 与插入结点一样，我们需要在删除操作后维持二叉搜索树的“左子树 < 根结点 < 右子树”的性质。首先，我们需要在二叉树中执行查找操作，获取待删除结点。接下来，根据待删除结点的子结点数量，删除操作需要分为三种情况：
 
-**待删除结点的子结点数量 $= 0$ 。** 表明待删除结点是叶结点，直接删除即可。
+**待删除结点的子结点数量 $= 0$ **。表明待删除结点是叶结点，直接删除即可。
 
 ![bst_remove_case1](binary_search_tree.assets/bst_remove_case1.png)
 
-**待删除结点的子结点数量 $= 1$ 。** 将待删除结点替换为其子结点。
+**待删除结点的子结点数量 $= 1$ **。将待删除结点替换为其子结点。
 
 ![bst_remove_case2](binary_search_tree.assets/bst_remove_case2.png)
 
-**待删除结点的子结点数量 $= 2$ 。** 删除操作分为三步：
+**待删除结点的子结点数量 $= 2$ **。删除操作分为三步：
 
 1. 找到待删除结点在 **中序遍历序列** 中的下一个结点，记为 `nex` ；
 2. 在树中递归删除结点 `nex` ；
diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md
index 3e3222222..7977ab6a2 100644
--- a/docs/chapter_tree/binary_tree.md
+++ b/docs/chapter_tree/binary_tree.md
@@ -137,7 +137,7 @@ comments: true
 
 ## 二叉树基本操作
 
-**初始化二叉树。** 与链表类似，先初始化结点，再构建引用指向（即指针）。
+**初始化二叉树**。与链表类似，先初始化结点，再构建引用指向（即指针）。
 
 === "Java"
 
@@ -263,7 +263,7 @@ comments: true
     n2.right = n5;
     ```
 
-**插入与删除结点。** 与链表类似，插入与删除结点都可以通过修改指针实现。
+**插入与删除结点**。与链表类似，插入与删除结点都可以通过修改指针实现。
 
 ![binary_tree_add_remove](binary_tree.assets/binary_tree_add_remove.png)
 
@@ -497,7 +497,7 @@ comments: true
 
 ![array_representation_with_empty](binary_tree.assets/array_representation_with_empty.png)
 
-回顾「完全二叉树」的满足条件，其只有最底层有空结点，并且最底层的结点尽量靠左，因而所有空结点都一定出现在层序遍历序列的末尾。**因为我们先验地确定了空位的位置，所以在使用数组表示完全二叉树时，可以省略存储“空位”**。“便于使用数组表示”也是完全二叉树受欢迎的原因之一。
+回顾「完全二叉树」的定义，其只有最底层有空结点，并且最底层的结点尽量靠左，因而所有空结点都一定出现在层序遍历序列的末尾。**因为我们先验地确定了空位的位置，所以在使用数组表示完全二叉树时，可以省略存储“空位”**。因此，完全二叉树非常适合使用数组来表示。
 
 ![array_representation_complete_binary_tree](binary_tree.assets/array_representation_complete_binary_tree.png)
 

From f49c6740299079d60196c106c59c5d05b72d3796 Mon Sep 17 00:00:00 2001
From: nuomi1 <nuomi1@qq.com>
Date: Thu, 5 Jan 2023 21:16:05 +0800
Subject: [PATCH 119/158] feat: add Swift codes for array article

---
 codes/swift/Package.swift                     |   2 +
 .../chapter_array_and_linkedlist/array.swift  | 103 ++++++++++++++++++
 docs/chapter_array_and_linkedlist/array.md    |  91 ++++++++++++++++
 3 files changed, 196 insertions(+)
 create mode 100644 codes/swift/chapter_array_and_linkedlist/array.swift

diff --git a/codes/swift/Package.swift b/codes/swift/Package.swift
index a292d9fd3..d9368354b 100644
--- a/codes/swift/Package.swift
+++ b/codes/swift/Package.swift
@@ -9,6 +9,7 @@ let package = Package(
         .executable(name: "worst_best_time_complexity", targets: ["worst_best_time_complexity"]),
         .executable(name: "space_complexity", targets: ["space_complexity"]),
         .executable(name: "leetcode_two_sum", targets: ["leetcode_two_sum"]),
+        .executable(name: "array", targets: ["array"]),
     ],
     targets: [
         .target(name: "utils", path: "utils"),
@@ -16,5 +17,6 @@ let package = Package(
         .executableTarget(name: "worst_best_time_complexity", path: "chapter_computational_complexity", sources: ["worst_best_time_complexity.swift"]),
         .executableTarget(name: "space_complexity", dependencies: ["utils"], path: "chapter_computational_complexity", sources: ["space_complexity.swift"]),
         .executableTarget(name: "leetcode_two_sum", path: "chapter_computational_complexity", sources: ["leetcode_two_sum.swift"]),
+        .executableTarget(name: "array", path: "chapter_array_and_linkedlist", sources: ["array.swift"]),
     ]
 )
diff --git a/codes/swift/chapter_array_and_linkedlist/array.swift b/codes/swift/chapter_array_and_linkedlist/array.swift
new file mode 100644
index 000000000..c0c7ab9b9
--- /dev/null
+++ b/codes/swift/chapter_array_and_linkedlist/array.swift
@@ -0,0 +1,103 @@
+/**
+ * File: array.swift
+ * Created Time: 2023-01-05
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+// 随机返回一个数组元素
+func randomAccess(nums: [Int]) -> Int {
+    // 在区间 [0, nums.count) 中随机抽取一个数字
+    let randomIndex = nums.indices.randomElement()!
+    // 获取并返回随机元素
+    let randomNum = nums[randomIndex]
+    return randomNum
+}
+
+// 扩展数组长度
+func extend(nums: [Int], enlarge: Int) -> [Int] {
+    // 初始化一个扩展长度后的数组
+    var res = Array(repeating: 0, count: nums.count + enlarge)
+    // 将原数组中的所有元素复制到新数组
+    for i in nums.indices {
+        res[i] = nums[i]
+    }
+    // 返回扩展后的新数组
+    return res
+}
+
+// 在数组的索引 index 处插入元素 num
+func insert(nums: inout [Int], num: Int, index: Int) {
+    // 把索引 index 以及之后的所有元素向后移动一位
+    for i in sequence(first: nums.count - 1, next: { $0 > index + 1 ? $0 - 1 : nil }) {
+        nums[i] = nums[i - 1]
+    }
+    // 将 num 赋给 index 处元素
+    nums[index] = num
+}
+
+// 删除索引 index 处元素
+func remove(nums: inout [Int], index: Int) {
+    let count = nums.count
+    // 把索引 index 之后的所有元素向前移动一位
+    for i in sequence(first: index, next: { $0 < count - 1 - 1 ? $0 + 1 : nil }) {
+        nums[i] = nums[i + 1]
+    }
+}
+
+// 遍历数组
+func traverse(nums: [Int]) {
+    var count = 0
+    // 通过索引遍历数组
+    for _ in nums.indices {
+        count += 1
+    }
+    // 直接遍历数组
+    for _ in nums {
+        count += 1
+    }
+}
+
+// 在数组中查找指定元素
+func find(nums: [Int], target: Int) -> Int {
+    for i in nums.indices {
+        if nums[i] == target {
+            return i
+        }
+    }
+    return -1
+}
+
+@main
+enum _Array {
+    // Driver Code
+    static func main() {
+        // 初始化数组
+        let arr = Array(repeating: 0, count: 5)
+        print("数组 arr = \(arr)")
+        var nums = [1, 3, 2, 5, 4]
+        print("数组 nums = \(nums)")
+
+        // 随机访问
+        let randomNum = randomAccess(nums: nums)
+        print("在 nums 中获取随机元素 \(randomNum)")
+
+        // 长度扩展
+        nums = extend(nums: nums, enlarge: 3)
+        print("将数组长度扩展至 8 ，得到 nums = \(nums)")
+
+        // 插入元素
+        insert(nums: &nums, num: 6, index: 3)
+        print("在索引 3 处插入数字 6 ，得到 nums = \(nums)")
+
+        // 删除元素
+        remove(nums: &nums, index: 2)
+        print("删除索引 2 处的元素，得到 nums = \(nums)")
+
+        // 遍历数组
+        traverse(nums: nums)
+
+        // 查找元素
+        let index = find(nums: nums, target: 3)
+        print("在 nums 中查找元素 3 ，得到索引 = \(index)")
+    }
+}
diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 648a9c753..5e814ea24 100644
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -81,6 +81,14 @@ comments: true
     int[] nums = { 1, 3, 2, 5, 4 };
     ```
 
+=== "Swift"
+
+    ```swift title="array.swift"
+    // 初始化数组
+    let arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]
+    let nums = [1, 3, 2, 5, 4]
+    ```
+
 ## 数组优点
 
 **在数组中访问元素非常高效。** 这是因为在数组中，计算元素的内存地址非常容易。给定数组首个元素的地址、和一个元素的索引，利用以下公式可以直接计算得到该元素的内存地址，从而直接访问此元素。
@@ -193,6 +201,19 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     }
     ```
 
+=== "Swift"
+
+    ```swift title="array.swift"
+    // 随机返回一个数组元素
+    func randomAccess(nums: [Int]) -> Int {
+        // 在区间 [0, nums.count) 中随机抽取一个数字
+        let randomIndex = nums.indices.randomElement()!
+        // 获取并返回随机元素
+        let randomNum = nums[randomIndex]
+        return randomNum
+    }
+    ```
+
 ## 数组缺点
 
 **数组在初始化后长度不可变。** 由于系统无法保证数组之后的内存空间是可用的，因此数组长度无法扩展。而若希望扩容数组，则需新建一个数组，然后把原数组元素依次拷贝到新数组，在数组很大的情况下，这是非常耗时的。
@@ -317,6 +338,22 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     }
     ```
 
+=== "Swift"
+
+    ```swift title="array.swift"
+    // 扩展数组长度
+    func extend(nums: [Int], enlarge: Int) -> [Int] {
+        // 初始化一个扩展长度后的数组
+        var res = Array(repeating: 0, count: nums.count + enlarge)
+        // 将原数组中的所有元素复制到新数组
+        for i in nums.indices {
+            res[i] = nums[i]
+        }
+        // 返回扩展后的新数组
+        return res
+    }
+    ```
+
 **数组中插入或删除元素效率低下。** 假设我们想要在数组中间某位置插入一个元素，由于数组元素在内存中是“紧挨着的”，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。删除元素也是类似，需要把此索引之后的元素都向前移动一位。总体看有以下缺点：
 
 - **时间复杂度高：** 数组的插入和删除的平均时间复杂度均为 $O(N)$ ，其中 $N$ 为数组长度。
@@ -486,6 +523,29 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     }
     ```
 
+=== "Swift"
+
+    ```swift title="array.swift"
+    // 在数组的索引 index 处插入元素 num
+    func insert(nums: inout [Int], num: Int, index: Int) {
+        // 把索引 index 以及之后的所有元素向后移动一位
+        for i in sequence(first: nums.count - 1, next: { $0 > index + 1 ? $0 - 1 : nil }) {
+            nums[i] = nums[i - 1]
+        }
+        // 将 num 赋给 index 处元素
+        nums[index] = num
+    }
+
+    // 删除索引 index 处元素
+    func remove(nums: inout [Int], index: Int) {
+        let count = nums.count
+        // 把索引 index 之后的所有元素向前移动一位
+        for i in sequence(first: index, next: { $0 < count - 1 - 1 ? $0 + 1 : nil }) {
+            nums[i] = nums[i + 1]
+        }
+    }
+    ```
+
 ## 数组常用操作
 
 **数组遍历。** 以下介绍两种常用的遍历方法。
@@ -611,6 +671,23 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     }
     ```
 
+=== "Swift"
+
+    ```swift title="array.swift"
+    // 遍历数组
+    func traverse(nums: [Int]) {
+        var count = 0
+        // 通过索引遍历数组
+        for _ in nums.indices {
+            count += 1
+        }
+        // 直接遍历数组
+        for _ in nums {
+            count += 1
+        }
+    }
+    ```
+
 **数组查找。** 通过遍历数组，查找数组内的指定元素，并输出对应索引。
 
 === "Java"
@@ -713,6 +790,20 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     }
     ```
 
+=== "Swift"
+
+    ```swift title="array.swift"
+    // 在数组中查找指定元素
+    func find(nums: [Int], target: Int) -> Int {
+        for i in nums.indices {
+            if nums[i] == target {
+                return i
+            }
+        }
+        return -1
+    }
+    ```
+
 ## 数组典型应用
 
 **随机访问。** 如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。

From dcc3b2e35b1d2fd8239e9904fea81e40ea83ad45 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Sun, 8 Jan 2023 19:03:22 +0800
Subject: [PATCH 120/158] Optimize arrToTree function in java, cpp, py, go, js,
 ts.

---
 .gitignore                                    |   4 +-
 codes/cpp/chapter_tree/binary_tree_bfs.cpp    |   3 +-
 codes/cpp/chapter_tree/binary_tree_dfs.cpp    |   3 +-
 codes/cpp/include/TreeNode.hpp                |  15 +--
 codes/csharp/chapter_tree/binary_tree_bfs.cs  |   3 +-
 codes/csharp/chapter_tree/binary_tree_dfs.cs  |   3 +-
 codes/csharp/include/TreeNode.cs              |  10 +-
 codes/go/chapter_tree/binary_tree_bfs_test.go |   6 +-
 codes/go/chapter_tree/binary_tree_dfs_test.go |  10 +-
 codes/go/pkg/tree_node.go                     |  10 +-
 codes/go/pkg/tree_node_test.go                |   2 +-
 codes/java/chapter_heap/my_heap.java          | 115 ++++++++++++++++++
 codes/java/chapter_tree/binary_tree_bfs.java  |   3 +-
 codes/java/chapter_tree/binary_tree_dfs.java  |   3 +-
 codes/java/include/PrintUtil.java             |   8 ++
 codes/java/include/TreeNode.java              |  24 +---
 .../chapter_tree/binary_tree_bfs.js           |   4 +-
 .../chapter_tree/binary_tree_dfs.js           |   3 +-
 codes/javascript/include/TreeNode.js          |  15 +--
 .../python/chapter_tree/binary_search_tree.py |   2 +-
 codes/python/chapter_tree/binary_tree.py      |   2 +-
 codes/python/chapter_tree/binary_tree_bfs.py  |   2 +-
 codes/python/chapter_tree/binary_tree_dfs.py  |   2 +-
 codes/python/include/binary_tree.py           |  36 ++----
 .../chapter_tree/binary_tree_bfs.ts           |   2 +-
 .../chapter_tree/binary_tree_dfs.ts           |   2 +-
 codes/typescript/module/TreeNode.ts           |   8 +-
 docs/chapter_heap/heap.md                     |  36 ++++--
 .../binary_tree_add_remove.png                | Bin 77839 -> 79400 bytes
 29 files changed, 222 insertions(+), 114 deletions(-)
 create mode 100644 codes/java/chapter_heap/my_heap.java

diff --git a/.gitignore b/.gitignore
index 3ff305496..e93873c95 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,5 +14,5 @@ docs/overrides/
 # python files
 __pycache__
 
-# iml
-hello-algo.iml
+# in-progress articles
+docs/chapter_heap
diff --git a/codes/cpp/chapter_tree/binary_tree_bfs.cpp b/codes/cpp/chapter_tree/binary_tree_bfs.cpp
index 236f62449..ffc2e372c 100644
--- a/codes/cpp/chapter_tree/binary_tree_bfs.cpp
+++ b/codes/cpp/chapter_tree/binary_tree_bfs.cpp
@@ -30,8 +30,7 @@ vector<int> hierOrder(TreeNode* root) {
 int main() {
     /* 初始化二叉树 */
     // 这里借助了一个从数组直接生成二叉树的函数
-    TreeNode* root = vecToTree(vector<int> 
-        { 1, 2, 3, 4, 5, 6, 7, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX });
+    TreeNode* root = vecToTree(vector<int> { 1, 2, 3, 4, 5, 6, 7 });
     cout << endl << "初始化二叉树\n" << endl;
     PrintUtil::printTree(root);
 
diff --git a/codes/cpp/chapter_tree/binary_tree_dfs.cpp b/codes/cpp/chapter_tree/binary_tree_dfs.cpp
index 51287b736..5ed5b78fe 100644
--- a/codes/cpp/chapter_tree/binary_tree_dfs.cpp
+++ b/codes/cpp/chapter_tree/binary_tree_dfs.cpp
@@ -41,8 +41,7 @@ void postOrder(TreeNode* root) {
 int main() {
     /* 初始化二叉树 */
     // 这里借助了一个从数组直接生成二叉树的函数
-    TreeNode* root = vecToTree(vector<int> 
-        { 1, 2, 3, 4, 5, 6, 7, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX});
+    TreeNode* root = vecToTree(vector<int> { 1, 2, 3, 4, 5, 6, 7 });
     cout << endl << "初始化二叉树\n" << endl;
     PrintUtil::printTree(root);
 
diff --git a/codes/cpp/include/TreeNode.hpp b/codes/cpp/include/TreeNode.hpp
index ab54c7746..82f2ce981 100644
--- a/codes/cpp/include/TreeNode.hpp
+++ b/codes/cpp/include/TreeNode.hpp
@@ -27,23 +27,24 @@ struct TreeNode {
  * @return TreeNode* 
  */
 TreeNode *vecToTree(vector<int> list) {
-    if (list.empty()) {
+    if (list.empty())
         return nullptr;
-    }
 
     auto *root = new TreeNode(list[0]);
     queue<TreeNode *> que;
-    size_t n = list.size(), index = 1;
-    while (index < n) {
+    que.emplace(root);
+    size_t n = list.size(), index = 0;
+    while (!que.empty()) {
         auto node = que.front();
         que.pop();
-
+        if (++index >= n) break;
         if (index < n) {
-            node->left = new TreeNode(list[index++]);
+            node->left = new TreeNode(list[index]);
             que.emplace(node->left);
         }
+        if (++index >= n) break;
         if (index < n) {
-            node->right = new TreeNode(list[index++]);
+            node->right = new TreeNode(list[index]);
             que.emplace(node->right);
         }
     }
diff --git a/codes/csharp/chapter_tree/binary_tree_bfs.cs b/codes/csharp/chapter_tree/binary_tree_bfs.cs
index 31f707246..f0c914acb 100644
--- a/codes/csharp/chapter_tree/binary_tree_bfs.cs
+++ b/codes/csharp/chapter_tree/binary_tree_bfs.cs
@@ -41,8 +41,7 @@ namespace hello_algo.chapter_tree
         {
             /* 初始化二叉树 */
             // 这里借助了一个从数组直接生成二叉树的函数
-            TreeNode? root = TreeNode.ArrToTree(new int?[] { 
-                1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null});
+            TreeNode? root = TreeNode.ArrToTree(new int?[] { 1, 2, 3, 4, 5, 6, 7 });
             Console.WriteLine("\n初始化二叉树\n");
             PrintUtil.PrintTree(root);
 
diff --git a/codes/csharp/chapter_tree/binary_tree_dfs.cs b/codes/csharp/chapter_tree/binary_tree_dfs.cs
index 6e38ebe4c..0f89cb3b2 100644
--- a/codes/csharp/chapter_tree/binary_tree_dfs.cs
+++ b/codes/csharp/chapter_tree/binary_tree_dfs.cs
@@ -57,8 +57,7 @@ namespace hello_algo.chapter_tree
         {
             /* 初始化二叉树 */
             // 这里借助了一个从数组直接生成二叉树的函数
-            TreeNode? root = TreeNode.ArrToTree(new int?[] { 
-                1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null});
+            TreeNode? root = TreeNode.ArrToTree(new int?[] { 1, 2, 3, 4, 5, 6, 7 });
             Console.WriteLine("\n初始化二叉树\n");
             PrintUtil.PrintTree(root);
 
diff --git a/codes/csharp/include/TreeNode.cs b/codes/csharp/include/TreeNode.cs
index e5cacd59e..9cd0ac92c 100644
--- a/codes/csharp/include/TreeNode.cs
+++ b/codes/csharp/include/TreeNode.cs
@@ -19,7 +19,7 @@ namespace hello_algo.include
         }
 
         /**
-         * Generate a binary tree with an array
+         * Generate a binary tree given an array
          * @param arr
          * @return
          */
@@ -31,22 +31,22 @@ namespace hello_algo.include
             TreeNode root = new TreeNode((int) arr[0]);
             Queue<TreeNode> queue = new Queue<TreeNode>();
             queue.Enqueue(root);
-            int i = 1;
-            while (queue.Count!=0)
+            int i = 0;
+            while (queue.Count != 0)
             {
                 TreeNode node = queue.Dequeue();
+                if (++i >= arr.Length) break;
                 if (arr[i] != null)
                 {
                     node.left = new TreeNode((int) arr[i]);
                     queue.Enqueue(node.left);
                 }
-                i++;
+                if (++i >= arr.Length) break;
                 if (arr[i] != null)
                 {
                     node.right = new TreeNode((int) arr[i]);
                     queue.Enqueue(node.right);
                 }
-                i++;
             }
             return root;
         }
diff --git a/codes/go/chapter_tree/binary_tree_bfs_test.go b/codes/go/chapter_tree/binary_tree_bfs_test.go
index 8d5c0aaff..d32dbdca9 100644
--- a/codes/go/chapter_tree/binary_tree_bfs_test.go
+++ b/codes/go/chapter_tree/binary_tree_bfs_test.go
@@ -14,11 +14,11 @@ import (
 func TestLevelOrder(t *testing.T) {
 	/* 初始化二叉树 */
 	// 这里借助了一个从数组直接生成二叉树的函数
-	root := ArrayToTree([]int{1, 2, 3, 4, 5, 6, 7})
-	fmt.Println("初始化二叉树: ")
+	root := ArrToTree([]int{1, 2, 3, 4, 5, 6, 7})
+	fmt.Println("\n初始化二叉树: ")
 	PrintTree(root)
 
 	// 层序遍历
 	nums := levelOrder(root)
-	fmt.Println("层序遍历的结点打印序列 =", nums)
+	fmt.Println("\n层序遍历的结点打印序列 =", nums)
 }
diff --git a/codes/go/chapter_tree/binary_tree_dfs_test.go b/codes/go/chapter_tree/binary_tree_dfs_test.go
index 67a3e1f3a..b0db8086c 100644
--- a/codes/go/chapter_tree/binary_tree_dfs_test.go
+++ b/codes/go/chapter_tree/binary_tree_dfs_test.go
@@ -14,22 +14,22 @@ import (
 func TestPreInPostOrderTraversal(t *testing.T) {
 	/* 初始化二叉树 */
 	// 这里借助了一个从数组直接生成二叉树的函数
-	root := ArrayToTree([]int{1, 2, 3, 4, 5, 6, 7})
-	fmt.Println("初始化二叉树: ")
+	root := ArrToTree([]int{1, 2, 3, 4, 5, 6, 7})
+	fmt.Println("\n初始化二叉树: ")
 	PrintTree(root)
 
 	// 前序遍历
 	nums = nil
 	preOrder(root)
-	fmt.Println("前序遍历的结点打印序列 =", nums)
+	fmt.Println("\n前序遍历的结点打印序列 =", nums)
 
 	// 中序遍历
 	nums = nil
 	inOrder(root)
-	fmt.Println("中序遍历的结点打印序列 =", nums)
+	fmt.Println("\n中序遍历的结点打印序列 =", nums)
 
 	// 后序遍历
 	nums = nil
 	postOrder(root)
-	fmt.Println("后序遍历的结点打印序列 =", nums)
+	fmt.Println("\n后序遍历的结点打印序列 =", nums)
 }
diff --git a/codes/go/pkg/tree_node.go b/codes/go/pkg/tree_node.go
index 2511a7655..b1e630e67 100644
--- a/codes/go/pkg/tree_node.go
+++ b/codes/go/pkg/tree_node.go
@@ -22,8 +22,8 @@ func NewTreeNode(v int) *TreeNode {
 	}
 }
 
-// ArrayToTree Generate a binary tree with an array
-func ArrayToTree(arr []int) *TreeNode {
+// ArrToTree Generate a binary tree given an array
+func ArrToTree(arr []int) *TreeNode {
 	if len(arr) <= 0 {
 		return nil
 	}
@@ -31,19 +31,19 @@ func ArrayToTree(arr []int) *TreeNode {
 	// Let container.list as queue
 	queue := list.New()
 	queue.PushBack(root)
-	i := 1
+	i := 0
 	for queue.Len() > 0 {
 		// poll
 		node := queue.Remove(queue.Front()).(*TreeNode)
+		i++
 		if i < len(arr) {
 			node.Left = NewTreeNode(arr[i])
 			queue.PushBack(node.Left)
-			i++
 		}
+		i++
 		if i < len(arr) {
 			node.Right = NewTreeNode(arr[i])
 			queue.PushBack(node.Right)
-			i++
 		}
 	}
 	return root
diff --git a/codes/go/pkg/tree_node_test.go b/codes/go/pkg/tree_node_test.go
index b4c8e0773..bb1885ee1 100644
--- a/codes/go/pkg/tree_node_test.go
+++ b/codes/go/pkg/tree_node_test.go
@@ -11,7 +11,7 @@ import (
 
 func TestTreeNode(t *testing.T) {
 	arr := []int{2, 3, 5, 6, 7}
-	node := ArrayToTree(arr)
+	node := ArrToTree(arr)
 
 	// print tree
 	PrintTree(node)
diff --git a/codes/java/chapter_heap/my_heap.java b/codes/java/chapter_heap/my_heap.java
new file mode 100644
index 000000000..da2dffc0a
--- /dev/null
+++ b/codes/java/chapter_heap/my_heap.java
@@ -0,0 +1,115 @@
+/**
+ * File: my_heap.java
+ * Created Time: 2023-01-07
+ * Author: Krahets (krahets@163.com)
+ */
+
+package chapter_heap;
+
+import include.*;
+import java.util.*;
+
+class MaxHeap {
+    private List<Integer> heap;
+
+    public MaxHeap() {
+        heap = new ArrayList<>();
+    }
+
+    public MaxHeap(List<Integer> nums) {
+        // 将元素拷贝至堆中
+        heap = new ArrayList<>(nums);
+        // 堆化除叶结点外的其他所有结点
+        for (int i = parent(size() - 1); i >= 0; i--) {
+            heapify(i);
+        }
+    }
+
+    /* 获取左子结点 */
+    private int left(int i) {
+        return 2 * i + 1;
+    }
+
+    /* 获取右子结点 */
+    private int right(int i) {
+        return 2 * i + 2;
+    }
+    
+    /* 获取父结点 */
+    private int parent(int i) {
+        return (i - 1) / 2;
+    }
+
+    /* 交换元素 */
+    private void swap(int i, int j) {
+        int tmp = heap.get(i);
+        heap.set(i, j);
+        heap.set(j, tmp);
+    }
+
+    public int size() {
+        return heap.size();
+    }
+
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    /* 获取堆顶元素 */
+    public int peek() {
+        return heap.get(0);
+    }
+
+    /* 元素入堆 */
+    public void push(int val) {
+        heap.add(val);
+
+        // 从底至顶堆化
+        int i = size();
+        while (true) {
+            int p = parent(i);
+            if (p < 0 || heap.get(i) > heap.get(p))
+                break;
+            swap(i, p);
+            i = p;
+        }
+    }
+
+    /* 元素出堆 */
+    public int poll() {
+        // 判空处理
+        if (isEmpty())
+            throw new EmptyStackException();
+        // 交换根结点与右下角（即最后一个）结点
+        swap(0, size() - 1);
+        // 删除结点
+        int val = heap.remove(size() - 1);
+        // 从顶至底堆化
+        heapify(0);
+        // 返回堆顶元素
+        return val;
+    }
+
+    /* 从结点 i 开始，从顶至底堆化 */
+    private void heapify(int i) {
+        while (true) {
+            // 判断结点 i, l, r 中的最大结点，记为 ma ；
+            int l = left(i), r = right(i), ma = i;
+            if (heap.get(l) > heap.get(ma)) ma = l;
+            if (heap.get(r) > heap.get(ma)) ma = r;
+            // 若结点 i 最大，则无需继续堆化，跳出
+            if (ma == i) break;
+            // 交换结点 i 与结点 max
+            swap(i, ma);
+            // 循环向下堆化
+            i = ma;
+        }
+    }
+}
+
+
+public class my_heap {
+    public static void main(String[] args) {
+
+    }
+}
diff --git a/codes/java/chapter_tree/binary_tree_bfs.java b/codes/java/chapter_tree/binary_tree_bfs.java
index c000eacea..450311d08 100644
--- a/codes/java/chapter_tree/binary_tree_bfs.java
+++ b/codes/java/chapter_tree/binary_tree_bfs.java
@@ -30,8 +30,7 @@ public class binary_tree_bfs {
     public static void main(String[] args) {
         /* 初始化二叉树 */
         // 这里借助了一个从数组直接生成二叉树的函数
-        TreeNode root = TreeNode.arrToTree(new Integer[] {
-                1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null });
+        TreeNode root = TreeNode.arrToTree(new Integer[] { 1, 2, 3, 4, 5, 6, 7 });
         System.out.println("\n初始化二叉树\n");
         PrintUtil.printTree(root);
 
diff --git a/codes/java/chapter_tree/binary_tree_dfs.java b/codes/java/chapter_tree/binary_tree_dfs.java
index 1d3026dfb..d1ef063b0 100644
--- a/codes/java/chapter_tree/binary_tree_dfs.java
+++ b/codes/java/chapter_tree/binary_tree_dfs.java
@@ -43,8 +43,7 @@ public class binary_tree_dfs {
     public static void main(String[] args) {
         /* 初始化二叉树 */
         // 这里借助了一个从数组直接生成二叉树的函数
-        TreeNode root = TreeNode.arrToTree(new Integer[] { 
-            1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null});
+        TreeNode root = TreeNode.arrToTree(new Integer[] { 1, null, 3, 4, 5 });
         System.out.println("\n初始化二叉树\n");
         PrintUtil.printTree(root);
 
diff --git a/codes/java/include/PrintUtil.java b/codes/java/include/PrintUtil.java
index f21bc17c9..b2593ac1f 100755
--- a/codes/java/include/PrintUtil.java
+++ b/codes/java/include/PrintUtil.java
@@ -8,6 +8,7 @@ package include;
 
 import java.util.*;
 
+
 class Trunk {
     Trunk prev;
     String str;
@@ -103,4 +104,11 @@ public class PrintUtil {
             System.out.println(kv.getKey() + " -> " + kv.getValue());
         }
     }
+
+    public static void printHeap(PriorityQueue<Integer> queue) {
+        Integer[] nums = (Integer[])queue.toArray();
+        TreeNode root = TreeNode.arrToTree(nums);
+        
+        printTree(root);
+    }
 }
diff --git a/codes/java/include/TreeNode.java b/codes/java/include/TreeNode.java
index b98252665..11d457a10 100644
--- a/codes/java/include/TreeNode.java
+++ b/codes/java/include/TreeNode.java
@@ -22,7 +22,7 @@ public class TreeNode {
     }
 
     /**
-     * Generate a binary tree with an array
+     * Generate a binary tree given an array
      * @param arr
      * @return
      */
@@ -32,19 +32,19 @@ public class TreeNode {
         
         TreeNode root = new TreeNode(arr[0]);
         Queue<TreeNode> queue = new LinkedList<>() {{ add(root); }};
-        int i = 1;
+        int i = 0;
         while(!queue.isEmpty()) {
             TreeNode node = queue.poll();
+            if (++i >= arr.length) break;
             if(arr[i] != null) {
                 node.left = new TreeNode(arr[i]);
                 queue.add(node.left);
             }
-            i++;
+            if (++i >= arr.length) break;
             if(arr[i] != null) {
                 node.right = new TreeNode(arr[i]);
                 queue.add(node.right);
             }
-            i++;
         }
         return root;
     }
@@ -71,20 +71,4 @@ public class TreeNode {
         }
         return list;
     }
-    
-    /**
-     * Get a tree node with specific value in a binary tree
-     * @param root
-     * @param val
-     * @return
-     */
-    public static TreeNode getTreeNode(TreeNode root, int val) {
-        if (root == null)
-            return null;
-        if (root.val == val)
-            return root;
-        TreeNode left = getTreeNode(root.left, val);
-        TreeNode right = getTreeNode(root.right, val);
-        return left != null ? left : right;
-    }
 }
diff --git a/codes/javascript/chapter_tree/binary_tree_bfs.js b/codes/javascript/chapter_tree/binary_tree_bfs.js
index b52f52820..21daaa8dc 100644
--- a/codes/javascript/chapter_tree/binary_tree_bfs.js
+++ b/codes/javascript/chapter_tree/binary_tree_bfs.js
@@ -28,10 +28,10 @@ function hierOrder(root) {
 /* Driver Code */
 /* 初始化二叉树 */
 // 这里借助了一个从数组直接生成二叉树的函数
-var root = arrToTree([1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null]);
+var root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
 console.log("\n初始化二叉树\n");
 printTree(root);
 
 /* 层序遍历 */
 let list = hierOrder(root);
-console.log("\n层序遍历的结点打印序列 = " + list);
\ No newline at end of file
+console.log("\n层序遍历的结点打印序列 = " + list);
diff --git a/codes/javascript/chapter_tree/binary_tree_dfs.js b/codes/javascript/chapter_tree/binary_tree_dfs.js
index 51e557336..d23b69b6d 100644
--- a/codes/javascript/chapter_tree/binary_tree_dfs.js
+++ b/codes/javascript/chapter_tree/binary_tree_dfs.js
@@ -40,7 +40,7 @@ function postOrder(root) {
 /* Driver Code */
 /* 初始化二叉树 */
 // 这里借助了一个从数组直接生成二叉树的函数
-var root = arrToTree([1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null]);
+var root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
 console.log("\n初始化二叉树\n");
 printTree(root);
 
@@ -58,4 +58,3 @@ console.log("\n中序遍历的结点打印序列 = " + list);
 list.length = 0;
 postOrder(root);
 console.log("\n后序遍历的结点打印序列 = " + list);
-
diff --git a/codes/javascript/include/TreeNode.js b/codes/javascript/include/TreeNode.js
index 6add12f0c..ce6d667bf 100644
--- a/codes/javascript/include/TreeNode.js
+++ b/codes/javascript/include/TreeNode.js
@@ -14,7 +14,7 @@ function TreeNode(val, left, right) {
 }
 
 /**
-* Generate a binary tree with an array
+* Generate a binary tree given an array
 * @param arr
 * @return
 */
@@ -24,20 +24,21 @@ function arrToTree(arr) {
          
     let root = new TreeNode(arr[0]);
     let queue = [root] 
-    let i = 1;
-    while(queue.length) {
+    let i = 0;
+    while (queue.length) {
         let node = queue.shift();
-        if(arr[i] !== null) {
+        if (++i >= arr.length) break;
+        if (arr[i] !== null) {
             node.left = new TreeNode(arr[i]);
             queue.push(node.left);
         }
-        i++;
-        if(arr[i] !== null) {
+        if (++i >= arr.length) break;
+        if (arr[i] !== null) {
             node.right = new TreeNode(arr[i]);
             queue.push(node.right);
         }
-        i++;
     }
+
     return root;
 }
 
diff --git a/codes/python/chapter_tree/binary_search_tree.py b/codes/python/chapter_tree/binary_search_tree.py
index db52d57bd..7633b6288 100644
--- a/codes/python/chapter_tree/binary_search_tree.py
+++ b/codes/python/chapter_tree/binary_search_tree.py
@@ -138,7 +138,7 @@ class BinarySearchTree:
 """ Driver Code """
 if __name__ == "__main__":
     # 初始化二叉搜索树
-    nums = list(range(1, 16))
+    nums = list(range(1, 16)) # [1, 2, ..., 15]
     bst = BinarySearchTree(nums=nums)
     print("\n初始化的二叉树为\n")
     print_tree(bst.root)
diff --git a/codes/python/chapter_tree/binary_tree.py b/codes/python/chapter_tree/binary_tree.py
index d99026352..e00eeb4e5 100644
--- a/codes/python/chapter_tree/binary_tree.py
+++ b/codes/python/chapter_tree/binary_tree.py
@@ -36,5 +36,5 @@ if __name__ == "__main__":
     print_tree(n1)
     # 删除结点
     n1.left = n2
-    print("\n删除结点 P 后\n");
+    print("\n删除结点 P 后\n")
     print_tree(n1)
diff --git a/codes/python/chapter_tree/binary_tree_bfs.py b/codes/python/chapter_tree/binary_tree_bfs.py
index 0320a08dd..225a8bd6e 100644
--- a/codes/python/chapter_tree/binary_tree_bfs.py
+++ b/codes/python/chapter_tree/binary_tree_bfs.py
@@ -32,7 +32,7 @@ def hier_order(root: TreeNode):
 if __name__ == "__main__":
     # 初始化二叉树
     # 这里借助了一个从数组直接生成二叉树的函数
-    root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7, None, None, None, None, None, None, None, None])
+    root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7])
     print("\n初始化二叉树\n")
     print_tree(root)
 
diff --git a/codes/python/chapter_tree/binary_tree_dfs.py b/codes/python/chapter_tree/binary_tree_dfs.py
index 11ee8339c..a1d46e697 100644
--- a/codes/python/chapter_tree/binary_tree_dfs.py
+++ b/codes/python/chapter_tree/binary_tree_dfs.py
@@ -45,7 +45,7 @@ def post_order(root: typing.Optional[TreeNode]):
 if __name__ == "__main__":
     # 初始化二叉树
     # 这里借助了一个从数组直接生成二叉树的函数
-    root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7, None, None, None, None, None, None, None, None])
+    root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7])
     print("\n初始化二叉树\n")
     print_tree(root)
 
diff --git a/codes/python/include/binary_tree.py b/codes/python/include/binary_tree.py
index 670fd18ce..9d612a7e2 100644
--- a/codes/python/include/binary_tree.py
+++ b/codes/python/include/binary_tree.py
@@ -26,39 +26,30 @@ class TreeNode:
 
 def list_to_tree(arr):
     """Generate a binary tree with a list
-
-    Args:
-        arr ([type]): [description]
-
-    Returns:
-        [type]: [description]
     """
     if not arr:
         return None
-    i = 1
-    root = TreeNode(int(arr[0]))
-    queue = collections.deque()
-    queue.append(root)
+    
+    i = 0
+    root = TreeNode(arr[0])
+    queue = collections.deque([root])
     while queue:
         node = queue.popleft()
+        i += 1
+        if i >= len(arr): break
         if arr[i] != None:
-            node.left = TreeNode(int(arr[i]))
+            node.left = TreeNode(arr[i])
             queue.append(node.left)
         i += 1
+        if i >= len(arr): break
         if arr[i] != None:
-            node.right = TreeNode(int(arr[i]))
+            node.right = TreeNode(arr[i])
             queue.append(node.right)
-        i += 1
+            
     return root
 
 def tree_to_list(root):
     """Serialize a tree into an array
-
-    Args:
-        root ([type]): [description]
-
-    Returns:
-        [type]: [description]
     """    
     if not root: return []
     queue = collections.deque()
@@ -75,13 +66,6 @@ def tree_to_list(root):
 
 def get_tree_node(root, val):
     """Get a tree node with specific value in a binary tree
-
-    Args:
-        root ([type]): [description]
-        val ([type]): [description]
-
-    Returns:
-        [type]: [description]
     """    
     if not root:
         return
diff --git a/codes/typescript/chapter_tree/binary_tree_bfs.ts b/codes/typescript/chapter_tree/binary_tree_bfs.ts
index 1e57ef62d..7ec4a2a5c 100644
--- a/codes/typescript/chapter_tree/binary_tree_bfs.ts
+++ b/codes/typescript/chapter_tree/binary_tree_bfs.ts
@@ -30,7 +30,7 @@ function hierOrder(root: TreeNode | null): number[] {
 /* Driver Code */
 /* 初始化二叉树 */
 // 这里借助了一个从数组直接生成二叉树的函数
-var root = arrToTree([1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null]);
+var root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
 console.log('\n初始化二叉树\n');
 printTree(root);
 
diff --git a/codes/typescript/chapter_tree/binary_tree_dfs.ts b/codes/typescript/chapter_tree/binary_tree_dfs.ts
index d9e982df1..a61855af8 100644
--- a/codes/typescript/chapter_tree/binary_tree_dfs.ts
+++ b/codes/typescript/chapter_tree/binary_tree_dfs.ts
@@ -47,7 +47,7 @@ function postOrder(root: TreeNode | null): void {
 /* Driver Code */
 /* 初始化二叉树 */
 // 这里借助了一个从数组直接生成二叉树的函数
-const root = arrToTree([1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null]);
+const root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
 console.log('\n初始化二叉树\n');
 printTree(root);
 
diff --git a/codes/typescript/module/TreeNode.ts b/codes/typescript/module/TreeNode.ts
index 5a886763e..0e3425006 100644
--- a/codes/typescript/module/TreeNode.ts
+++ b/codes/typescript/module/TreeNode.ts
@@ -20,7 +20,7 @@ class TreeNode {
 }
 
 /**
- * Generate a binary tree with an array
+ * Generate a binary tree given an array
  * @param arr
  * @return
  */
@@ -31,19 +31,19 @@ function arrToTree(arr: (number | null)[]): TreeNode | null {
 
     const root = new TreeNode(arr[0] as number);
     const queue = [root];
-    let i = 1;
+    let i = 0;
     while (queue.length) {
         let node = queue.shift() as TreeNode;
+        if (++i >= arr.length) break;
         if (arr[i] !== null) {
             node.left = new TreeNode(arr[i] as number);
             queue.push(node.left);
         }
-        i++;
+        if (++i >= arr.length) break;
         if (arr[i] !== null) {
             node.right = new TreeNode(arr[i] as number);
             queue.push(node.right);
         }
-        i++;
     }
     return root;
 }
diff --git a/docs/chapter_heap/heap.md b/docs/chapter_heap/heap.md
index def4cde5b..b0151622f 100644
--- a/docs/chapter_heap/heap.md
+++ b/docs/chapter_heap/heap.md
@@ -2,26 +2,48 @@
 
 「堆 Heap」是一种特殊的树状数据结构，并且是一颗「完全二叉树」。堆主要分为两种：
 
-- 「大顶堆 Max Heap」，任意父结点的值 > 其子结点的值，因此根结点的值最大；
-- 「小顶堆 Min Heap」，任意父结点的值 < 其子结点的值，因此根结点的值最小；
+- 「大顶堆 Max Heap」，任意结点的值 $\geq$ 其子结点的值，因此根结点的值最大；
+- 「小顶堆 Min Heap」，任意结点的值 $\leq$ 其子结点的值，因此根结点的值最小；
 
 （图）
 
 !!! tip ""
 
-    大顶堆和小顶堆的定义、性质、操作本质上是一样的。区别只是大顶堆在求最大值，小顶堆在求最小值。在下文中，我们将统一用「大顶堆」来举例，「小顶堆」的用法与实现可以简单地将所有 $>$ ($<$) 替换为 $<$ ($>$) 即可。
+    大顶堆和小顶堆的定义、性质、操作本质上是相同的，区别只是大顶堆在求最大值，小顶堆在求最小值。
 
 ## 堆常用操作
 
-堆的初始化。
+值得说明的是，多数编程语言提供的是「优先队列 Priority Queue」，其是一种抽象数据结构，**定义为具有出队优先级的队列**。
 
-获取堆顶元素。
+而恰好，堆的定义与优先队列的操作逻辑完全吻合，大顶堆就是一个元素从大到小出队的优先队列。从使用角度看，我们可以将「优先队列」和「堆」理解为等价的数据结构，下文将统一使用 “堆” 这个名称。
 
-添加与删除元素。
+堆的常用操作见下表（方法命名以 Java 为例）。
+
+<p align="center"> Table. 堆的常用操作 </p>
+
+<div class="center-table" markdown>
+
+| 方法      | 描述                                         |
+| --------- | -------------------------------------------- |
+| add()     | 元素入堆                                     |
+| poll()    | 堆顶元素出堆                                 |
+| peek()    | 访问堆顶元素（大 / 小顶堆分别为最大 / 小值） |
+| size()    | 获取堆的元素数量                             |
+| isEmpty() | 判断堆是否为空                               |
+
+</div>
+
+```java
+
+```
 
 ## 堆的实现
 
-在二叉树章节中，我们讲过二叉树的数组表示方法，并且提到完全二叉树非常适合用数组来表示，因此我们一般使用「数组」来存储「堆」。
+!!! tip
+
+    下文使用「大顶堆」来举例，「小顶堆」的用法与实现可以简单地将所有 $>$ ($<$) 替换为 $<$ ($>$) 即可。
+
+我们一般使用「数组」来存储「堆」，这是因为完全二叉树非常适合用数组来表示（在二叉树章节有详细解释）。
 
 
 
diff --git a/docs/chapter_tree/binary_tree.assets/binary_tree_add_remove.png b/docs/chapter_tree/binary_tree.assets/binary_tree_add_remove.png
index b7922fcb3e7a364f2ef795cdcc8108852c2abdce..d95c48f078fb4379531212f15945476bdd1aafd9 100644
GIT binary patch
literal 79400
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
E1C(Ef#sB~S

literal 77839
zcmeEuWm_Cw)-H4!f(4gg!QI_0!QI_8xVsY^0wfUJJ$Ufo!QI{6-JMg+ocGMU^E^M`
ze3;N&)w!rHcGcc{t#!*HOkP&(9UKlE1O&u832|XX2nZ<PEoc-51RMkjBq4zVq@$wP
zM~JdvyglGQfhOt_rZO@R)WCZf2q;KYh&QjN0ACQ0IRE(Y>qjIZasS_YMM%p3dk%2T
z5OWCdKhB4M&;*XJ|MY?H*U$X(_$CwbUsuco{m<D@5SefO=RIf?I2*!OSjY=Fz}ksx
zI6^=mcD{Z?{-8m`1;z~_AuOcq26>nUo2uMZ^U`HN5O1(zpbiE@q1%1xB2(B1Ah!u~
z&mI%bQHV|Gq<uDG4PzqjCX=hGC#7yF9DARz6GamcN(_RlEU!FyV1M&+GU&fPzr->z
z;eB%C+30)IQSei%&SvVT?UnM(PbKG~;dDMv#8EO3G2wr{?qoA<?lBf?EN7-mwOkKp
z6;$1`xE!Z`HZ>(73pH_w8lWIU{^zR@!{2zSQt|Clao}`m6AtU=(R%w0kE{K>B*&qC
zY7?uXCV4-ZCBD<PH+^Xp57q6o<U;{Jq`|_1|M{{YU9G9moaJ{tS(fpGhpIQ<Qpu6k
z`~qsS-{`(Nn29C9&bn!k8<^QTwvjL&Zxmxw6@~rlRfOB5+KM$bXS?dPK>2SLC?r2i
zNJvzf4mI781{N#(X>2z+Z1tz{xME^pd_$QpSMr06iBR&O6SI*)jF6)gt^4akA(p2B
z$@Wx3oM^W3k9o>mIs2cVpWj~{)LAdYUyV`0OO`^|F4Vp|O28WRX@;xVYs+8vn9?7Z
z-)p0iQp|-3_507)WVm2J@}9CDGtr>Qe7Si$Wt%qd$G0|<g$fQrROqX8TD2vbHQ|Qx
z$zwhWPD>)B2K;@!{B&ZroNEdW-@;M;G6Tr|`>>gd9%yd1bXN1_-rQ`nPWm<r)#ggt
z+J{5_cG)`b7Z~OlG;Q+sTu(x%noZ%h@h5dA+?FUrG&zY}m%{%tz)-<>u=Lhutk)t1
zq>~E2f(LBoW%AujKXVuRAH+u}c*X~x1X_)c7FAE=>V7oU%idV#w4b}suAyNLQ2%Ch
zw6K{g<hv=IcHc^&4q5(ytjun{=PMP+E<d&DRX{AXtbmVZ5L!*a%LOm0g^ey;Y_rD1
z<HB<{+Ak4*Gc<B=lSO{e7)KiFzKUPp5*fLb#n0a^$Fsk3Xgpg%gJEK~UhGFR@%%ZL
zsH?F9{dQ#TRpf_px(RI<nSZ^SAB?eRTb#@UD=d%7WV_eA2(PHV8u(k_op7JXl(QMh
zk&2&tn|mu|L;jhE09y4*95ubUwuEZrjq2ZT1;`0!G*;b&H)r`<4e!e}!zBll_{YK(
zoKx7XE$$9g{5Y)VJHG&%gA0GQ_@<#^U><hOu*rWv!$XOh_CGfxuoBr&#pPLK9>~5&
zFk(@cE@ihl95}7&G`eJ+CZo8uf)1;-ZxET5#lh<elD~?=<&xCD{r&RYt%lu`K_XiQ
zd1be0;uIig<tq8ne8@p|RIzCE6d3&>vC}NR-As1ae;uro`#0ktUd4heUr#DYCGX4}
z_h8eWaQ~Lu4r+2fP?fT#LS5dBXXTZQSy<OGuH-)cK=qff0t^Zpjq!>_2)1T1bdx!j
zfyu=(L-!q4O`ZG2HU`{j6h4pJAWK5;LsU?60BT1m3+n<&#3i|s`hSK9V7ot(=@(Jr
z6wbgMpeur0veuGSt%~R^7z~wXow@M(%v<B*#IeL<ez?&D3$~N|?b^-+OJm4X^fsWT
zky}DO2(O78kqzlWCC1z^8F;RUXoC2Qsk_Gyl>X*-2ax-f?XwMesHlaz)L{~u0yE&G
zc{8YMhgu-Lnoj+9_f3Rm2S*F36f6T_qtn(-FVyuxzkE5B8UNZaA#GqlasTgrjl;*b
z;zIJ<KMv=Kh?Z0|@q&)F3fFrwV#LIB=Iu%e(tq7zkSM*dkV?vF`^lMg^K==Qv*i#A
ze5h*t_W|RUOk6)B;V}OC8Gj2H&aYF|no7ZRgId><HZ<t^jf+MnrOm$?!k)4I=6p(2
z!91DYZga)^s+4V{l@V`Ue$U$tkhm8A-L?{rfheMZD?zg=chLGdp4>i=gD#c1#B!7W
zcdH8-3#3~*ZQc&k>I+*fWe~lg$ka#mHz(?XWQ(0W%J`PbAsW$_XV5YKW|WDj;-ii?
zG;K_!(Vc(yb0-*aNZF9@<9`jyo#}q)tFs(ge>0CUh>%omd-94n|C#)d{b$i)KzI-2
z%20nzMdL(-P@MRZk|ck*6=YA4qMy-9V9{S6ogg<j7oy;kg!x~uXDBBKXLpz)kMY+e
zEFJ=k-HDRw>wo5&P{Bi3amXldw4%QZf)KQa90N*4B+L72N(toyZupn&N0q;1X<<Tq
zVC)lFxvYN;HNPl;8@`q)g!}8m&HV(7ojWd0^e@|r@EW+`o)%b@znRScPS(F>?Z1=t
zuch<fo%OGM{@<PTub}+jF!-;a{Qq0d^8bvgUTNHiYum(R)Ex;v>mL}<^VrM7(sd&u
zYPny?lS&v)<*K@8^`QP&%meOb3dpb8d<1+z1=AbTmMal!)3BHS^3eJs<<?qKayYGJ
z`}B0;n}Mu1bhJH`;(M7xpyPA5<+|){#@2T!{;!Y$q|+h_`MUd_e_sC?mGiW1eyGuU
zq4tPE;I41ID}u-6&}}a-fp{>L%hBhygFuyG>d#vOZ5sT>`^8J;f4dT)08m2=N4qG~
z2@|q|E%G32XDil%acvU0oh>f5hfeA@qT=ba6y>aXEoaI~TiOq%ON;sa)Bhc3p%Vi6
z6>4_3s1j!LyWl+>WBhW)%j3>KJe}oa;TXa5X$ZYeL*iny=Z(+Rlv;85r=^Dd#UhH_
zf`84gd?=Vzl(th<Elq@w6SP~rUE05>x7M_ORJS6Ee>7D*)Bl4;=eOte;h(Yt8(63P
z$)764s`T4St}9Pd<vumu57#b7^S=_4W@gIuqL1pF52g!8ySlpQ^ZwW4CypTpMrt0Q
z$c%#QUkxLj$~o3}ciqt+!4ZOpFFBghHKnF^)ZF}he=x%TV1)$$ZJg?r=ck94W7k%r
zEtaAaIp6yU;75_xZ3#LqNmBX$yW+`xEotsc;+T0s2X&=-^)^Hq=)VmfJV1{N72cmN
zf``JW%$3^(Kts5yU`ZUdlj-a@Egc2IQGlUf8R12fz@*a*{EGEJSHw^UR_~M6?}@@k
zBbTP6rp95nN`!qJ6C<#mtIX4F_5c9KPO2lKxh&t+B!Jz~97p(Wq*K_x;>mJtq1!SC
ziTrz^L+Jfl;+W;d`J)LAq*Xfgw>!g+`Y2%rBTDmTz{1K$N@>L-9&*Yj+ez9Oh$5CW
zQGR<9Bkvc@y-z9Ks0+zSaN7>gAWX2$NE*>o&117zzp2w`mgXE!w#vI!kl~Yj8twaN
z6fY6|fp0#=KxGY}W3G3{a*7JVvHaaoGHr$RQ!sO5Nv)PLW#GplQFFM22zUR1t4Rby
zs4T-<5U7BXPBu*BTNbK5W1ap{JCzhgijSp9&Jc4Vi50sp?(E!Z`8c_D7Oa|!HO4$M
z12gw#2J4!<7JW|ppa6@O`_e+A>j`;k34~Sv0Kk@97OVq*K|5wCS8>cXYssuGtUTAE
zuUg#hDqO<O?tc9+4&YvpR$WqzAfJJxYB)M13MCkHnd%f)nUDTa%S>C0str45B7z?|
zGZu&C1fRpH*nZTMCgbjKy8Q?LVt457h;SA{Ebhx_h6%DuBr$3ttNFMe<eO8IAYNTx
zHO@|A@;p#vLxgu?j-Q0xl#1HfT((HWge=cj!FG|_lhzlXG;U}4??(z5{NAYJyQ<*z
zkE?0FPe>z|OFXO1|BS~k6^7EeWxXM_n$~ZxHS4?zZ0b@v?C809Z}ViP4I?i5njZ==
zAT^XMf{NSFq#)@}83gHzM_`bSW=MNQ^-5V$5@OzHFg<^IV9WFPGY^IEAbPoSqDGZa
zLpNDz5BIeC1qnc?E~l%1UhZdFXNkN<h2BDT6hovyCE~Zj#@G=&9q7Gy><p)2+NSt(
zA?#tb-imybw3#D{1TAKL3W<}8ouCl~XG^p#FcA~+;YyyIrgs#7pO%65K&v+wQi|Ne
zm?H4FqXY<m7&-9nnXyb?0ra~pdPToaekH`Hu#7mKKJ$*41E=&FVl`v98My|M<>ys~
zY86$c%E3~MUr4R)O=x??zwwsRR2!_cMSUs4=KubK-WPUtdw(NZ-~)>(!kmx1I|}FH
zX@`Qh*+}|VM_L<zkl2S~gSTtHYkPUVX??jY5IBQL!=#%hQxycC|M06bI-JhN#ZMSI
zFp<~epxd1aoFXt4R4fN7d*M_+*YOzsSYKF@4%RK#CGx#Ju02K*83{BUyjTgyD5K&o
zt!)J~0;U`=39qsqi=O(ACZn3TAJVf&?54URMVmnrn-asccb|sxX&V@;cLOUGx66AE
zVIS{Ce7g;Puq?3KE<Z}?-H*dkr25&?GWW1xTF}XfeZ}eO6HPUr%oO?po|-XU<s_?K
zIbLd9ah}oHN%ypIcXz+8q<V`IN)E|gxWn%~e9yrxN`CnLt=%-=xdcX01}1AXtf~@6
z?#7RPlPQcRB3#kn8(t!#Bkp7bvL7&^f>|i1vN+>eeaVWS_57^%wL*x<p|KGO*9?(9
z6eHgm^Y(YyaP#-2L100mY7wRoU)lUYwfn-WJY9vvwZPM!gXL*<yukiEkcc!#9=%^g
z#kvu2X~+gXZairbBk)GAvbMKB0}>18{LBGV@<!A!=LUkZ-hltrAjgu^#3v-aK&;&b
z+t#PuoM;y=+ogu9WzUl*AciiKXjH9rgycZ9UXDuz>I4KrNM)8co%aI^lK*Zq7B<?6
z2Bbi~nuaD_d!I}c;4`@WZlXl|ygIX4TrT3;QX>zKAwQ}0dl(RQ1#Mv6Jcq&XVqd4@
z;=Zd*S$|K_P;#T0bBJZ85eb%S`&kICNA^2%2H$QP&h{~WAJO@NwQyz(iP-uTu38w{
zE{8lS``n3uBt(0ik`rpG%NS44H$V2{w`+@;!Z~!a1NDkuq?WzdSOr*0sDc}OXPs!C
zH^*Op-2ki0`(yIiM$ZIf){U;~lJl*LZj&36CXE>JH`+hl3jkf5@wiC=TYjJlK9BUn
z?O^hgV(c?zp%XV#|9POw*?n^inFZsakFMV!iON_Z^`3JZTUSL4EKK+UQ*Tf5l;YYX
zCiAq<-fSc?J;oSW{c(?XuNn<*NT5APo`k9`Xte)#dCo%C+LX_pjFm)s>p9c;r-^*R
zy2zN}h^^7Mk0ZSm(M%b&;D>?56s?E;0o;vu0#}nti`hg*hh6fK(KMJp^l5Y(oT#cC
zmgC?e1bxsl-&Au6`S#esj_x9%P4g~ffA$ccXl6^4BFxtU(j+CC9bbVfZ&+J?=J<vQ
z18-7q@^`-O&>a9AufK~!TIV{Nv0P_-_+&R#oSKIlv~1ZxZ^SQYW{GDc^sG?kw7R;g
z_JhUdmwMqKf5e2GKpJa_ndux0^qS}K?+`6ju?;@UzVBq*O?A|M;Ul;pqR6$TlJ7l^
zrW2#%?-|HmGa0dL+gFO_d4{E*B~&Q3^)TUTzq-^CV8CL2QGMvc-#&>pK>5t#F?K_%
z6%Hh2Qw=O-UlK#tu^&2~!37HHcZFlPF516^N^{>%0*LZjRHm18Z-^A8I-rixYW85W
z`IYXr9)`TBfI=KY15z<>byA%T^!}xvTY|$CD-aufJsIE4DD`>Yp3~bw@(=nyh#WRl
zyLpCdgu2)$#IH6(k2sTwpP*p}lRu7KmuV<jDG-rJU}Xpmdyv%uT)<AeZ+gOUw|imQ
z_IVMrX*t%e9ktxfmB7h!n8}DLo}v0km#RS^tQho<N<bONc)l#KoGziFqWXPUIe_Z7
z`a3)k3LdjWrx8;RY9N6@PCQc!r56{ptULB~Z8vk&=L>F!`(D<rV!U%0!geC2a>DLb
zP6e<#z_6o^{mH0*T*Au575z3AT$p0;3Y5hABr&3|aaV<PRD`LIK0H_tBivSqpoO`~
zGL`M?beRc4^qgPpjO_I4EqBE}0?GZp)Ycn5di1@g?@i-Mjl~o-(MXH;!*{F0*<ZlE
zg^L~}OpPJmqQl(ii>2^A@1sEf)7O!k6&go{K?On~(tq&LDGyafI6TIF5Lo-%3Y|5c
z@88ngW+U@fHQ_Vs$A{b=&yBAfvp3)5*CVl6biK|*4g}CXs5lPzAGi&dlly-N6ZC?0
z+j+;g(HBGh?rTa3)!EZ?Zk)EKpOT?ME)tlLnK9epft6YYFUPBwBZoEy9LvzIe@6JG
z$}Lfj)-14((x^F39HQVtO~-jE_?;)dg8owT)wGtz%VLGWCs|(Z%h6A0dWDm2T)Vra
zb;};dzr(R(NuoH3xn%m^^YHdP6#BkAFKY#f5GsOqF~0R&g$FLR(HnE^p=LZ?&Y^jv
zf96r5-T}{~*xxp6v=CG>25Br3yxfZApQighyAOZ7LCvIi+!1(jzuQV6a2gd_zO`rv
z%17GYY!;KdYas;3lRuT%sICCYTbwYDjqEXe)OtLG=k1s@zRj%em^JYS5(!-0V1^%(
zgOLCuHdwz`iUY$L0+wxd!X2@2W2xwwcAT4y@`1y50}{RT9ual3x_%d?cDL2RR_;nP
z|2@pg@Ed3Z&XcB#D1m1;<&})5L$hX&t0K4_B%jkah@X<Vo%j1FGExu05k&a(mAzbR
z&JI3LS2MppII@|K2bOld=Aw@{OW}gTFpLh_9bp02mV)dyE4SB+buc+k4fJF85;L}9
zU>%__AzRhr`<AEc1t271l~;^*SFdQ<{D%5sca^m2?>m|)G*vLBgc1q@3YY9rxI2n3
z=&O&G6XKJ-)>Dk;R+|ZqeN9F@&|ayV-42~V1t<l1U1wg_a&KW99NG85>r}{A+9A<-
zY)0Er#-XW;_j=ZdilFB6SUazHfme|@N+=>^3HWns?}kUpB7Ha$^AGOR<vb>*u-)cq
zHIh<|;G8!VcBDUlfF9>9%b%|6TDOp|E=B}ivLoo{7fNtB*5$H13>WHb%U^+wAUaHM
zGHQ@&uM{@0eNC#i>lIB8yG9MP*y?M(=|y!F(Jot_i|_`LLc`iqzlS;_{Q~SaT~vK|
z=qra~2-qDjg-H8l_1}dfbYBge2?B^p(e*dbp3Tk`6XKXx8BWW6pALXRW_Ti2mU|Bv
zj&ondaW-n>LL8*(Zf>MnE{t%vUkTMWizqKtQ8+vP8dK8!0F5^XklBe@U+`^QaADV|
zgE9r^tbeO<iJf#kNpETHLgkl<iOEV310@#$n9;D}v2zGk@n<M)I8zhw6n2|w!^f)i
z?ev;}td+7s^U(QCXd+)`?#92^%Sp5U>G5LZuG1Ez^)dB*{SD9U>X#+D=Q5k7vu;>4
za%9J~AS|B~&y@}vUfboS@o_~Er?wpx2D1MxYK6wf8Ak^iOGz&+7K`svkWrcuow^@V
z%8bxW?ny~nVN_v%iXu{pFseSOAl~L@<^gBuOG%KT^u7U2(=>FAT(Xa0cVp{r3Q<?x
z6H|D8O2jl~kNv=mbSqW_*ZT5wa^}4yydHl#n)ONG@$?gx#A;CgKv#uCrx&;(5y01g
z<oR^lBfx)9QWe@+!0LlJUv1vu6KgE@a7+g!Oh^wlmI;%R>Qa`aYGbml4-G%!rrj~+
zve@8#6QZ1$FS8+{Eb7C48;giH#t`3$>OYIhND`camiwU=kJ|#nVIX}E+S(SzqwzZU
zc3E2Q`8)v-yM$|V#G<=lyw<}gDsg@TaQN1)wvuzkda1z~06nbHs(2av*7Ma3&aI4^
zmW%aF>1Dk=cp7vXm4RBi0^5m3xli}Y#{G;Gz|i_&uiL3E;dLz5l(pF2h59+G7si=#
zgl=<=>_;tl)E&L^|AvRJ4reE*hhRbj3X&i+kVS?8h8Do84)fK@G=F+IW)&xNt3Uqk
z;iNSh^tkf!v;s)2mzXyxE05a%jP1&q`dN@J`8b%w!i7q87wE`p>=_~La~7dzwcPX@
zsAXn!T=D0byA5oEsX7i>pT`qg;?BPjixBRBQ9WdX%_{RZn-tEaA*kBir!%?A5R12C
z{P1hN#toRV`+o_lU`1P*UXj6eW25V%wd`|T3coT67Gi#~!B~r_ga#>OB|7v5dFf3f
zWc)0N$(RTc9)?_rzF`i*+On!U?0-Oq%WHf1u8T|nq6Yx%%f4Fcy7=1L4{rMFoniDs
zDv-5sQjleEQR|Mfg41!S974<RK)rF2!r27JY-EO0KBtgl^~^?T(?^iQr**zFEfOLo
zLk5(En+%Y6k_ucYXr%fBStMFIydO!j=sZQYnJy4VtMxyB4Vs~``dt#F+v>v?#0@pe
zYm}$#H_+d2(|n~W`;qv`ydce#qOdBh9^eo946Aw)rzQc?qSm;Nd}~t;odooon9x$P
ztQSl6x1t|>LFt?FpH%>sQwn~fuJN9@4yhK{^n0^EsKes=Jn!CO9MO=Td8P<e8gLy{
z$_%Iyc1xKDD%s_7+^{JeC3e0)7A1-_p2$wOQ*76du<2aKvPIyr=<%2gJ1b2FD2at2
zyH`{`{^ks50oa(-Uo%wIz{GN(Db627`&^Qsufo&UL#S|>fJ9z{GwEe&WxjB(&bc(g
zKPK#VNz@#-)lE57M~k>pYvD62pB&!2^RB-$B54Qy7SE%iU*C{<(;FT{!;moC$2;QR
zuj8XM1}$?5aWXEMS{gqZqV85_YGG|~OSE>X^52$toHXCe*1(4Y2q0wy5uZEN>%1=l
zi@|3*$*f*vscYzme<j&yiF&QpLuWMWbH>hKQipXcxeP6hEeJ@TE#M};0^m6n$!0F)
zqbV-se?pl9GFmUY%p<t!R~mlqANi34xJzr#)1Th5*3%V948O_D)>(Dq1uvAhql|@L
zeFD9ae$HRmDZ~-kiw0<m1M67n5+O+G>k{34&to%YC0fZZ3_|c-#w94;5%A-wspEa_
z{3#BMfSQ4!=M01D;pQYG^L}0nD583_rEecrUikC%ub=WIAXe1O^Oc!VdS5ZMgGfte
z{|}J1{1CpriM5rP1!>pqdihC!Ki0MRLQmkbN=vb>0^bVFDgyKH;xC_tU>iCw1~F`a
z3`56*Jb<>Ajp=XPtECnCtjQ?l$K{pg=%KMT7`#mMDR>nMN8(g_t4YxDSfSPDN!~9k
zgU1zsL=Q{0UK_Z(-F+YehhC!8`v`W=eyRfA^InoZ*rISIPX`q_3<i(_A+Ye!HHl74
z0FCQL22T-6Bmbks!=hgEhSbk@2W+GnX<Ix!gZLelJ12O~K@4-`#_P3^B)o4_i^X5_
z_bXs3g&`e;y|0O3NHrHaz*wr*FQqQ)oI+l$Sm8Nos<K^aNqzDh=Gv+F&P8;_bE5p{
zQQ4F<5vdFCk3Ane4*{l)3_8W`qa+V06_H{cF|sQNmam|M%HDRgxBn$bhwR%A#Q+R)
z{{#Wgy__zz7w%(*4XhTm7M`=66$WznY5M9CtGxB#BaGxG`d130H`vcrHpc5w^W`uf
zN-yK;zJq{2?rY#w(}9Ob%7jzhR8zK?IqG{}H^zC}{?6IJIp{%u(OKu0m6r$K_aOk_
z_c-gqiglYQ)1lH+$c5R&hO`~&>)ULZq))Y(uzsqtQJO~Ao2Rdr1|VOQwZWE^M@}pE
zW)WSnZt|JpC|=$fw2b;4;K;ZY@iYIEr4t;LCg8FW_0>9j;r561NB%Ok%Q`7JN|8EU
z5Up&>Ny|g%AKZBNHe$QOUp+PpwO@OIV0#)iQ#?LC9w$cZUZn`A`)yK$sW!1;AC<hP
ztUcDm*lFSIj8n)>1Lm~VByzTyVi!otV9O<VkWirjRKrXPz+6)J0!7orrIr~hP2?k2
zy};)YG!PR1?dsuN71t2Vjar%HI~-O@Dk_6D){r+jL{-E%UrrmG541r*f*XMW@UNS5
zijPE!**l!MeLxqrn&^~foWMQW6>s%w4*b$4Vc9MPiTJir62<?KJcg0teR))uM6vlF
zyOz9{8{ZeRmJ-gcI)FNb4MMGQ+!+RvYW97lDEFQ8YT#u929V;#ceysyQJhnLeP*Nc
zj}l?&5){9fH-i^2BrFpKh%;n=LfBcx;ruDeo}Y0-@q1d!vYImR_uWo<qPQG3oi|h0
zM+?>}jv5+sI<8AsmlJXqUb7Vj0CPIm68P}avvcuycR}ENIfl(*s{hVrns&(%QsC)Q
zsmUyh@uII!Vly<z-M0lUOz;x8Ravu)(DXzqQit)P1!*A)4+TZPoEh@7gx)kd^oSx(
z^Be1hS!DQM9as)G$4hvezm0kjMXmbiB{~ws$hO}?MmenID%G-8&c~KUQ_1mtHIhNw
z2I~l*^)!f^62LZH&s(~#c-NVPa+FXh<tJWyZhjM6cAAi(YJJ(s@Z~382Z(+DI>q$x
zI7Qxg>6dk^R&hJlp+D_ZXf%po;*W$`JCUKvs3b41RC+7>kj&R)4lCKZu1S20+#p91
zG0eQ<6xYZz_H9}Vy^i9-miP3d{+8keJ;d@-AcTn|xiv!@6M$=1uN!<LPgkYjAOOqh
ztTPedV^}%}&%#hdJHbb5^*le*!fv-Jc-XMp48R!`$)kh>kIP;AgVMTe3J$B;Q=pcV
zK@Kwt)B<oCpezKs<;T<4uLb}`pAn>Kz)wIM;LMcO)k`~#w-F)a25XC<<9{pq)+teJ
zQ-vcr=1vO5$!(2dD{=c}Cz^l&0!)jSaPMR}HY9x2pc@)-y4D-EA7P3rt3jO?1IySE
zP(={`KDV`(rLw-sF#ra;+*~M^ts)uo@(F$#U<pGAd}dRuD`gM7E!H+@$~WB%hl`pN
z`5Ow)CGW()5hKfhmeW~um-07$+Dv4HIta>EWG`~te;+b!nzoHNyEi~vrbeZ>gd7Mz
zQk%DJi~R9~1#{}Xp>-2f_<mVkZv8Q!yV%Hn+(MHvSdTA^7Q{rpdc>t8h8}SbRPGU`
z4j&~UT`19e!~I+*d>8La6pQa#BpSb$2yV^{sBbd9Y^$Xyr@Tk*{c?3Z{jP!QkK0xF
z>%#3`Ef*mU7yN+ok7dvDzn1+$)u8q&UWO@^YwW$uJlm2dVIYq|y_7^kda1`Z7L(HD
zO6~#TOOGosW2gCw?N#U{D-6i%;P#lz))FDR#P9ra7*;V*uh~#=oZR>zcdA++g#8+o
z!IEtYj?5L>^)?2XU3ZD@b(neaDGf3NKcN$Tps%jZV%iK3d&H1|renRV+kV3)U0O}W
z`U)RYuQ)$w`BJVZrN?B}*2!wpT}z3E=w)w;cZCYVfNzhxG$F5tVFL!PSTwTX%``_P
ziglR=uE!4my`_d2cvMT$+NBQSvUsv}N!n$G+0uY)5vN5VTRFG=mIr#sIuNEBbQQk8
zwsr2uH;1{N3y21A?!OnTE`}m*?8V}+uH?zq#Rx}QJbj#LH__UwGxf&1Pb?|IUdftI
zZ9|<VR0^C+`LU`O!5Xz{oaI0a3UPc+XxHP{L5NVnEYoV^Mus=jI5MZnm%-(u8;~yY
z#pfy=`Dmrsu&}>Eomzk=tHk+3MTSI#@YwQXPkPndF#xQMgiUGOnh&)kE;|w6Uz@-T
zn0mwsfqS7#jcL2lYHg6AC~c5gS)dF>$b)z*R3mtSH*1d!$LM=U*@hX#53|WibmOd^
zH<qA*8ZJnLyy~^8t~O!b1k@8cUV9h-_~32nu_I|MS6k$fdVjDTa|%4GUxYEEj@c@v
zt?xJkZP2)^m*uD9)V+p~6?HQ=#ub@jCQMt~wV~4Z&^e6E43Q2w86S9m0ASD$MzC#r
zM*8dK^c6cwh|+vzyUS3GEvcHOdjZmG>Vx^>SGVJ&8qNqeoQ*)S)8gJSPRl$|Y=9gC
z#fi`lr6`Jg;o_gY5$VifRA=x2?TY(3tDhGS6iXqeTmAW4T?xRJB4RUl;%-PK{%F|f
z{+a@Sk0O;~9Dq~+4v=r4FArwQ3k!P_9)C!@(kEaeW%!)|<%s|$3$`$7kozZK&2^hB
zkM{kvVWD67MAc?*{?o0u4^KT(RS4<CJ;0y_n}@?63u*d}lI$Q()k@cZ?O?G<>15iQ
zxok_zwwcZ6(e31*2hTC`1nxAM&C=&0WrbF!VNz=p(4ky+(p+7R7w2%XBkbmmm&%7y
zY6hy#9@@B_HQDHG)E0BS?I+gnuZ$ETc43kjDSGLOBYFlsDY#L|rPikfjGlq5!A#Hv
zJVUSy5LJci27NG`GMRZU!WxDIxgJt}qwD*+V|v)wEJqoQ!ifD|$nJ1}PnUsofq#K(
z#&A^djdJqwn4icfO+AJasJ*PWLSNm8;wdv53E!x!U-o%80#N^A`?Jq7K(v2ueeVO1
zB)b5kWwYGm4!nS}UuOE%4H|$zMn>j+Z(KI@K;z|LGr(bc-?NDnyFr()b@9FYiqA<s
zVY~>Hl0WISh$*<_LQ(Szxp{1d)|Y`Nuls2TV4;B5kVJ>)6gIcXU@6Id>2OtszN-Cg
zWW*t<&L}X1zmL#X_@ydm(K^k$cWxSbM9wn`!mu&O_im0|p;Se~eGb=AkATn2Y0gF<
zTKgQw(`+~uI}p@l&=IUrW%}o;q-vNOpmmDgJ^~!OY%=TKtWosWN|3fU2BwX=?@XZU
zPMH>qL)+@U(*949)ot)Egwc-CPvcCQ85`rm6n<9Z2rP*Y(_OuEAD!mKz5{vzGQjed
zPz8-|X3Z$cR(upoKY^Nu<8~2ZTrHlYzPVQlQ*NdyoyZH_>~^<V)63l)^fWLnO?O{N
zT+mIws%)LN<y-`0VpFJhxa_p4sGsQbG`<9ry~8C#zke**n@~N{$xlBOuj>O_&9PX9
z$z+g1rXdZ;eOKD%?QW#(mVqbs9fpd90QOvvXj=)@WvaRob%!U?VJP8S4JG1P%Dqrh
z_*cVKJ|@_zO)R6!4=Lg;{Jy9Rp306Nw<qGPQiL{0c0c}ZjuYufZG)HKTPxGeS3Xad
zSc4pouOZI3?CyJ;<}?L#nyq$fcV$4#PWKo!FOAUBvL~Rs`+OCz!jG9|qMGU%c|gmn
z31rHz7?S``W&u<yU)`t6JsfG{cVtr7zr88WxmyGnezOekZD!IJ!20@op%AJJm)lDI
zAqt+O#MAydk^^hde!ZF7)%1n^Xt5Mf{3}dGE<<Vu1IvQ198g$6jRts*3AGzQ6q~9m
zd6m%tBKtYSW<o<LpEeEePg+}LKKKR-hTDv)O$d#?^AQc&>(cPs{IzL^JWlu5i&TE?
z&{7P+G`-|A!@G2cf%na>?dz~*F*O<GX)T8LBeJ*d6VNhYyj3SjN(nMcs<mIKz8gtJ
zFV!1u#F;2*ugAOrP}?g{m%yNR+;2Ue+xJQZHgPw;2T@jUU-i2unTD|qXVA$2ia4;h
zx5otl>4U)Q)W0!J6UYH#AKXd%;VSy(O5GzOkodd?+ucom#Nr6kFIA7J2>Ii{W}eMg
z?znEZusDcQ?d=8ZdZo(LcjJ8&Uk$d83rh8}(5$GPO=4RBAa0pX<GN3vvo%fGC7@_3
z6(9;A1B!ip5=>zzr5Qjg0T~I&I2M%p_UrrK)b)@njv4$M4!vZN*X&j+jXAVCmCVDA
z4~xi1?u*vLCIeECP4nd{b^~Q}8<<gir8jEz*7KQj8gHZDx9&DyAT?)NO3d^W@W#`?
z0F`d@-F6Dl5a2)V*@+^C=eFv<TSTK)_IPCL`^rau0Dzcmh51DO+UDF6YW>4;<I)jX
zg0@39wpqQ_@F$DWOvt*X8o+PBZau$BGmvhmHEgQ>MIuS2w=6Rd0?wVg_8_pXr~&x>
zLItKnvu~_m`)`Clvx%uNi%~Df^QDA%-G4Iv)NK4BB8-3&Dkf&#DL)`XEdxKjPt!?2
zGH+X|t6+#ym=3{0#dD)Glp<!oB7Ajj_7b-|9*>5qFOpS4HAkX?80CkqAMz1W0G2U3
zyTg#SOHv?M)k&+w$bcs#!(@`5;e^w6vQsRkXS2jx)*}ZKEGZ?a#cFZ37cS>|v}{sN
zw^aYKm}%62-_fdRj3up@s+{%YvOl?((E4Z+fk{Vc{BV6#2Z-sHdlLk{kM@)LYF2=s
zBbxVI+=dD2BCZX<+S{r^ucS6TnLnWGEZOwILA^&(pV9R!<q+y#1GdQZ-A+dN{?$Qw
ztIzIemI_~~_2YG=&OxoUqiqeH&3Zdr?x!|7Pai;OyyRM(r(GjKBbZA(&_%ghA|>Sh
zT{`5#v^ObhK6p)oNQ{gOxvhE|)@RzzO86&WSamus6Bf(i*&#rsx0FDCX|Gn^<E$uv
z$sYxyuJ8|+>(jaw&gWK`VBX<l6vBx1VGsEbp_vbkOJrXd_zJIlhU^Z?O21_Xe6TD!
z%uCR<m}giw5W?qjAcd?2H%<*NULP+#i2azEX?=Ds?!r*hHem8PpCtbBEX<3jQnYV4
zmC69JqFG?GISW|%>S?(#j8ETjOoo95Zm<yXgB5ya+7sO|Vi>1MuNuMfF0DN0IO`=M
z`PO;PdZacHP(wz$U~3&l<!ud%e&{;bK;j{bD>2_zS$pXv7p-h_Nog5=;?~h8kGX2c
ziDgKYf4R(Z?OXAN!!~p!VU1J6V9LJiur2c9Fq5RNdxXoIs&gB*c=!v?J1Xvq&~Z(y
zI@sbt&4iA%=B5tKEkKB!d~g7a8Kb1w?iEb+0Asl<#)af~s`%B6!Gvm)&S*t^ILm&?
zgTiIOv(4dLsZ05jUsej8r)it<7YYy3d$L8a>V;}%w05~T6+7K7{w$QH6TiuD%ZgV~
z)IO>Z2<idfh}2vPW+=IR9i3Zlg3EDM8XyjlTl7Q#0zV@6TtX;Q@om}r<+YY*M(CK-
zOKpU`T~-tblrugfRm78ChM?W>^Ay1)ZVU@MRt86lpq_87&sXKJsFn5K5;16;PUWBy
zx!>a1UBwv9v;DNw&o8b8?*{CKN{{4XRho3?zu7T19bI^vtUTG9TVy>2$J^Ybi*buZ
z7`Tsh?poqN>K;}?MdURER|Et2lcpBA3TZnU4RoUL>)dElRw{fLt%DJ*bl<ge;r3aM
z3O=wI!4oI3alRE+Hok-@(bHR74wGp;X;NByVZRGsJ#5sfO{1k_0_q-Vz?h@N-%pD=
zb+bFXG<?F5DOJ@xV8Sv`(6(Yo+S48z&h@9ubEXR-SMhBN_{VIMT##Sy0*&ILuJ7&E
z+eluA7l&QsPI(j{-4Vwi`b*-gPscgQQ^_>Enx&;A_n65m);BP$YwL8D45t#0PF4|d
z;6H8AM}0>g7H!`?M8NTs!P|O!IXmUJPoson<HJZXZLCezoG1rAM9#^VNdXL30@51g
zK!nPR95L7gz+jPmz*MPL-66*61tNcSwR=Rc^TFCxk<7-rhsapX+D-+Lg%;~RecJfI
zNE5Hmvgg2C`bInTE?EZ_#Dzh9YnBr0d+-rf7p`^FXA^}Ewy*n0C8z3TQm>?MwkW{R
z7S@O_ZhZsc-C#yGJf_ljoE3@p?OJHHmL9ftAr9UmDcPA1*x+$u$Bcau`XIu|Qm(Z+
z<J$A*!faUVgO&Gin8GBHWQ#JG^X+HAHpiJ}0VLU?otjXVr}*ZUTRWHMRLe6T`tOQo
zN^*QPMc)@{t+l3dE;k-(EqDr>GfX!xBZg1ny0jvY78Te09sYR26BJ#Hsv$j4zcw&A
zX;{67EmM1i0}}y=<<61L36pf1N_B^R%va%2k*@|Z1rmT>o75zoJ_lG7=L-=XH<waC
zknGOI<Fs2HH42$`i;$a!WS+$33LINT_kHVi>+)gw0?g6tIFKGzFq-d~{Nz2of`ZW6
z0;s1a%gvsXMB9yCj?;s4^+q{U4nxyyWevr3CCSxJsC6>?9D7ULV>RcV0HX>-+aMBD
z``|~wbJI{=J=vUyw<@nkY|UYNu4FiPGX+>e^xU_8ppb~>O2?Yyrs*4`e61Sn*WIZw
zq}QudBsV}ky$*L?n0oRWFq|PEhQ`N=b){@O#6BC-)Bjj5F60zxvvH<Dk#TjdR9>it
zaABEQ`O4Fa08^&9rnrs+Sg*=ZzM&e+>I3RYv1;l16HwFqqWV>@@M{5Lke)Nx<9Y<z
zYp(bY>=#~9x8e3fovRRPe)n_Z-1bHP^}vIiLCZppDso1TYfBcj5$R#m?jr0*k`~X1
z4}EZ_5ezM%*8@uI$59{n?s-=3WE~Lc^VQ0A0Z&^Zvk6>F$>8k3Or=c9lkQIq#=)Pz
z34CtXV&(Yfn%pk{lgL7&mwy=7&7$L5g!iis1GIiod^U@mi!zRD+R4(YW!inq8>3M&
z{nA#=TRi@9{CCDz`%}gPnqS~Yn(Qu{X5?MRM3$=4G`@HrV*I-2&d5{6&&MCa$~<_V
zfT*3XJ9bm68Vt;Q3-akOZh!JRyrKy)l=_N)CQMvHLNq?lw1Ze<#TN<eg<p{G7i_z_
ztMZfp6<&V6GVc9E;8A4EyhVHDT5k+q?_xL!!HEs``AyV|e3ycion;{O`J7n>(Bj8H
z3GU}$1noA{+g=|x*!8yog75R~Mzqmt^Krugx9f4_{BNMh094YhVlQ2XJ~F9z+CLv3
z0J-=Ma8FV+28_jPn8*a@h<?4_Ab3e+-nk?};yJ7^9ZI%dtUm)Bn)>r59l`GayMPc>
z15l&@U6E-%{F2y~AQKalGPPF<nWy@YF?(!oT4RjN@Tw+{X>x2*zk#jQLu6x{?UDN^
zL2Mtx=&AYpDRIoot0r}FJtT1iXr5qCA@uvR9s-udf+E^yVMrHem+N=v`nY#VID_&?
zeDMV~gFU@S1sY!GHYRRw*mc`?2fZ9>88dW;;<bWZ0j`%+t6kf8D^*_uAwwpa6`R?(
z_x5Z9wiOtp_x&Z+cUJ<jo@l|R?E8g&YFVW9B0c4iSH3|jlbP9hmaLG;4xphIf$cE}
zS2cIF87o)D@0~!e^D0R;9ydfVY%b&Py~E93@xahO7a{`|O$dc-YH0AFNctf?`9-<U
zRq@nL#_$B-rd$NffPi_H;vt?1v_Jzeoq$qj$z8rfD)Xh`-v1PvcZEJh#o(hIV20b2
zjTR#inK482rTr?zaCOfhJ{rifi&2WWjKKsOVIrQXJGK)a^~q)SaSm?t2l|NnBd3Rv
z7c9$N?|s5tm08tg@EOEJM9EKseT~+pmervLY2blAkPk~h9n97es1`Z^@i*Z)RIYZ=
z{ugVUTqkjxh+ijWZ&(R6t0>szaMu3i>1Lr!N*M-spKM@6f7r6fL_OHSGTF{y-NJA*
zkB%lGSeo&X*~N)zSulCsU5{$8BHB~c`)w!+1{r3Zin)vAV<^2=trc*GyV<mX`8`rp
zs77q)%Cv)=upB3&RIw&_VW`hQMaJ=Y6asscn|ZhZS$A;xn{zJZSzZG`aPNA>?8hm|
zVzYjZQRDSsJek(>s6g=eXd6r~eFJP`3Z~0neKgs0c^)ESCAI#H4}AcAQ##vpqkcX-
z#B*h{R8TwKa5)G&FI*8}K-BgMDqIhw{PO5q?}lu@qcGw2df@4Whq{q#xmu@HZ{`4K
ztbC=`<|cjV-2uDROzzUE?5F$cpE?U$8or4>#Z0!hfG+kueJ+-!tUf?b?xgWD)l`Ov
z*&V_Bi8@0_U5OHfB>V~Gm;3&!zjNEENe0bf_SN%6nYM-p$^Tp3r;9K~F5cI{`Dk7R
z?U9H>J`24kUTVT;4;{7JT^DTnB&cMvX$FnV&HSvvASyZ7^aDC(8|Z@56RY)ys6#k(
zo7pmFP|dm5l;j@GiRPbgP+p|M2Y>;rPSJq8e=q84ao3L)w?}5C<s$put`Y*z;E9pi
zS}F~gQk9#Upm>74Jqzgv6F72rwci>ZOfTbEbBHK2XxXrzAZYCG@vLSOD$+;|Sj0ct
z>|>z$2_Ly!#ZSq}dEQt3m`Ky_iT{xB738&O-*a_1H{sy<a8#F+=*ac(UT{eCLBx5D
zBY};f#7{pM<&%_y+8{Z)@vB6j5g!fOWT!EuIZipPt67-#=u)ruS$mt|Yo{0;D|*SZ
zfLm_I40$ijA=3etIhX&M9!tjJ^xahEEQ-h)@f)~rP8Fl$z$x7ZgQ%}JH<^g6j8a45
zk6i+`J4glFvxr*ujEfYIU_(wXYCrp|0jvp0@dtrlY_ef<z0tbeJfCxLB?*u{%JEOW
z`N)N64p$Rzb9&G>5#W0s{@TMTh<hz{fX-tlwnMmIYNwT^#l_zpD~3lW^-od>sjOW_
zhG12@l?Rc=tx;>;+q~Bpq~X8g_B*!QeA~<pQz%bFl^P})=pR^4e7N7`${BD;xTB18
zt+@ci?Jx3vV{kxB3>pMH$<yvTX==@<0I5USlX9Vz$^my8;0*uacJ-OAu{O8lHsxZO
zcBSf}_{n?LFqZk{F*J^iOkkcVpa$rA`y(3GEdHKbU0;xGR?YqN&)WjM46sZh7WT+o
z`;Y!MXv6nVn#>Dtq~8y5JrQe5nr12t+mlNpz%lZN56UD+{j(hxP?LT*l(Z6a#7}#2
zWE2bvWKponBr1KgV51Z75vNFsT0StAFW;3HreL(Z8l(_#4>wxNCQ-cqUUATgiUd$6
zPj%<yTbIBhxL(Nhnb0luC|jsSyeKbTy%jn6%IPLN<}X4o3dsOSl})VZ*9iay^mV7M
zdox|8GvLkw4f-UO{J?_NHh0TFG=8I{n(YJJNBx$dj+pt&c|z-<CrZEkYt6Q6d}?Tc
zC(F4Oc<E32xxHz38+;R_R1ZyStzmF3(~52@c@?gU^CxH}@d4U%qPJC{xx1s`T}qSF
zdG(J8Ou*S*?4>rM$|uLSTRq+7nbzS8Y-n-w*1?TcZun?b+H@4kl$ihdTL6YoY`CJF
zk<Fs=ZcXLX@8ZoC&o3q)JASDKOkispo|pIQeUU<QAbhIjX&%`-O0IsIne=tGn7->L
zDYH^92Tf`@u6P|+?MQC}3g=FF%1W_Hc}y{K!umh$9SVTG!``Y!d>}Hb!zH7ts|j#6
zD8yrI;bA<jygYM!%&xBb5ZUamfT>;y*aJGhLEzHLSczWTl8$7;tqsBwCwg=tXi|Jp
z15`nPP6@|=)ZT4I!<4IF%&-*D<MHmg%t$-E$bUzT=*II;My0FVC+*EXo|ea9H$H9w
z?E+8Np)M?)AJ!A#clEwI-zpR4y<6j;F_7bdD|K&n(9PE{Jo198gaN6+(1%c@y9FeD
zcIBx#cc^=X(v#?`mkUvvtA|Bq1G--iIJWJ;#gl%BZ_+^02<!%G8c<C@T0R?>pLGQ+
z{N7@kqu7<pVJlpp{A{qjG5I_$^?CcFx%t=Sm&799qj)EgWdSm8BuwU;!3=>FFh5Xi
z<S_j9=!#kBEq>A*D@nnxvpY0zZf&=ofF2s=b^}|Qj0ju?l#%HWWSpz_uK!-&9!~ST
z7~<H7gUQ2M5jZpwQ`7nFux0D}pf#M-k&r9Z=kYd`w^0j(=XPwv<@6NEGHh2z%gs0<
z+7vVlSc-7HOy-oV2HZv*s4Q{YatFybi<UnU$@RGCOdVkAc`s<-n3gvsl`P#ug{YU}
z)SdII%%a4wb!EvD!T|U8B~!EBz2#z<N7X%5opAsc9+`6gwKXQ9ki~RxRje6E-@lNx
zJ_3wcXMi8e%Lk9$tWvELof#bazA2jEMZr9>JUX13Tc@sqMi;gEkyXtG`=3y^y!i`E
zkB)V};Z}3uj_QCu{np1V2J0Gh3Qzl{yZ=XSP^kYqxdEZezDWIfxXh6XHr3~T&qWGo
z5k~k>)_kpL8xYw682AnW^O)Y$!Hk~o6JSp&_DJ^ey0T749XW6mZR}n5=*mkvR<%po
zGy%%&CaY<2m7?`TJssjzc*qjG+T}12r`v>cvJqtFH7mZI*lwy*qPSvWU{{`}Lo{Mr
zH&YIu8f{wWHXA0c3<}{x>v#@2Cm^(3W==n_eL{?Wrxc7c@G+WA<$7F-!PzsYA~On)
z>$~e5>Y*x+<AB_LG<Er_!z`Yqr%n?g<M?e|_s1$}KR3K0<*BWRg@O56e9Voc;+wMX
zIW82JoM&y^I3Wd}%{bmiB(QZ^1h92A$`FcNp<_UTDj~!&QO-Ytub&zaEmzz8r6GC>
zH46_OeUyTN0H2C_MP_w1t7yBFG9UwgMs3qUF20p!*G6Eq*8G*nLZ9H#HL4kIoxT0G
z-q}876t2`-2yc0SrbNY*=*x``=3tJ5&0J*=ia?Y=Q?$c}?bSS-5#4^pUd@`N$C`_m
zr#_{!PT3*uw8;xnpd*_E+0rsR?V-!<wG+jOO_4AF0Lo$&3Wiju!HCx&BJQ{5cIxg;
z`)#^}UT%pO77e8~OARL5P29RQ@zp@)@kh;+(f}+!BKl#K7+L<9JGR^V7*AVCvNp~K
z!Z)0Fjuu@E8+t%HL}0@zVlqHHsFHSKO<I4ouJf8Wf6L#rLTA6DoNN28MfxovnXiPg
zjD%@+A|aslA_iFe+1g`ss`v?wge^p<-t-w|&IQ&q3Of%U2@j~kAH%D>@>F}U-YRHp
z0nTA$OAz4s*hD}oZU=gK(wZC7PR#*Smf>zJRs9o>{iz{O7dG1=S^uN-u<cUiQQY^_
zE7PC8{bDU*WpfSNwrJ1$@iiQj7N<)jtp~CV=gsx%W|WqaB`FNRG(biv7>TG&0zTZ7
zauGcCbunr}p`K`bsbL-Z2FlP!jWkZT(^XhB>fvntDdLp4*(xkyp?;uWKNA_ou5w_y
z6k~yNPwNx{UHHeFG&ELVM?sI-*$+-2GOZ6hb`U%><~<(G*GOS!bo5HZlB;ZhBl2|D
zDBA!~+v57zd{C!G3%zC`U-t*&Q~BXyQ`OS`gp}YkI>Wo5H)KH7Am0S_jVm|`kfOCz
zn4D(ap<8BB=|q*t<;WLUhWQt;RxtWdKR8b+&}tY5r~I@50rIh%1J0`o6e{=?yj#u>
z7yzZZO*PqrCvPR8VL`wM-6v^GN9o7hgB<;~0k4sl4IqS7#r0omwaos5FsK@2*`4`$
z3wYo(Rj2?)zjXgw^x2R36F%98uA>Xr=%ykm3GxvC2TB#=s_$%Ml`^ru0Z`|~slJKI
zIl$i%`1Dq60SSk-Fgb3HH<{A_bP(I;-*y@cI>YtfAO1WtOlxpNT!7QPWyX(N;h_e2
zKU_ht1Hj0_vzTx7^<BB3=s?~EQ;9SiB3r91@a~i(RoVB5dPa0rA74#rsmf?_hb@p_
zrCi!9Ep%!5>HT_*N`vxMkI%29<JB-e*JMJS6^HFdeizG@a+j0kr+%99$oEXdCdsrU
zN4<IrR;ebc*W3qV0b1YVqXJo{`8Hn6I<BA0PzaWecDGUzE=HP{TO>U9Iz&HBqu-Ru
z6M{h)I_dN%y@`G^qko79AhEe`$M9QiIhGzyntQCfL256=s(Kfb{qrJbZ9kteUON<#
zAsPH%6|pq#DML<q4#H>;c8cC=LP*=amXIl$`>5(#?5Omo`9g{4S%El%oBK!=7TWWz
zB!)(DEH}WMGe%i&qA{^M_Arv}4BO-nw5{0>j8p6kSWFeEEQ4v^*D5(?c%4g}u<Lu7
zEdpMPWB3#Ayjp{aU-lf<9}3*@N0PUd>S{GaNS{*KssR7LVl)5Fm9Olx-brhMSu;9{
zxg))3;&hy#r)&xbYx>})xeSBhGf6)%kV??}c57Y0w+o2#qyB<bri1ErE~OH+E=QU+
zmJ}xQKNVJ&V7n>XYJ(V#>V7abfImw@TUd<l*2;g72=>sAbxMWnAYu}lqy_pS0@cdj
z3&RJ;P<WKnbdkF(Sv&ZdBSyA)m6tUhb4TqrKb{Y?-ZY<(QDy)F0c?sX_RtH^__M9O
z^4b9T>U06%C`}XQR~$BKu95lf3YBzc<0j{hcN~w0W&(}-Ma5;mw{fgyiq*=?tW}vL
z3AU=r+dF|xomj1c2?V(V%NQ<51bpfD3lD#=xqDxl?Khef$rn8cObASy4S^PhzK{&}
z$%jK0WkfEDHo+Kw^fxsrwk=$q2D7Rm?>1W=j)8`hlkCpJ3uQ$2Px^C}CbHI<Y6yk8
zSwpbNkNX(jwmtVES32oe5&IhT%UHzCu-73=T5Qk&0LRnvZZn+$_?X}KmpTnjzt6gH
z#{{?nP0!Z50QZ&QT6GolLgS|609_rP@8j7aWw%oI;%~=21lSDcX^j@AQaa7*`lH%~
z3Xz-;Bd~5&zTq#|l@{+DcKals1$W$P>St>lwMY)9zU1r^!CvtG=p68YLfx${VTN?u
zJ7eOQh_YBY@IO&9jD{ozmJH}tZL^cmc%$wDcjZ=8@Z&j++e2yH`I6(^1zFQ`Fzz5#
zUc@Dn-%Jef<OPg-Z(aao=prEz7M;{XQ;bk+^y6sxX}(FLv422EW>50p)##+iO>NaA
zsP|F^a;rMQPDlce70#APCS6(?zR$n!gqi`hOan8~p8xKQ_^qe3=J^;<1<%-O)p?E_
z2Rq}|T8`V;6%cvPU-q>GtlfSd(v`JEj23w2ynn-lu=r-4T4MVJkeHGH&9MK-@$^rE
z_YTi7d#ImBmqnrJsGMqSN^~@58stAveAMFUp8*6!rG?#Ww`N2AM8)??@=5B4K#_qg
z&^bsqK2#Znjt$~gVKQkZ{(#-{%qWxVwe<|Nyj?UCKLOweYqTAk8L4W=c=CSq6Vlv0
zl&ZSdo|K+sZ18sz(SP(r^#<CazvAOd*_UpLV%6X38DtddN%qrPZ)x>f7OVBt!DhRJ
zj_gn8@A#co+hl$~*X0i-djoXcH?ve{Rl%V)1g8Sow0K&L_7wy%Vy0$%c_H_tqw}GZ
zXD0XZmxWC@7fapqnwAj61I6S=%KG<Bt*LhHuvKOw&;4pG-}A0he#LmDy&q>v8ZU@O
zN;c>=ynR>?ANs$b_1Z?RVi2oL@Al6QLF(j2F3QvJbzS}LPO!{iwO)&<4NK7fq3SK8
z>gbwiUECqKC%C)2ySuvwcL?t8?h@QRxVuAeLh#`34!3!~bIus|e>PcrcduSmv*vvI
z!kC33y$&&0hd4-4Ec@~p<7*@~WTuAx5qvakk@KF~8;y6D?To|S7_)CAQM*BpFHTPl
zmWhOa0OkPQ;BY2t_C21{%vcrL1leR}p!*46%tUWsBMaP=0{m@;g@Yob2T(z)dt2n>
z8Kq2E3<C<hR}C~ZTLhpWC}V|Nl0O-=_D}7kHK8zde}=^0^dp{JWL}<^l@o+$X@y#A
z82H=)MmJZ$zZtAm(^3T_<!)nn&VK-z=dOf$BnHivEx+M6DxnuwHc#h`tQlFa;dM-5
ze-G|u8YFy9WIS!bUvAEU#p@k6abrS}<jnayy3N2Bg!_cCyb>dKvynCB&hI0Fnk}LC
zgi{e100qcBq)DGygJEAFP?9OzX6?Y$yx;6kn|&x)m_v5BnF*m|f!al63)t&B>=}cK
z*SEZ`=d-u&Tyq|nBjTpA+9WIX9azZaHCu@Zo3h$xSoE=xy{i^d=_3_qb~`<%>gmY(
z1BVpSF=Ls|7#3!5oWZUB)A<|Cwlk#_r<mXKQEBs^n2^HHiHKmxzLk9ZF;LBv$)!}o
zpfiJV3?{M_$M-;OFYC$V4_JJALG22S1<WZB?dLT>lSYy2%}kEO@T)e*kH0d%Qebg5
zi@%Z4T4Uv2+)Qq5*=}Z%QJ=$QCI9{_mYwFq&MA&P{feLeNTsvIz5RSmv&W7{2%XhE
z=76I!4mThwKHVG?Vms_p^Vps;O3g7Ia69i$1`|I<3{43M7j>9vhwYmSXWlTbZVwaT
z(^`>5O9x@$G$VH;V{V=F-3v$?&Eu|ZUm9mRxUo*;I#P%jcMe@jF)yLF%BFv-u}aGU
zI@GP0Hv2lWP+`19Yu>80x-l6F1syKi-_Ic(<L-Ahi#H2F^45Bt%VrZtKJxa<MQ1%F
z@0BWz(;D9#%?3O%95ymv_MP+iESN87H@W=QUxC&>L^mWGePp_z-eg4kH$I=Xt}cE&
zHsHXf>EDMCFz8I@>e~Qir~?il#YSo!6iQhzuKE(}V+T**yfcNy3@JD^aOi^!S)E0x
za!mp6gBhnzAQtwo?rEmR79-{q2~%tK4T37oaTFIG;&DBn><O0Kv{yR)!u2m6P|Jg}
zkDA3}@sGSvLXwPH_UY*PZ!ekP4^q^qHB`NiN@R5@doKIoTlHD&vU?o?PxZRzNi}6}
z?7tlMjWJC2j-faXXw`NJ%tt_(4!;Qsmb6>_8jKbjfkr{jEBsSzid-Sui{3&e$UMrz
z(*EeM_lGhY!%pgc1VwJI|LOI=CfSRCjQ`UBr<r$Zc3af0VtyJK-Yh0--n`FlG3Nc;
z`e(A(zgw~Oud2<YcHu7DpZ+aCI%J%s>Mhc0vCXOU@`e6Xp|SulUCq}tTty#eP72AG
z1sbS@s&RD)xOgB$10V^0mp7nq9X5&alJ-U6p2Nv5^#wsM|7bVlwNeX727Jx5$B1gp
zeAKP3)x<vwtjTAagurQ=PeGfD_P(`ju=R8@K%O&QwuW|LZQcRn5#fNMfLS6Xxd_sf
z<?CUHsXC*9Is~*hjs;We%WmB-z20Fm7TIDZyL`LREOn$wbdfaThWJmpe(z6IK4ngV
zWLLl=ftBV~>wTO?vy_V{;%%7TLbt8XE>B0EXdlMf$!(K(+-cY<jsFdV+>BaH%@aMv
z)XP;ZqB8QqswXv+ZRY=Y8~)Oe#dL3x_?#^<a1L56wx-BrjDU7i0O|5>wfI`yergau
zn%n^{p~`SiF+V)jwg|yK)OfaH!z_L{j5IL(5cTjR1pL<tW>r%2A3h685<^nAe<mV5
z;}Y#Lc^BS+`PIRAn8TS_++V!43AgIC=BbFq=GF-KQUb#v&}EZ2zEH5&VLbaf4E)k@
zKxKJQVrJ-hb-I>P^!G5$NO~U;cz0BTjKN`nI!i14jG5Hn!W!zBS2IKX^ZR(&)Qnc~
zUHt9LsTW}eR&?+WO1@td+O6hyb=9Yf04&=+0xY`e(?u|3`t)?#IKyr7!$}?Jw7VGG
zM&}aeFk`g6+jr*mIv$?0b=n;*ogC@+@3;!}T3huUEu)m(vqnIhHi3M*q7c5p_B(Z)
zwe;cw&A$6fg&Q$45+IxPZ&xW-5ED{pswF6S!+}*%?bSJX`AZv?RHGkVQ;w@8IUg&&
z-;|ketC{Jn);LCCz1scN!E;xqgmrUe7+aE{|6>nG1)q_FR<e=rMY=E2WkVkTD1w*`
zS{@0Pb+jwA!72>X`}Jyseh%+(<DuK)PpufUhOqxd1c#i1k$FCHZN&r+N_;)S<FEGn
z^b>j<?<1k=2ku}J8l?AXY7yFD7LAKd7a!p`v@caj9|BBO-sW$OOh!>QM3V{S8db*%
zf>%IGYl%uJXdRj0Xu)3$D?J9xFyS2p4R2W1fZ7GQI;h<UqIXTvSN%Hb7qdu<2bJiP
z#CF7=k|~C9ytWRV;qC-lmEHC``O_s9uI^?gTKQ(N$H}2OGESDWG-2BeR@<|?xDav?
z1cfWz6y>_$`5xH=Qx%o*!EOm-=lyFw9s5w5D>}e$kiIlz+j&JbaI-x9@j#)_CXtir
z%3XdSb<Q3K9&OHOrq~A<zz^n$W)@j9fNE#!FyX&`4sJd(aC%0YsIg>=xlvqN8ksWS
zH81xIx`B{c>~R#BjhZ=Lx`x`QJ(A{q9is9G;It>@ks7~fhgRzNe`bKy6G^IFV(gH{
z%{hIEJHE4~dCit=EjwreZ$^fl{c&A3ZF0cpWPZV6#065TQ!0#Dv#;H4`2<d|agi$J
zOg+~EWnez;%x1sWN5Wpv__jv96FW8)<hiH`c^An>tPBQ-8Wk|;Rcu54hH~|m4;7D;
z{1AX75(dJh5V^&WD#b%>5-WI9q;9DSu0{~@k)okbbQTPYrb(6+b5XzwH@QYy)-B<F
z?&jMAs+Z~0=d5gw0mKHXwZ5}>t-oLvdMqgwf^7PIyrt=TQsFWHlR@8fR&+-oSmuc)
zK|1McQd1FZRO%8K&|Z<eI#T<8yMOWj*Zs?k^M6ntY{}OR^65xl>?mRK<E;W6v53M2
z;BG~uG_{6%F>^4qTteslj(NRIc;K1_mVHAW9tOhMoyqIbFcyioku2}HtCSR7WV**v
zQ|Dkjh~5hf=~$Xs%~gMN8gO51iO6KNeAjIGreFJqmA*zpHHeOh;@6P-Z@QMh{cgt7
zp!=pI6yPV7pZR^aGb<nc`U#@ePoxdtH3&f>hz0BPoH+Ix+3fIr@vO8AYDcWW_B1=#
z56Dx-#9z5}HjnXtlHbMf9J)1_j7vVo(Brud!v3=Xtx*OBDMpwFrPok$xtPL6cHq~e
z?C-n*afNIMgpL8yhqyY@-T7jr25<1af^>5bbFU8&K^jF(lf*{I;;=tAxPQu4*;KcM
z{&kUVj+lXy!(xH7(aa^wHl^_@JuIw#|Ll~n^zr_N5_G>;8QVyp^LDO5#lH_;{GYV|
zfhkVoZgk{P`t0Fb>D$izQ-_59VsTMaoR}zAWy_}T+Mo!=KmSU~DBNHhpfpp%7g@Qc
z#3}@0Br=5d*>R(p#MY5Lez-UX<dB>uE|9l70Jdh`cp~u6!M^Qo5E3^`(x16v8OI+3
zE+C~to_W;Se4yqbpVB;Itmz_?#A#}3s(GHpGnYdXYJ>vUUb0ow_^q>yyye9H(>tla
zIPHG;I8CFwk4IF>%tQ1?9^%?Vo|v~wOJSP5{<J`v-wXNKjT*tere&;8Nr{-4m`#F%
z8hx3+r<k=J{+1LdeVM)QW6Ir7z2BoTMH=8Vs-ha(jLaScLJP3>=@`cdUlH6HqlRQX
zKL*8~IM^%!Pr!Eq$nQ5-ab}U(pXqEoQ9GcAyFL89`84gWObSOkK7H#6#J-hmPIbx5
z|7yKPJH`#9HZa@+&Bs>`JA4}RwiO2H&`BC5tXLwBmr3Wuf&caL%$-0l4<YsZ>&$%!
zMT1;)zmIOhh?D0Jb-!mkFwEH#DrT+>^b~7l>Jr-=>h7MzKBoJ0#Qm}N{qZe<EhKcQ
z)97yVel}Mc6baE)7v5OoUmzrWd@dbjwiC{>)gzHRz%K!!g<S6Ey37Mla<gHxk3>${
z*Mb+WJAbyt&zB(eD>_%A<q(z@tZUjrd$|s>Z;Baw#)=&SfGPZ^7~y6Oy@*T>mGl+#
z^l2qSZwGKTW4*9gv@;8w5yNhs9!#>#bRHH&btd2hbKQWjMW`)t{B-~yJ_GEp0OJDc
zVDU3f!ZX4dWJB^U&3!;2)(J;7w95+5bD80Rwlr2Mt3sG?j8Xk_m9;OAg`06&?-xO<
zVE3z#Mv@TLO`S*KTcFGm`pfk94aUQs9G7cg_aYSs%J2ToHijGca29Ih+yW^9kp&%&
z4THyTj>hDS$F1DVw`<Qq@I38$*qB&Jc&nty^L84~R`SUZZk7PFNX#0mE26@%e<a>H
zDdc@MG84wpIZP%{RxI~?==)+(nDs<Bzg_|70v#0<*W2xUweEbLN~DGysc*Ag$5}HF
z5liBIy4D;A%+i1Q{w#K4Ul#((K}(8lqwopVVxwSJ!LvL9Dyc+!DQp0Hj1I-%zdpK6
zj?@z!F^AowG@9$jL?f|0PqEA|czV9+M>{WS$^Vqd39TcozfR$CqjMpsw$htskC38a
zH6snXdGGuUjM^s2gOTu$0*RoD7l}}FNr%uxdj9J?qeN^F4a|fKs5^Aii9IGV+r0Ph
z8{is^9N%{IZM{4QAhCv_EGhil4rjM_q8N~B@+tqF?&dDKR0Qd{05Awz<VZ<@p!?4;
z$6A5e!m>++q6x0cHDC+JpCCG^Bsnpv9M%p_BE*+i`c(}tv)c9}>ODT>`PF!dJq+Nu
zD0UgYv*lTlf)OEO1AhDKJ&bR}E6BGgwccdGsD-)^7NY_HQ-FM%qx%X`OQpe{wzL3s
zi&!KY2jGzOn+6&MDPSHsINJR5ZELj1ZQ;6%xjJ`_O1|%Kd7JBr^SVqT%fo*2{rbG_
zz4ShB4Q7jqzu|qqYVk_64Q8=arFFGFfJ0e4$!vi`q+xzxeuHT>*=)PU2}{*?gE`Fi
z2McmVf`<<N=gZwmT1=BCM;L^r&?RuTWP*%*b=O^J+Pu?QX3*`J9Xweru}FfF>o+Ra
zXTqPR7K1RB2C<H`?9o&qK4fF`wuX~8)l>%#5B1Q4uFvjRhpHFFCb=veeagp<XTt6E
zVE2PpVDG76-HeMU1k4$5V5||Q!-64&G=!jXp@@e(3;WBdW9NO`<bBjl_Gy`A>~2kZ
zW`P@5H!wg_CAFeCP-r$dXQ4F~sC-R5>tTLd^z(TfY}WJAsM~bepL*j7CH?6+bm)yn
z8UZ630~GR9I-)nBRQ17_RFIsk3rsZO7+`jJc>4PNn+MH4%lE%@mYVIC&U?XWbTL=i
z>=*y?h;P<g-BkFXv^^0JP9oJ|#M6}nTH{!60Jt+rnDku)$cq=?Y3_U2^z#D($5pcX
z=sQ5oSf$_f2chRwsvBs1e5j>Y2h%}fYaa(%;Oef}h~e)NES4g*zQp<%_GLnH1p|?q
zuuHWj7}1RX7AW!mTOf>F?_WqG<lXGJ{9?b;pb`FR-5GDij-c3M-&>K3H<RCg#5x{M
z&voaX3P^gmiq??P@|E6(Pnv5Q87p7dFIMoI45@BL=3xu@8W9`t;xVdiekx=rC)5-6
zUiDO&`2eB(m7FLvS_&5Z%~@x8o-@{L!!}7sxKt3o>vZNa{+C}4Fa-Qz$@77J1TR~a
z^9G0p>A|RrG~^(^t6{=HfT3dfzIDFGfYlbnn<SjWY_Lg&zzY$DY`S4Vqa;bN4-j~u
z&ug?oBD;S2bGtn5o~Cn@SNrjLukmr&I|`k}R>f)AC~|{zfbe|WL&4|zDl{PR&GqU_
z-t+eG86KV4Xr3&bY$mIv^WKoKmS=rDq@p80s4Kr_uH>&C@BAWd{|Ha;TAl24lK|rN
zzB+7<;}jke$EA^?mN_5DGw!CIA~Je)j3EM5vm;9Q{JGeY7*=~t#O!<mHBOHuGB8+(
z;Wz?&i3tZ)gtc3=TqvKYd!4zmqK$46&3pVhi|c|oy`Khrr<FZ?2TRuSoh4d@_&;Qv
zj18~90vxq<X06`j0Iwo|EaH%80l1u3m#0dbHXoZ!kP|z=x1Vp1f}kG>BPB=YOCU4Q
zyr1UN{N8qIHMb`Vu;*5q^0Qt#9?PP%kmeg4CkXtWMmG8H*I+Y(J%HOm_7AlTM1caK
z#!@nFhg@R`2(tC~I@VuX^3?20(~Vi)IL4b;HZlrkbn~A;e7teJvXX7Xpa1<wZU5Nw
z%q1Uh&fG=v%lpZDWthQPQFfP8GkhU7!NNVEd)5F5U{0six{qq`VGT=!&~R~a<ATzV
z*u$3tOL#uthRwbK0}WB-^h3(iWSb9^!(;EdiZ<AA?OT^{5n%T2LzSit)@S-T-VTWR
zWuJ5jwFJkjOb!=HVI*LNh4TX;5|77?_T3&OS%i}-fz3OD0oxn2a8jNuNB6h+gF_1n
zEF+r((9vWu(uVDOFNeeI7h-QK_&ri~Hbk-o9C|-+O3r5ZK_lXt&g&C3R{Lt#d7Yfc
z9CN^F6(tX02-l`J?0j<8BtJvUVDS}pZ1$QM8G^e&PAihbH^Z6zp~-Sy_T1sVO>L;`
zyqj#6G(4GZl!h^E@Q<-%2|_yOCI5Jw1I${_4S2HEHqYmOc!+w0T~4TS_g@H!O^#xq
zRTf@3t@8q7-jd-H036RoHg(|-(4!#s?3t;0->;*6?51Y};^wDwct*PU`!xL3cGO{@
zGo2meFCjy<g@d3Fh3OPRB6|73P@c|HQc~L5s(~1zlj$u#sPm;CZ3*Od;%1jI60SZF
zxBm<9L6j>o=R1w69i9?3;p!N$Z%C7dqOcklr>J)^ANHlz!79apWU|-oq0wr`QBbcm
zJdcU|V9d1iLLE)*wUdOu{nyQ|zbQRErY#+y9<iJ|;cs8iD>4OrA0pM3brb--?;h1*
zfJjSa?o}Qr0pt{Y$&$cMvBtbd4*(!yv(?s98xTi%QY=<H-XezwruGv;4L_4{l!*?B
zvKPN88&Qix+@oyiV1;C0)%x*Z3ha`4=lMVPK!JJurCCyR=EDpKqyVl3lmX}zo;e6z
zmPQeXg$P6KMh=@bCbXV%aX|s`^m~lWdT!3^q*<Kz#CuzipgC=x5tD+vH?#K`;J;l1
zhFmnua>T(5;(}zxkIV#bpnJ78VuS%8n=Rq#eplx}o!~aOt9Tdy4oyB<zGemU&%IVt
zZU|uAi1s1|1ABTgP3R`{SAUAxPP<lj?ea}fFJN{ZiN-N;<pR)dg*LZqO3fxWu~V=s
zj%c<Cz^OyZ3wMx86$FHZx8SUg=86GLc{<|Zbjxb|0W?muwQb)ERhMd93&LhdNVI7a
z_<h<`aB$KXS+J*|3LakW%O>QS_4Ycl<NbczJ%~Z8kG{6pzgPRN<J;`dT<HIH1W0k8
z32yPF<bzUP`@{~VVl9<$-s%qxdTghF7JZ^%TVM<SW{$Wt__#A5Lf5Vn8wJy?llusX
z`~)8X)_Sr?HeZRat_xVXAx<iOc{2yx&<j-DjE?#x=K*)w=y#C?t#I`Kp%8!+q{EJ>
z3cpiD9+J9DeeZ827e))OGO&B#Qv$FhkMvhDJ6=OAQ5Tw`O$LYCFK}NpA^x=3Z<Z?L
zQQnx|nt!AdxH#FZ{hA_vXf1O9_t>NfjZ!I&5JZ3(oX#}PDI&36LML|qE>}OM-dMuf
zhkltOSWvR<1v<|73;|fe*#H-9653gdQXzgeg~wFH^7YI_g>%%jg8o%9$8f&^&#CpR
zOzeyY!eNPgPCF2mVY6P^Lh<bN2j#*VGXSldu4hk~*tAK>f&r-L-`1aK*!wQ!5|eQ9
zSW6)@SgX7Y*BjO`+C3L)fZbRKrF;EJY6FmAWPVv3*_@8VPlj@RA)4rajZC%5zjx~c
z06#t;ZnE=3gkGJC`Kp(qwe4~20Idzy0fn$0vOo(*Dg_7hzHRl{!X@j%`+&zAjd?=C
zK88Tx9RL!9fRom??nEBqn^u$nn;v*~2Y{@?&2#IV1E?K<MWaXkg1SBpXn%k?v>0I=
ztf8F8Rsb}+ea%YIaC1U7EyW~wC*Ydx`gnh-FHuYbAdPe%RaBtA5>%969hBfsP+%^{
zhCJ!rsIJFalHt=#w86eAiVTvk0pn!3bjH5H&*P+N(?;8FG@i&!mQn!3?!k~9=U5LA
z4=!Q1`WKoEBHbiZfGy&iT&B+?@JHzvGLVpBJY_n=!t34Y3$m82g`k41`*Ju+64xYQ
zM<G9+961>Za4~ES_XaxB{kV>UGMj8xuYqoADvWxs21%B{K|M0%;&o(S9zW%ium}t4
z9!R#azM7gXh3RQQ0D2esB6;YCGHL<VQ1ZCap2=~GVy>no1zHm+%RjRA2gEAeU=x_%
zYpH3~8q;jtwC(pT$22NyH+>i4+CUQxVo)aoX6}F+e7iqHwrTf1gVw<)@&N_R28R2*
zb(eWY)&86$U*C}c_Kg9|<8#1IkOhQ%`TMJ=X{dVD62@kJEcJbSTG;^?kE5y}BF;@c
zd9EOkB=dYY&&hK|YEhRZZWUrlf=4LllDGv(StEJxw-oGaVKh<FXut)`011sM&GkG6
zS{N??nRP@oMFdtW_A1z#NrRbzevCmfkB%w|@k$Ex4SB3R>1q3jJ);93Jir5<CB`Wh
zh;R)q1<di7jVD8JlqzBJ=r=eT!yS|mvUHqf7z<uNvOyW8k5m#T0`hPG2u1JD2W6H0
z3WtAo(EX0INxZF(E6>10G`PG<6oBBE%E7k7vf5*FZs)@*z9$eHTE8Nf1L;dZs|5lz
zmtmMxTqbk~xpO(Y`0~n3dB_W+eQ~a5q@AB6iU+L7xf7(|0ca_Cq~Hmb<{Iw*jd2LS
ze3GSvNvt*)6-OIBPd}#&`_+aaQ|%t#E@x*?fGtr_I+ejf;j}ZXNZ6!{<X{c7;FgwD
zJB@;)XAN$<r`YN;#8HA9s1APVoPN#UP_as?wSPSWgU;c7$Ol&Y69VrcKmni8BnuZT
zgZLZVT}9RBxZG*vU^CWcm)}NnQ-<OY#HF(z_9NTr34jeVU6XkCL1Lx<!DOp9A^kEE
z#>_Hq*_#boXV?cu>Rz^fDiU2mq9jIm0o$to8&g=tz@`UqKULY<n-s)%X?lDinuV*-
zKtQi$#sY5m)+>Z1bdFIbYdC7hTK%qmEUFo4(?}!0ol!MwsyS__yoA2FrU6%XAxV<+
z6YrRd3h*q2`b_5qcvT46!eYzHuMU$C>u}=hToWbc^wKs~+2%?!0HzuIfPeaqfM-A*
zzr=8upbtZjkgHOIHa=9H4L;2Oggxh;2GCrpYdu8#Jjf49$Y#f6uepZh{<KMRBgUA-
zANJ^Wf@Pp^zMM9mVUy~++vusEa|{eoenxL}z|`K<K0|MbGW13~B6dR)L34{V`$8lY
zaKu|=@qcZN<?4S0lP0kZO;9&F^mqQ`Kx-`dVS+yG5A0Ed{GrE`fBaG73$+FxKwp|N
zp<?hSr8)@9z}r!c2Jqn!dQ+)pd~PRMLbKY@hJ#OA77%d6v8crQ3T#xQkpFO9iO?)|
z!v+AWBvbPywA-+X9F3}Xv3G1hV$26~UmCp`!0GNA**dF|vG-;Ja|DqvBsqG4Jw+a_
zjL(#@FiHHS#@KWSgWuBxuyL%El$5?R|ML+##<=N@Q0ogMj-R#FUN@7wy5h<A5Fs!s
znUscekfwdY87oMJfJ|qbA(4pvH$y8xlii`c-ElF9roan~E>MSOVPBmo@})6>JxLf}
zms$m&39)^F^a11Vs~q5Yx|u*N0swOY{`EyyQFXV3>?8U}98W3A*LAX9^U8+pt*1Kz
z!Ab{Rx}ZefTDS9x<sQEeARWwqGs$9CvjFKtk^K3mR}^|*C{}?O=%;0WDwA#PLzAcn
zwoKzTtLz#rpboaEsRXdR2=nv%*aO5Q8-Q(1Q`@PmuYZ26kn8Udhc21qPYb}D$HPp|
zzmx!uFN<7{eSoq`c*b$)b~gJH+}DNM?esgOhs2r?R`n|YCjj2b^iB#i#}8BXzAAt0
zV+I=(^7Wa#LdS(5oFoZXGo3a(4y0ZXYsAtyKE)l*lwOQ&-!|Q7uwQ_QskM2~ID6yW
z(7|e)0JX3Sdzn<dU{~S*@FENY_}}<HQ$m9kP^bX(GZmzZ_{M({ikV_`(r{ym#TY}S
z7P}rQfs<Gf9?XuE#9ErJ%q&gyCUo^m=F07>Iy3G6j1L+abWz?rkik(#pn095{}Vol
zDa6D=d!KDjuxfNhDNt=!x^qE3fc&ds=TE7pit8nC0QR9@f7IeJkeDd`YQ0e{W@&0V
zgC?ZR-d8e|by8ctX{h)neM)8($ZKh%MuG&PZnws5yPlb{)<R6Xt+v)u^S3!><{Ymj
zWw~~_Nu+}v5$~qVws6=MkKJyqOz8u&dRMWUbL@K;F{;M<x3f1R=~bH4=2LOzH^!lI
zS2AlNlyn|<`qBksIind#pqGL#Kjx~TsmzxEo{_G{3!f3+8sd>T(W)PxI*2egZxY&8
zQe{;Yf~WV+V-UQ*vOmd^zgGA_neq4>75p-t;EP;_T#l{lJ?o0IVB%tr$H0CuoeZ=a
zei^8QwB3=!(q9OjlT%CGD~k+=a#&P<fS>G5<X`i$)G#!^R4x8etrmJX@TSwmU2cM9
z+5c-NHCwaGm>CVgV$i}|jsT%zI~{5>w4!W|WFdIHWgP2bkb`?KJmsVBoj__OyTOH-
zU0;Lr4=t3w-I+pvbk{2pii#y#jilC-`yHgMmQ^~qW~F~-zIto2CJ^xVAAUJ%XS1i%
zi;h`NaTN}u$NtgAhQ~ln-|~HQFkL7egnS3WRx7g(_z*}BgX}2z2V+8nj&~73i8hg%
zF$zqW|JxP7=tMe8E?)Qx(NIDf0HmFRN&QG3;c)=+G!%~d(By&!vr%ZA5nKl6JkxU{
zLjRGs;{wEg?{0yK0f9T~*`M<ES~aF&V!2C^t;6p5WrOnn{$-QNxPHQ(*lS7AO?$DU
zfb6-(nD18X1yi=x`t6O9G*G0l!hWX~kW=g<Q$aHwP=|A1zumb#=W*T?dSQ!ro72E?
z&X?C|X8(iz`{R^T2v$R#O{ld~EfZ!z5M=RT%!7q4!Qi=quAtdQE~mS>M;^AOfyny;
z<4MhU5w$Y=c0iTPg%3I46s9P<siGQVP)?gDDy!w%+9gx(&G@o8lki165iFZ;pzOdu
z_W8BxKvtSN&GhSHI}yLsfVc9V#ZZl*i#Gr2xeg9}-|z5h!QCY<j}IgdGs6*~0WYKn
za>dqRau6l<>U{E9cUd6P=D#@oApfzVFLWojq%>7#EnlbkPga`ctY9A1yn`XHDxAMa
zjK<iexM|NkPk(?JR{nHlum77*CoKB?edM~f%WfFes%n;RZTe|^p!?HyV*s0g?0{Ep
z?@V4DfQd4d%FmRljQ%k6P+Cg9T`SHcCrp~u{t1%xNqjeG(=5SfyF$SOC5>Y|J<*?P
zj!DK~m$AQAC1`8=E$*a6)kqybYLy8B#@`&6nJ?I_RAHV9;rsNPbKd;7N$rt)x`q$i
zi*0}N25uA!@UcJ(Cy}X|iYna3sa=Q-{RG%~h`W@U=sY_1Kb#$k+?2}i>{s9;hQHrn
zV)31%xV1iClq1LtdQp_JoVl}1K>O5c>j~UWHxwlm<XZ_0)ryL8fC+QYotA+3Y1{97
z{@~I@Ou*@$$ihnk`xUl}<-xWVtqOrUyTPlXWELSZ{Do$59;OVVf`Rp1lB@^DR0L$|
zKG!nI(I{lx)AmD1KW=IzSPSLMH84d;h$^OQ5j|4~#nCSWG&PHQ=s3$T<*rggw(g<b
z=4n+JTArP4B&XsZRzN=N4~pu)o`?@=DRM`zYMvj4U3$S)RQh#PS^f~+Ey4k;0qBMo
zEi``p--SNm%=|6{8(j7V@A94LsGjuS+F*<RNo-)<@aw9fDPHC42+74iY|^VSf`d^O
z^t>MO=?`AMob(OoBBfMZL<0}Dwscx>TU_?`IthbRz7Frdk>6QOmxR3t+E_!7fy|^G
zf-QzSi@UGm7W633jZE$6CDUGXodFp&0m`Th*tz}u3&$SuTSWth^R>$p#o&vYZs&D*
zWN6ewCAa<`dT0A014uEVyg$^vVjP>^H=&4lk<_)|4|>@}|LCpEj4HovQ!X^-n;H%+
z-^}Nhj_aSL)iMiw06>OSrRD(%+<)xOi?T}<zwDPbN*3{!tXFC*U%r~HX}J!Qj5p{F
z@?+w@RVlNB8i&opSp^>YiOBW?c|w5k#7I9ktSw*F@gQG&sdusHD@QgAdAroWOkgcx
zM^L35tH0i5$)aPRr(3K4P%_n$e3semix@|F5|3H!L(7DzrFQT8Qfda+J8X99VdFA5
zh95S`OK``s3CQ1-bn}{h&cZAKkSxHHv)XL(p>4%zjXx%Jeu1nL(0OOaQP6k1O?jmX
zxq+4udJcN~IPHRU(Hrp~r!<C^LMCkmMV9i9Y7H-HwI>z}Pb6DSq@&s}r7<B>w|R2O
zi=F4QFi&*mK3e*hEt{&9*gU^ppZx>X^?@^$L#p0Hrk*x&r~4vH6j`@E0R$BJrT=N;
zWz6`9e`~wT{lxCB+sonG@ly5kN$o|C+QY|5t=L_>!}lX%!Okzry`4%YVq1(#MyTLA
zuRFN7xQPZ34k@Xrb0A2~47gn`zc|0`o+!}$kY?_^WvkIYtjaeNUhLh-`c4;)r3MbV
z(%bMzU1_srBnHCznk<|eCFsXBfL~Kt$>X>q>gwv6p3&sb@oSAm{k6N(Fk%6QCSbFS
zZ<%fOLJ3mn>Fs&q@~tLIJ%HE{Tn0oY&`ixieYLkh930w56SIZUXOr)xX5x-hiWFx2
zk(~&%Tj&sjiBl(8!=>hl7RutM(L9tqn4aXf`XmHJ<Oq?ccMeTY71XcV-BL!|O(AYP
zP2WMFSGut2x%tV_Z{E6_p2_OPm@ZCY3I&j9795OV|KalB_JKgf<XdbJp(EMge<cX&
zN$0B&FMt6NQ&b+6M<MM@-;QbZeS5CfY0=i!rlvM#M`d6@_RrGr?(yq9-u~sNgD!rQ
zN3cerUWP?>%z9$?D+rX9Jrp$h2X@yACvGT{be=jZrkxRAeYKI<+s;7nkZ(mMHd?Zl
zF!gYupf_bR5(WC!8fjsDxaHw@MYJ?t>NL}Jl3w{azR(OMN&N9IMSYRfc=rAE^HN1`
z=IVu`d(!Bj6<dwyOKR0Enh>o1B+Hbc7MdE&rV})S-tIHj8;CU&*8vUF>^Vx>kf-`Z
zW8c(BlpwB-p{YV_(1dn)aQ3k^d(yW!7#SUQhY|nu>Pt#jzl7Y;=;#ye`>l3NZAES>
zt%_@TWt|)(Cy%>)e+mKh{#mFumGCV^vIx!FYow)D;J!nf!@5fqLXRvP`;qlgy|$I+
z5r&n^41C~AblWWIE*>5&r5?nJR7q5N!tE8N=S&vrkDy`>NMl4rI0r}_Dlpt$@%E^#
z2t!RtOxRImp3KP8pgk6gt!?3nkev>iDn{L~^52Rs4MK|!;ey;%y~Xir#FtOD?ppX&
z2D+LS!gwoWi6mwtH5%!W(XKr!DR7p_e7wq@aXa<YkD4cUS00c%*C7Ph`roUd`G0$w
zoGmyxB6+F0Y?=P1>3<xYJYb;r6G~68Ps$@{RHpBi!_G@t?7_xKE>DU1ig<|t9gB*C
z4GZd)NJ6x$*E#o%$qalWIi6K>fg`JnDnLf)DZn<9M+AJO!){PuT#*^qo~>d}t>WW4
z4!oN55a;ge-8huG49uxI8$L0}x9tSs)NnyB=t30qb)?QYsC!{U&Alj`QLE+3{3?TT
z?T6mpr&x9~@Jhb=W4m9r<=J~;cLRcGUBoWxHpG!<&cOs#(0!dn`9B6)VE^E;a$)x#
zVi<kd?I?Gvg^8p|&4K{dDb;&*h>}UC4R<T`Lq&Mb&}>J1$x}s`81gZI4oyfK${|+b
zEXH)5(BBn|IZalcS6Bsh@T5%RXIH7u$y4<fM1mq4`%HNN5(If)Mebx~od`skMp;oj
zB60Y02P-G%%Ic~IfFCK-ASHb@*`?9iqoMfLw@Yn72syeDlY8!0#Ro3m3r;S)%S)Oa
z3H%K!e_aoaCL0jYXU<s3l)#J`YJ5qMT#Lg8O5CmjZ>GLdn`8_a0a{kq&pRYmZJ6pe
zx9NCjQ|u-16T@VZsw?|<^|p;;Z>TbJi~7?BENi%CX%Pn+4T*yP(9{Hr{i~1HNX?`r
z_6XBi4uf~*euwZ^coF$43^e(e%7pJ%V!^Y1a>x@g!#+H*yXk!7&2XI*&1V|ckLLxW
zpg|UL*RE2X)$O_fKX*r)YdR#^@pQv<7CW9EjMHsiu+=0mBT6@Bbv)WN=?sxtnET%7
zI$T-}T0V@=wFW8=TjGm65!uvf9m>I`pwC)pGXy4NenH$yh=--sN1&5cM<F92l@r@i
z^n|kO`<CA1bT~}}rplhJT&D>Eltc57DqSprhb;=jlX|kgsWG*TSlXR^;^7^nbAQ1N
zZsm!<?t4j%gN@RXMN+<IvU+;Sz6OklV~YsjK%Ho$E6peD<V~-HjV-N8{q&@XW*m^8
zgNYtM{T+5auxeOMFup7Xf)k<$w-jZ#QW7AE+e<=(Cd<3OI{vphvyE*_P>u^eG;3Qr
zB=@Iz+L$Jf+d%)$%J!T%GqA)3qDkdCWrzfCdvWv3<Mq*%qFV^(=$54s?}~JjXoE+M
z0h2dr$lkc?=bi7yqQp=#$$RBrdze=x<b1{RYWX3E$_dfs93ai)+4~w?-IOI~*(acQ
zq#A#~vH4I6G$CSEY4ax6MuD&)R-@Bm3MHnBfpfxgg7PNT6C>2`x{6+HXO9%OMpok1
z-{Bd}2mh6vCJKy~>61ojMKR#KQSNdk!O~KG`937;`0<{9AB|`AZBI?th?rF~1nqGd
zQ!W_up*AxO0%73D0HbDyK#|9S!sGTnG=LUZg0cg`URYaS!Hzo89*?NMRj3x6dL*Go
zRsm=>K7m1A#Zn;7)10cI&hxmCRmf4}MDSv3Toe7Tzdz;okU@Wlg<&{RX_5yj_7Kpg
z7kZ}Q{6KnOh&B?4dzH(va45d-Mpa<zTw3A`Fw<1rCj(7FmXAb{G73cXriFp8OwS3X
z*ZX$G@d{Iy#7ap5{1UH-OXEMi^&sMHMvD!LVG=pYI{(EzEhs<~{p!u_iwbwzTT*~h
zW;hxBMN(kouf~X={=0d|I)^&}xx^(L1V7XOE;XXJqXlfl{)dDvB?W_UxjP`)-DaX$
zA4aJ?4ROJ5X^9n^(o{Jtoi8ubM;yVc_b~#$k!I)8wkfAr4Qq?lFH@x?f90Yri-s2Y
z&buiIUj_5qzHj2t^tp%v9^rOcV_u9TchdS0JW?!#n|iVoySv-=b!BXtA-E9&Y>;y>
z=t3ws(^(B{l;+}e8trluqKsD6mLPF(34XAQx-tC~6BU;<G|;a!JX48vB&?k1LttGP
z$p}XLa?C$vYN9|U#l+y)fv@1cGnzo+;jwZ50~{QD?5Wf<4L@(NwBfJ&Skc%I^y{4B
z&kw(@57o2v>QI~agCMPG?}`3Ui9pG#z}*ZE#hsR7QpUO@=Vnz08vtqE9Y~H$k1jHz
zu!I=yjW`r}QnIW|Mcg|f?tMYVpj!Dii~9@53GTKG`6(G>K&(J5JQwACrg;Z>J=F%9
z&NETrhlgUc2n40j;_slj$#`_6YLoyRMe!0a@WpxSe~A}-O6-?il%e8+AUApS>6l-J
z;&9(_h9X6PtIqQsgGCsF1R0S9Ro6IK?gwHchtvVGK{1R!9zQ1E8Icfg3T|VPEMzgM
zr6?1!y|gMWZ3Rh=?BiVx>1d@yI}9=ous%{SvZw^Gjb{;Y>XfSp7(;KE1ZD%s)S?8U
z`^dydt)vQS3RTQKto3d_)y>}yHBY)eFTV!oSi(WWwp7|61wqwj?OF11Y%uj8wg!{Y
zOJcLy4gUllk?n=FL2_}mRqN4>oWvQldyGk%eN_%`hlw^s^(B_>+SNV$*Y7FN{lrp&
zMuI~trBdlvijGm6rG2$k)F9k6(!DXyVSj4Xxx~Vmo}HnZ8z^#F4j}fPX}@QDR7Fd%
zNvFf%k`#~OBsCU!!}80j3@dzX=Ud>I_4;*o{IfF56WUW^JW;*#7^APb3NH3GjH<d_
zCn-J0bhtn@2EDcm&O%m>`MFSbT(KL{R=tm&FRtB{1kx?bZWfQ70ddR72$oQJ+D7n2
zV%0dJ&2%S$E6aL+0U*kV|MoCEevMhg^YeYS5I=;^o9jGFw<(G04M%qx`Dd5g__Tc-
z!^QPbqCH8U)#Wr?VX_?C<$5hghRXrU<avf1fQMg@l6I^|eVy1CQi3t0{*n1d)nmUk
zQA5KnT~o6N`$v`2QqqIQ$JO?_UU^%o>aY>`_|CdA6OAwST#QkY7+FI#MYEGW5~gtP
zTT7v_@SerD*U8(&BW|#$5`k9Bdy<d0Ex*c(vgKVCq?4|KU>5SBXd$9rd1jV>#R-ud
zLq0)}Uwo;Pl=sS7wDcg#61=D$S8e|gft8D0Z+dxpT)TK5vw`hgv$4Hxu|(zhxSSW(
z`9g<5)i&!1-E?@fxW${>$<t$=^K-rlkt`~)s0|7b?w*TNLJNyxfnqEEnn=(1)wpDr
zc>`0m`QGRIxba1w>qpnk^zZyHYW%l{f9Y^kmRR8O+`<KG)9#FlH?$1qqiHB_@>*1<
zAs|UkEM?%~K7K3?7{4twZ+bsSuNUi_5xxr^6$xn9^PBMBMMo;g28i=kARlSX7PM1+
zse5syXQ=j-s@mMwnF_1@#=qu*xlZEW&svP7@xI?0=*XRp6LzQn+eaan32zd3ZJApl
z4oKOTy$<_2ewrlaCCoea$|w+27Y0ay4mlptc<F(k(3}{_yb6UhIO60of-SuZ4d?IY
ze!Q=5*6s(q_L*Il6P+W986oqSIaa)T-Rf2)8JVq4jUCliiC+DninC(=J28?*AA4`<
zuLuH{3JR}H#g$@KZ1&^e2HNjr(Q>@1SF=ku7ag?~iGh<3Q8h4sMNqil{@V_ss}V06
zlajx%IhnMynO3r_goTJ2@Vhr2{qR?LTsD1nZ>~SKe=87~`&zE{&o!{vy8p4%HoY4(
zzB0yaq6H7-`@68-#hKYvaA<p|X=;U9L3I*v_gsSKd-IspQ-8}*M{M^nw4TTzK=BcR
zVbH&jUJq$<AeTX*=h$xg^~j7>#V1`6C8O$}<nY=h&;c;(;T(xPo#R!J;tF5>UlxG<
zc#*0K!FZfq)}oldXIole-g?PbV#(sgS@3K)>D<zQwh-o`UwBWi7j3OC7x(XHo99n8
z4ZcEt2O&9nKJ{PC@~zS<l=Wn6{Lpp#J5@!E3+{m5KN~NhzjwBG^8!eVuRXYrKSS=t
z)%a;*36wW9wJv0LkdTLzMG<N<L{r(Ncv?i}v$<q8oz<E$)xA_0H8&zZF_gyjKM$#?
zpg1#36z6Wlj9z|3Eb+|enlaU>l8R^tm?xd<mH%w`wn8Rhku~$WTKl1@)sw#@uux06
zDX{IEcB|%AzcJ)8QkNfTLFfb=m$G`M&x+kv>g5&+vPW6W<+xSYhQDna+hP1mQ9k#}
zcq<WSTn!AW!LE_XcaSgeQHTkMUlGr`>Q{Y^+kH0AYTna9qXX_c@mZ$*w1}WG3oOcX
z)F{D8i2T1AY!wh3S!!Q_@rcD^e&3doy_+V`l4bbj_0f7odE)&tmAdf_qK;<WUUf#L
zxHg+vE@T~It2Xtt!BcC!{bvT5hy6Wvqw0_+16`zTCCYljDs93`*`g^07qw_&FH>@!
zam~N6S0!@WyAslorBRjLb@S98D&IlyJl_7IUQPLDU@t=%y7zG%rCN4epAZX9bvFL9
zkk96_Hl9RueINFaRcV12TOtQa@C`CB3b#TbJg2$!nA!#Ab&B&^VN!CsyvP@udf{{f
zQ9b1DyGXoBf>fs&w!B3g2ehS(hZ+I*0iv6d5D=cRrY&J(1p}|$@uHojhM(SQwJt*(
zR-SHIg~G|a0XQ6n*UXPDst~5LcE*lW%AOqRU9H}Z`gXEA2eo+wDaGh$ly+U_{9?Y$
z@+DCqqN-iY<cFi29X8VoS1OqDdf`Fkbs(*cway12Ut?KuHjgLq4tPy!(wXQWl08T6
zdIPgg{n@Hpv0G5(;b#U1(RM5SP&PLRc<d+y_TPO#0`iu8ZhM0xzQ|{01Fxe~huJ)J
z_QH<aSt7iNSd8$TeC)qUKhb2Xx9V#Ofhpt;tHD=ZgAng>`?m=X)Zwv_73n(0BC(mA
zyAb-6NjNNM&Cvh`biG8#aUO&n#(ckM@cWfZ17@?ar_IK0|ISsYNyg3dRrdJb>*S}n
zw4<>cdNB0-W3!678TvO`^IRG$0seavSsLXQdT{QWVJ`PEyvEX4kVT%aG^bxf*2=F~
z;z_FnrU<Kedt07O){vrJ9>f(Myfhf5a1Dqd5{A1#t6JGcy`k=0^Tak~a26)*rXqj$
zD$sdqGifb5ZRgFr>aMqcIh@Se`^#rv6wd^9N}41>0q4(2%IkT?r%aB~lIo$N+LZ`T
zKUDhelBI+t6lv(xuMsKektJ)Z6=6(j)7eRZ#Y+_wXpuSX?ea#lds`^4h!x;SwRKzG
zw-(d@o&j>VhhdP*<DtJGMDj6=f_!HOBwL56Bx1MpzBt&dNIt2qFA)1p=3MB_Z1wUz
zTnxoQ*?j@xSka2&oms@`9Ig-!=fA5rbgY=<T~|-BQo9VToFf-j4aY}6Pp*j3+uxU@
zV}E(CwKJL~vv#142Rr|_P-44*;aPBATH0o@nyg=Tcav;o7&dhVxlbW|$5hU5=M9J^
zI_cP^%nr(&F;BJ4A7m@N0R&&v=)J7^RG!+NI1!H4czPB$Zt7#knN8GMHc~{HNrrR-
zNElgJRW-4BD#FsVApX3(1RDy;p9A+lH4UxR+1b<L;tJC7?)CMalGkPqt6ik}KDWFu
z*jLw+P;)|$yI4qs^fMhd-IV}=_#A%U=Op;t3i?W4!(;E;7y$v>;V)Gz_Nh05rhUSn
z4e0UrL!(*)FM?#LE^Z}+6Jn4La~=Y}_9@E#T+kW(vuP048!hRm^Xm7Mx;|!1S-s1_
zR|=szzq*f?u%6A|Yew;{JNM_UCRM~roh~T;ergPju6+Rn(6#uF`EER;`~Ut;Qe~M0
zcTaapWaDioiHeJX*o#R?jRAV6xSXX=V8>0E2@kc*idl;Nu)8l53N6%oOvTD;6bFOv
zf&ltjcn#@CEU0%QLo-j)gp4E2%a3xMG}E`48h2XC^}_DrEA?GG2|q$K(|!5vPVA38
z{Cd<?sS--YUBo37Gi9}LX8TA-Dj3CFx2)6%!7lAs5JW?0!oI&7K5NFMpfW4y1dR3k
zFS7@AC#dZB?^pE%de%Kwkqxs-e?8mJH)&@El;_3#Au99-$lY+L4nTrNC#CAo^4ATx
zZ*rZ^bJdh313}O`049Mm8f}2&rjT^MRKCof(#iUIwSIQXcPAxB9fOMwjbl<1v)3P_
zvN7j4__86Y*Q}9i9gVFfFF(Yt=6EnKFZ4D8S+;R^y@&<1Sc@6PEeo7l%Yq9j!LCmQ
z{d0=Ikw>ao^Ezk(Of38}+B?<B)kuC#W}yz*u^baiUgea6W)mxJkSAdhm&)VW&^6Xq
zSUsiHRlwbZZ1BF%f2sBR-iaHjvpb1r!Nw(|2O(L0oWiSNt^n_JA?t8Pz{t3%?1<-z
zVhUBl)>gK{CF-#Z?rl#)D-q~okJrKD#rASP)gJe}bG}(|g;rE0(}GYX0irR!S9!6U
zLf^8Q+D&*NU%SHby+mV@9i;JR_bI7FN<$g_aNNd~P==~n<78IB@t#<3;eU%ovBK@8
z0^74?_8DpmUQY|-OYLrYo#1?c>4<*4T*0HjQ)n;EkQ8$CavvQ17j9zgxG{7{EJ#(M
zZzoMlMf-F*H$#`+J}YGEv*;Pow&Xi?McJs6<3W;bF%0Ew77c>YA$n*EYOA7P1J@Lc
zHeZAResP{#!b4ZnRr`?BalWZAU53ehVbGC{*_VJyV~5BrpsbZU?8QXeYBgM8f$7su
zSu1&fFHxu=UnVMR?M@S0zD!_-Uz4dC)9FfA&$fX&osP~D3JO$k<&r}7jU~fZZ%V+$
zhyf02da&@xaCGl;_CoqVRc*LA2ec~mfNS=QCgh+X`m61Bthy)0NB&iZ2F4Z#%O_<u
zXxT9SMVDhB+eA&i>z~k^<9GxGTuu<Jhr9l!o7(CZZY0}*2oKK9YnS<>rJ7V&vEnRq
z`)n4j=3A_&dby{6>(185Qi;-7pww;y#O!C&ppuT@oZr5&YiTF+bi0+87?U?dPfZx`
zS~~f-AM9V_C=4SSa)!CHW@-@;XO|9Xa-yA(SZ~d~ZQ<S<zb^DE1T6d=b8cC-tF*5j
zxqnow<(OHGMnby+3R*y({YS0&ss4obY?!ZeXrdnj^$4}3ePp08*t<LMv<?98O|S!c
z;9yz9D=VU4JS21ZY_cVWaN0`UPyy&)*=Srq|HVVh(yI0sw`qgLaNq}~T5U9yiMNr)
zdX2*5hv;;Ab_$F7jsgW_3om(b){U!bK&u(?>~;gE><~T1cE6?^*=m`keAC8bY1Dy$
z3L6Il#ldE6D+>yE8&p{6`%U?P9yoZRvLso+jyii^WDTE<x8~)*zBA3afs($mzP9dj
z#?TCRFR$P3>-1yyZ0zHto$EfAXgW?P(b$kYv#Suc-<gjJd9`IxI}9P`!`*eyn(UiT
zl#4WO?@#2sbR8#sc5Qe&hUQ^%J2P+B`*rEu<<TP^O5tB;h0C!!OI_>f*|rzC$HehK
zJ=(t^<AuwO`>ke!vBM@7H?B89k~8edV7e=6%(tY1<g@>j{fR=vt$LaWBQrUgRLv0&
zl@#envrVd{>~Z@*kb8=M=w~H<SJcnb=uqpr@q9s$v$3X|Cw;FvS4K6fb7JCLk;0cP
zy@6bk@C6Oqd9!O*H2%YV^8pYr`#Q1j&Or8JbCEcMzv%Iq);-74uM?UjUZZ_>9ffDz
zeFfh)lck2L%|xCm^l>JBf7s14qeKVue(HBuZ2CA|D-EddM5$`@?v@|~oleMp`pcl6
z(da+j{w%oS*2-|mY!ZPXyE8x{gEBwTOwwd?+gS<O33=Ij$!Nfr<l~v@7a0b?AQ+><
zDg$3HN(!foLZ_A?m(@&Wh?WG35$<g}#QBki;aeE-G54Q^r{1wAsjDNb1KRjxLp)H;
zp7C$;3Bo@TBaWf&;Md{#Wh;_g28hUeUY`peE;-EpCSQe+VIy~LtlC)7M;jw#PmD++
zZOdkZ7b`O(n}6P)G+!+np}MHvDU&Mt3c8g(<v{;q(fYOMb{J(Fw!aWGV)?uZP|omX
zq9?y9>7%AP7guUxH^uHGut1LqyV4WJx8mbyY&EQOtZLo$Ijr9T`4alqIZFS)43O@y
zfvKJ<3t@{hB))NXbEG&5Sc$kF)Tf#^E-|#~Ik`9A>ou1aDbG8Upe)KA$Z<>Yk?%5c
z545Mk1F<S*ySG5HZRfQo+p9WfNX21Zmcl%s#GeGQwQOYm9&!qWX9G1^lq+^+*{9eo
z0%2afCDLLU0Hf@E^&O-XCi!3tKS(?`&7uJ0mvtTjhqzBNUnH?VwiujSc<-PN4k#|L
zGW103t`htnD$HYMoa{wmp_L8PP3H-+DUik}W9nUN!-1{3{L&Ouely~{XL%28;)pCU
ze?W=&acs-3jfkn%Y(i-OJW4R=s8)yqRX_DyRmE$P82<0Ub(wmn600~VKRE{-P(tw>
zU%6MN!<99ekBC7OP!a>#h%cYjMsFSi=h&?<%2s0F5~K+m^Rv9#8FR3W*g7=HU~~i>
zVM6=ZksxBvUoHC7RXKhkXmXF$^__1?_(Y#uIk}rtb0uE6X+rRxlhnWA^Nbk<aA20V
ztbS+H6f_+9e6p%iYbyhad^syc4X8XMS>BxCER2lb)zok}TW9$S`e11w3w4S4c@AW6
zf$3<thIq1YvJ@8RN@OIu4Qhb9{lN8Jy&6=mJ}`*mu-}kXhN#{o-9mVgOno=zcJ#)%
zoaC^YLCT^fO<?$|2SWR)0}RLNM&6QD;PK01o1tk`xFj0Ys80Qr=*w;JRSIEr#-rX?
zkqVW@&tTg9-UtY7WmRk<Pe>^FR!RxL?;%-yHVg9KGRuTWvim~rZ%%g(Hu#@X70gPt
z5Pqm|iOwjV1gLqVgCn7c{!a^BHs2AQxidsh7z8P~%L;H<r2URh1z~^O<KZx5kjI@3
z`jw!;pF=J3^rLDCyz-F}3V$H*ko4-nDNFpq!T&`Aa~HqM4WiiL-C0`^(AwZ@X33Y<
zYyhRLx5@JJx>jI*YHWc@SqF#CO5$XF5GBa|Z6ORCC1_C>Scp)YPAY?lb4s{S-y<WC
zn$Kog@QDQ>2N)nHL=7*+5HYB<dom)x#V-mmSeSAip&d6FPPfa&hB6YaS+QD`-#6^@
zqB9N+b*iE7o4(gZ6n+s!QH<Wg7bM(}qJL<gjXn}+A!X-;S0579U`b&nAC2w?3hFuZ
zg*kJkG__7D#$j0{c6kZhs`y|3t<?%E!Vb;*&;Li&S4Ty?M(qwm4Lw75BMcx6AR!10
zrF6GQD~ObcNGjb@lG3e+N{EQm&@Cw;NJ^tL(%g4E-*?x&=bz(Rx_<M<uJ_q{KO3xe
z&WI6HsQBv<)XX%-m1NHC27N~FvH&5Hx<p#=;QfgCnD0EbM}%yY5OjwTK-9?Kie}FB
z{W~2(0sViL6MQ-*4b+XH%_xV3Mu&W&i$9Apf2_RAIxgOoC`E*KkuoT-@fkd~H@L4G
z74IGX*yeh&HbXRxvCApyK3~I{y&dmEUE{}3HghC-&dF$>);jY6%V&r>*RRmTE0o~-
zpOt-L@ULFLqiv%kBY4r|fikyIZ$m3SylzeJ9G@yII>^EanX^d^PT`E~uTNqu1Zvv$
zu-&lgf+h>&WOF_19ajnYBF_0p@05Vpr%EQ{vD)U5Am!TlDETT%)5VTz>6IoC-zrR7
zD@{|5=M{la%qMzl-V9ocx7=R;A^Ot)KccUZ4-oxaNKSMI(^cq1zV{7|40QxVfJi0y
zRhscts`A}iUHu%vL+UNIAgSxC_cG7cLD|D29e(SbJ2Zqn>s^(^B<yjTGNy;^;}1S%
zOitEw`<G`X8(}sI8F2^WQ8Lr|nBi!*(cfpT^~!_RUI){Qmmq6+dYgtog9EvQh4{&l
zFzN8Uwi)Y|_bLBW;`P7ntIk$ALU_A)14|vn_LjrTf;brJvf*(Zn6K&_uM=3QAf~g_
z>u?-mqEe6>36cyx%;cw$F^KFtGRZso{p!w`tEoY2CB5m~8Sz$-nrtUEG-xzx@Zzn0
z^(&0do085z*%NwzTg|=UbYJU6Qvy$L4X10Ft4sH}6qDeF<1W^wzHyc+wyuOF-QZ-z
zs9}h<5KYUD+`8iSss!T``@1h?p>}+hI~wn-puDYZn}nA*TSU1n9?N>`K&_K2)LMKI
z-rQz$-TIYcB;w5PtC&*zMZ(q22kQG=2WXRNYve5tD_(D$vyuO4zvZ&?)~iiD#;}{J
z5I6a~=jZG>Vi%$rP6F+D)Ye$!AM=uHK_VxPWiR;^<D62fyR=6}=^)p~7PN@&hNNuV
zy_LKT$Jt<Nb)~W}6Ab3oiY0KTbcgyCnZsyBdsdmLc&%R$bPfgl&G*c>N5E?B8zizO
z>m=<N80%x`Spd`3^~NSGcT}q`6N+sem>niF(oJsFI0~-N_eu1bdXb!sdMmu8QeJmj
z7cRF#5gd(qu8plL^AsNop$>>#h`@nLoT~ZbLu-TX-)A{Sh?5^xoSLiPPYeEfm0d)k
z_zcM1`xYq9X2c%IGN!a)vy3QxrM>__Pc!}FhsP4#DOX*mBb`TYb^_X)+dNh>60P@q
zIQSvS-+Mo%Cx>BG-|v5S6q9;H$E5t1{D4uAk4FFNVGI%I#;CJ2y@Z;o^Y|%`az{gG
zh(f5V?%*Z*J#mMjgboUpy5g<sJnsKGrnuR*w6{N@ef{cW`N!A0zpbD46d^03ACLdp
z9p3~&pd6ruZw4Vg=?4skP4I3ZbF19`lFs8%jb0`hMv$joG+}OC<L%>3Cfu`0;(s?t
zH712BX=u5GwCaywJ>u8MI<@$fC<(vM>!h!5-yPI)Oj!UHK8>;W#r-zP8AGvtA1W1y
zYa17^j-X(~Z7%M&evp-gl9JM14CDitZOe#RaFKH4sPK-rl=H3r`#|scV;{Af<-!M6
zL$^=_+Z1!U*P2ecw~<P8RQ<D3r=0;Ie;Yp?<tR<EX+x3Aaj*|8Vf9MN5Q*TFRu+W+
z3@;l@O7I2(XZW|ey1L`VwO~7L0tuAh?B7jc$*0fa`}%V4=@W-M`8gK-^{&f+?9bcL
z^eM1wH?Iatc$4#EUVgkhpS;X!X}Jm*xV8)j^$W^Wc^aWlj3!F;5bKnP_5Jzs$*;$v
z!GwBCa15b9!Q=y?=`HR6+8aNd3ncMHS|m&Z6J(W6qBzlqZ9^_UctP2M+%sWT+6Y>Y
z(~waX6PXVO7JmlTL)c6Y;%9?ccS-$By_`F@8)b9#;F=#N{x;=Ir{DE|ycJDo(%QBB
zaGisL91-~H$$$fsG@~zpF9&pnfF~>+M&3Y9P?5yje`h+RZL0y)-+)To8c-;|Ro*0D
zL)-V{#gn$MxT9}D&yRy_XxjFaO>ed3RON4<#0FbmG=1F;>FrD<++-ZT?hChL%SmM=
zSX{f9-wRtQdcYebFue1t?bqOx>Yk5c9UlwJ($SCKFbtERtQUPCCq)}4M%%;G^wvvd
zvB%y9!7deVwzBijw~k8i1j1xEEBZ1OaVJM}+D#Vege;^Qu6EL!vVuxle$4E<1U!3C
zVSPZJdy*5x8gJ1ublrWe!+<15zoz3@`bKO+pO4SLNo|Cy9sC&>O~3K>CrG{6;My%$
zYjP?E6tC_X5OYGQ$u>>i`&2WXbbl8T7Ip*u5{Y&)9;9t+_=6Qem0Pr#iXStLahT|v
zN25DiNsqc|NJsyM-6XNHbpJTl_H_<~Ek;(Z<&I8`ZjO9@zA6WP$1<5iJhoN$^(+ww
z{2%A|%5PsT?$H%de-|mM8?sE(K6Qm#^R5###_kuiT=O-60>OrUh4~sJOY*>x?aJ1L
zl3@hyo%fW#h}wQW1zfa0r>2NLuUvmUVKEttc-Byp9z?K7vfl*92;X`|z?)+u^Qx5A
zpR(j*zW|l;*jAN;iM-$CfseB7&ts6Lx~BcfhpggKBJW)^Szc#0t2&<Qd?s}=EbrIw
z-*++B3>OLt(&eMmC}0?Z)ViUa(^fJP3Y4>Tf8=dQGoADg(htNr=7#5c=f$W11v4Wp
zug2EjlExpKy*EgqYcvA<{MWQz7mb)QqbGPJD*RK%e682{D<8Dix0r41G`NoYwis{I
z*X<f{&q{hF1w}sOc8eYaemo5!;A`Ls{;Us2plOeM04z;7(wHuM0H$Sv78B^b*z~5I
z6S{H3kBKQJ#~q|M_}FX-+L%c1wKq!Amk56%c6KSwY(gD1H7?!Ny}v^pzhWY|wzlTz
z9Q(WP`^ZR@^OWfRcX9z02zhOY5}x(=Bczlvnn$=?7<RJ9gwr23t1t4z>Its1_4zlU
zj6iykkO}Sgft4GxOtJT}<z*jz119TTW>ZD&)%R~!ErYS8lZQ?!9kCxi2x)F9U%1VD
z39=mCB|BoGYwm4JQ#`ugekpzDBTGvfESrNk{#i=jE@=ELGEpJ>7A(3rEV3Ah*Was<
z-ekqX7akRe8}ti|onS1lD7sy~rZvoB4(XCa@*zyuwI2KX@2+4A-&#9O_L$~y1wIpv
z)6ZCa^+d`)Zy9QJ9XdAhQ{W2h&*M{0G==W*?@!3!vFC3GZ2O@^_1eKKQ70!SIHuzC
z=!eUW5~m=q{@MyWN0BLzlT%tDy20kNSY+U9M;d;*u^5-tS|VhC2#Rzbkn^~>yTg%y
z9q$D2ZoLznf~yKa*{yYnxuV#a+#j$+p`&5e#0L~kgRbwJV-KYGjw^dJPPGlaqaTiJ
zPgu3OMdKxsR%a{Vjo18GSKn(rP%%?fw<3)Vn_HtHT$Is!aXOldWv(_57T7=zFGX<>
z<I<2g>>%~Td&|WPr;OMWMNe;MG?%`}H1s8igdm0xQcqS$OQ<*rHZDMmfM|jYL_n39
zDP1RjOm&-4FxuFKcEF7IVp;fw&(@^Kt=9I8kN(R7(rx1rIENLS=#Iu$iUlyiHnWU3
zuzAJbo`rO5j;2D#zvHa{uTKFE^9bGi+HfJ5wnm;VASig=DcO|&fJ|*Vp)F`Q-g*&l
z1tsNdq84JMS&0#jY;O}07HaJdo*OBcWIwIYP)jt;m{NTub!YM7@7!GT3wc(poLiu^
z$?Dr@5yX7R<Dg%h5UC`=IR78|^hS7jgE25Tjsm)TrdjSOeeF(fC*7uy`{akDlDDNK
zK`S{zMeTAUFm_q+16Do3qu~fIi|*on=Ub<XS@?1GV1WHxwF3pKjZODN(~&rXj2FD}
z(0Kdf;@O=sz7+E^!R-9R7Bg~^AE&gHmaH6Tx9B^VuiWpRWk!)-hdb0}2(_YoQ>s%5
z+`q1c@yLer&Fci3;E=k2xp)_+GMm}dFC6K2aN9IhV$)k3<;k;^c(i39KMOuA7bK_%
z4f%WRK8c#Dudi?3&)z;bJX{zCbWYi_^)~Cecmja1H9QJ}fIuts9^V>as&PQjicKz%
zeIw=Z4$%2D3$Mz9@a}I5SthEM)z;EA+Un>~um&tr<#x9|sn}8b;r0BT;023uF0N?7
z$bw`@i`g%IuIl5Bn+*d|ls2RYb|^Y<HhHLtV1#WX(^egQBT$Qjfjb-UMT5!gG|aI~
zlH~hFDER<WSI;mAk?7~p{4X%15%E}>a#xjaGzK&&fcXnS7(n0C1cndUtu$QT0Lj>B
zc0cq3ttj*cOv<8$;chE7FnLy4<<|nywDJyMiMyXI(jU{ZMc>Z7U3(~)8b)<^Q~34+
zDqbEl0<L#Tc$(PrMRGS5hPaBMBT}Co?&XS-Szn1rT5#SXa=&WrBmN4=1>2)(+Ps+#
zI8|1M9MYnAVsE6c#!d}W#c1#Z(sRdAG}dwi-u>c#h~JhZQnxOk(sn`eECO``hKPJL
zuTfvD-j{?U?0Lt^#SyCbIO#2M#m%-vT*88;S*bTb`bxxhfKy~e(eCyQK}+tyJ`*dH
zAj7N7rq-knk6eFzS_i}s+F?d#BYE<Mr_4?cUiMy-YHCL|-HZqvF4$0}E#7Um$h>Jo
zF$>+SDOWL?_p=ewzW4CRtUn@-vMvG9Qib1NSLzVi-ilPgr>jl{45^$S9Un@yLzNEW
zYTA3M*=~97fIdE@*MQ!xRqLLvZo;hqiCc$ecvBGMrYhbHdx9fTsVbS*c4}`%)R{HU
z;Pdn2U90m&I@OR%xSu379UZTZ+wN%lH(f(%!<!+AQ>0D0w03=Eh#*6Fo+J-VvSLc7
zbM4KoYYO>gAI%;(LNYr>-JGPfadV8E^}>U5eO59+OSS_h=mv+qGCI|~1J@-oh?w#(
zkxsH!1w8y`rUIfH`m75~;J)Wf{L)>bUM5^+kPSh4_XZabRaIrQpiTR`fC_sm!S?oh
zEq|F?cPQEpw2BhcW1HssH@?4P1CtF5J*Kj6ODhG$=|>;3tcM0uSBo(qx;^mLw4(ly
zBs{Lo$WRjaieAqueFRxu&tM>D#wmYKv-zwy8Oe}a%yI3*#M74Nrxku3KZ71hq?ct6
z{2?d&aT$rx<8uQ`peG8N>|b4+3?Iy~oIGckrfmXK>-d&;7TUnb7bFt7`>B10D(xGb
z>pe3qX>&z)zBmk%=`oMNc}s3sGqy^}88hfY>rko`5h|(T{q08w*J=G~HSD0EnpYE7
zO1a9_&8_QsKr8&yn;kY`Ji<f3`u5mVBo%K7mH-&HLSb4}ig>`b?y%r6zqGWpoE;hp
z<RV-MYLPo>s)mn1Zwk`uw<KI=LgYzykiV^(KG2T4Ih%NG*%N_j>K)2Rcvn^B0W8P*
zgTL~PUu24AK;v4Er{mR>b(C@-4D`pc>lzqv^=IAk+3S4Cv|tmP1;^n`AcH9nXX+ap
z6AVX6@-W%AOA~;c&pbxOJpyM<Z7B8E?R6a+8&`X|_MbtksGraN%-r-)l;ePcFWTcn
zjf{*yOZaW0O74f#pC=#wZUCzX1Aef2=%!np2a*xEQi4^}O#w2Wc-(OZ9<KD0)>;!4
ziKf55zHCcqs2M>XN=U1Y-7|~=T4sVBtO-m5Eo)~t5%`W57x>Q4z5Bm`V&hIyCw*8O
zo0xb3m`@ZHA8LQ#J58_q`jwHDf*OX)`e@c)Fhd1_!->Xgjl=+sdAjT7+*!j!%(saW
zc{#0-(1Q|FepBN<6!b<Q8SZO_o1Uggk3j@ElqJeVX)SdBQ?9Jv=gLYEw6^ID@XN~V
zq%iAMqpc)}wvbhm#ofD11gYJ)|L>AW!PX|((;1S=-o2~$-sKdvn|4^!WYA~0KE14w
zwj*g?Mw)A4XlN}`VP8_ur3BA-3A{`UJpIN)%DBG?#K_!Ol|wrt?8aHZ+CsIt?fJ@K
zLlAOH(XuwcvL9j3c1zg%N249#Wka6e4K|-&h?})UN9R0)f-c*~y!XLABLmIwB%CJ`
za&swOYiVf#hFDRJtg(L=APqjb=7`e7OX30-a8oWvz9Y*fi$2PBZ*Q+b=CZ!JdVejE
z>sSd>$PZkj4~V!GEiw*RQ&g(3f`aoG<}EEuumw84pMwEUt-KOFX$F60s<nv!iIFm1
z@`j3=I;T`D2b3Jo5h4TGJ@j&PRQ=6Z<FVYEltdXHEno3$8-1>bDda?Z0gCRrx;mKk
zgh5Sd+Ov*CQS9+z$e@;kF*t6Zh5tG~zvBD~7`YhF`n2u(J|*@FZz}@ll9*s~3qend
z!w3+aMT1{}=knJ~UT|<QpvU$x<nQ15S?@)(D_ifiFkTo8rdw6mb`W!rw^?dG-FqXL
z#Df*kFAA6l9}(-16%}x*{IEgba}Ey=>lQM6fTpuUqkzFpiX^g&M0<c;@OE{zmF{%g
z>Ss|yHfz6pnJjGmmVI;7_pi6*<n)(A(2{u%u-V7@;C%oDw|l?Twuw3ay96e@^9(v%
zauGqkYQL{vzXDd-`EZAof4|Soi3aC%4V+UCA`e?VN|DQY)1#=c5EnldP~TuVxl=xE
ze#p44BIP=e8uQhCAk$1$4J#;1uww~ff-Jiigf)#<fY#w_ef>+52t2UvZgXJidd!Eb
z7hU0bI9mjb{rk3@Gl0f{M;_Fcetfv{>-IMvP^KTzM^_ukd^2L27g#QYn->t_iH16r
zS0~^bI}jZC)sDamV5|GcuY3o$6>3zIfPpAi0>@rXbyL6@3Qql+u4ZoM<;7VCMc~uw
zjq>h;p4c4RnCF$W&(^E%f3J2}qQIHq^f<`MD8amz)C^6XLG7KLorx8<`~MRn9k{z@
z=;IkiVNqV*(vp(f-K=u{Um6>KdLy`1@gmW*oO$tYhclDHgdy*;M1WR`g$wP+ni3J<
zn(o;-Wo>0;-K<M|(t4cilKbehv(HJ2$xZ|$iEG55-tfIon}nFfzC@M(aVS_d1itga
zl9c}hgG*s(XviMemN2$*g=3hb0z}CgfmM8NP2&y|aK~rFwbY*-23e;_s2x^qowA-W
zkLAcy*!gvWnKljs!FIHC&@U>#!hV=<_jbINWRBuKs9bqpTG~}#rJ4aQg)@N`dN~+_
zI7+5E9(!vrc@1?vCnFvE7xN$(q9$Z-;DNryD%{iZ{-X9@lA1wO=71iLRqR15!`C*w
z3@|b}wTta)i>@h8zWqAqyLaynRhJe3`C0et+Syr4`t#29SL|5rV8_J^eocpK>;M{c
z9lkN+Rgm8YeVz=cLBW3~8wP1a5)%_dqQ3%zp-m@JyZ-n9QGy8~E@`vT&${cOwogY*
z`+P6M;ZLrJl1|uN<;6tShqq$I-QsWUMJC94t|e?eb7`Qa<i_eqQ5afx-!@c@)K`5T
z%v|~kCh(ePiHTsBfySEg;9#(C9BAFgrc-{e%??pR3zYe<;Jf<w*!gYp<J<{4P%-R*
zH4Y$Bj|-K*Sl3BQO*M}tz2==O|AMtI@bMz7L1=$vp!!QyIV1RHBHCI}jp*3_pt7q1
zC*PKyM9DpLIyyz*$^M>U5vWgD>a6+vSwd1WL<*{rCUjUpJpvYq@x^<7v1uiF<3`@=
zof79Lx9!DyDZ?V)GUctd#q?-h5$jKLi3)Llu7H_fdbW0UTo34M#dDvD^DL`!0nABc
ziuikru#hPyK%9gotqve({ExN*pg4J|{pe0lDXYGtMpQ$j)4((cn(}_1e1nqwI~ae`
zAjoP5jBWB5jynJYXd1p!D4SiJB=!n|sNsQ<%k5EANxDdL<gXa}B=9EF$(3U%Uus{v
zXUS?yspi@3Spu%-8+F~mzD@ZbK+~S2qZO)=tC{S<C&TtYUQ+I5(ywj-a3-_tsK<-#
z%YA7iF6DTs9C~iioJPO~ZYcwql3DIGKZyi27+09t&n}tNp8@Uk-k!%5G5II%`y078
zpOn0Pi`2C=mHH<(-v8?l<WO{sGKz$Q@S9j^k_Lv3lEo}>bO-CRc&994t@uc(LPYSt
zmFg?$YTmzJ{9`kQDK{L=ZXX2p7Kp$keFg+1Fe(|ZtppbY?n+b#6%HpH0Sr&RBoF6D
zr#DkYI9sp0lYd9t)2Wb2)+r7zq_1J|baA<!+87ps^icTc&`ELVF`)OJk2O;lSUql(
zoGA(`0l>6VM`}DAOQdAUAfp3{f000#dO1EZQONCF1Gx5Y%SV$MFc_3*nl*S=x)<FR
zYHMfr`4?{-M?)k;JCq%f9)JJ*3<wBlq8)4n?k@5gwD+h`lIJy)d%{K`kf35UY3T0@
za{zy;ox{loHOS0xoR$oj1A1QSC|zT&QUb;Y0<#tnJYn{H`t<i)vpj^{l>2{I=4-%t
z*c$%Yj1iL)v-+#&)no;02Q@WyxmEM*{+^;4M0;kjvot@MG=mcyEIl6Zr(=6?dJHNg
zWFe#&7#ui0IHjOu5RA6IV<cmJ2=No(-Es|<)h>#yc{I^mAnX=HD)2O5X>_zyCn7~_
zPvu{{M}*@oX0HL$4C+*N%vHZH0%S}Xj^k^<egmxMcqKgfJ|kw9n4muMQ*CV_X?hbF
zU2ycd!rh>&vy>Re)t}MTEKvrC%sCno0Ua9~Q&l@QwN?_8SHI7I{Sq1YQgZv6mYyzZ
zo&XqjP%zE&QSMDVZ47d#(7xhA#D5;}R=!yt$dm+A7$5jOHIoM)i^TB3`ZFad96C4>
zKg`D^MZ{yhk0{ul9<)?aMWH2-37FJ+1-Ik|LUQJW`}Zc-mEQ-l@WlU(KO^wf`JQ{a
zzL0yq`u@em(QvKyMDFd_za5?Gn9fosngbByot~XtAk&KBSa+`&6X*f8i(Uc^mr8xS
z3|!!7;ox^3W3=6(apAKM0@0QPKIuF(c)$(*{XNZ#taM^K%Pval+q^+2#CrVh?`4(S
zyxkqwWZJaLv(l>yUyquJ;t;u`md-C2(1j;0BSXP@>&=!8Tl512I1qRcoD&7O%Ilu2
z_8uKe@%?#{du9R4;MM?thZlx+Y(%n&=gLpJub5BQWW0JHhjO``dHaNTk2nCW)_?@$
zH7aI1C4y#E-172s5gultTCmVo{%Rs!qcmXQyNBZd@uSn6*Wrx>%*Vlozdr~+lKo`$
zNS+=4d9)#a(ItQJQvMy^d-q$S&trlhS)u3OWVQqMz)N6(K22@7lY~<Nd-wo;`oT0X
zQ0w}(d-43dcO>dnS6rL91r38LWLhBxC)O&9<{6k?NZ3k10zwUTXQ1Mu<;rVX479Yj
zORxd_Sfx7G{X2KM0HYRn8wjtSctF#gW@m;i(oInLUkrBx-u<QhJlyp=dDp;cWnyNd
zuBO@b1*l4}{d)TK$a3=Rd~emrb{i_y$kMbsK0Xfo(<H{}H1`=#(!T%>0y~eeYPdJO
zm}O^?o>tr7v2yiwS&hC;A^(QUj~lVCY>98s2T~n(&{>g2Q>AJEoqGdbkoQd=gLMiD
z#%i(z%>e3t8X29HPT|Ri9yU@I_wsmbIHKJ*#;PTj&$gTAz}sgdEiFy{XwuGdX=rTr
zm=_G_+|Kr)cwzMF-3v;qxwBC&`HPdN+}dZg1KAQEQF6%p3MZ{9G%@D&<}a?^&RH2W
zdM%fyyz0`KGVoj7dO0If7k{f_>JgZr{SkhIlJYweY<>CiWkp1tY&u0nH4Gg4bN{WK
z0oT>X^&v`1CeyB$qi^l*+jR-08?#cYR|HY8$;FDOGc%(CPCYeQi2r9_s#sUxAb*ze
zMF_CyyhR$691qerAVZXJ!%iw$G?%5HA0Af<R0e1+Xq}8D=?uKS@vf%2roNd;<Rawa
z{!%Y(s&K=rvA!2;VvkE601(Ctu6*<R_wSaew|^ke7@Gq1wie+J`S~0tDiFGFqXmSM
z4a#@T&EweQg*+E7#jViLj;5BT_}B7DYx2Hl6oe7B0XRZ<&wcjNP&ch+kE_}R-&zFA
z6D>VE4PEE=KWj>VGMW3RB^ZCL?)B@}1Ox=`r^|qVWI?A+Fbo^Xu*3XMTZ+@n@9Icc
zu*43=tpC}*+P7-1Uc58|2sJTY0SLow)gm=net<WfF}_UGa*%t6BCrfVtFmRDML#8U
z>pef&Z(PBfO>Xwx{#cZpCVBa7{K?&C6Mr_=*1HFK0&It=a;*--h*YR{4yNu84rECG
z9RN2uA%6AMdB(o|mTBFw@QcGM)lP#6?NhOAIID~xs}C5*s3&xkY*yp+9WW+`5nfUT
z=^<d&PJiCqQju)|$Vi|K!B|0AS??7BN#A(W&I1K4wZ7%Ko<}SLJrkOlDk0gWFut|s
zz47xpwT$@w2>=(RXnOu{U>Awmc6om8*0hr;e|0LU5fi<P?2LG3@kJ~tJ$*KU{%I4>
zQE=+|kQ{X{C-%w43svwjnAdG#Yd~)2_!5o_V-Rk=@#L4PIQS;LY;qTOY%e%PP2Gs;
z;cn5k@i?3)e&FZsgz+`vrH=}{@=F|G`};9OK6db;WA$>ex#?Ikh04xBW6^2D(P{f(
zTE(Sb-Lhz$LQ;BgL$KC9>u|0w3!tQtIFeIArbk!Ub&-FJ;R?W72{b2^Dmt3=L(aQJ
zH&3s!iYuIQvX)&|eIZ|!-Sgu?0u2z!fR`-LxiV^C8)!JMfi6{Sm)|R!TSvl)S?T5a
zdJ88dy-^k)a;t5O&1j^<dPigkP$QUb&!YA>vsV|wR}+|_!1m^f)3CQZ1}qO7nv8Jq
zz*E!7)%EDB)Cey&gyiNNDtk}NYNDHvju}h`G|_Z)UAIO|iDG$Lp3@FgVGoP~gyBVe
zB)$gvc+ow~ATIKPEN&bDT4qpW!j5xBB|v2{?2&y_{_pHt$N4*@6EZ_*4$bEV%s;Os
zR%GOwoj#NelDA<#6mgrqg(P`2dyY*0&vW1f{kd#<ar2qe)v`2xH?G09OH3Z;1?jwh
zA7J-3Rd2t9d8Fp#l2!<U(`pR_ar0Y^pxNZHN?Y|X5LDrZ1qD_uy61KL>ZyE*qv(A|
zc5soqec2JA#YXIA+Pyn)y*cK7TTn$=IMJ_zKD4)WKG>~22h_^<qCVI6_uZ@Aw5!m2
zdBvwGRO)GS@?7qG6*S|aM3vbO4)*17SEEURLd`Q_w~jB~h<w=6(H@LOJ%~?P!(tc{
zA3FTYr1YJ@48MhPyE*i>Rm1*j)eBiE|Fz4A%i7ZC@;du8XZ=Uur6FR<9#*!io$F)$
z_`d~6ew993jBrr>*+olz-ZMHFFTh92OngBCkf@*!LaTLJK~Ge%ApH(CaQ!1;X|u_m
z2s>X!%!64R=d;+~#G$E-&5}w#m{X4XSLJ2A#Jzl(KGb}FbT$9#g>F&y?`ykqSFST(
z5PnmIL!eu5Y<&FGLOKTPmNOB2NI`Ry%c<MPshwAImnJx@&@DJlIQ}vQbotEIJW5+a
zVsW$zdho-daG^#dLtyH%nKyYw1|4KtYGIyuh@X!SqeuH7@^#6c&Yd~A$G<}he1G*O
z&iPzC8@mpjyWF$t<8bpWny|@wUI)@cQ-AOab0!Bdm9|rl2vl={nGsZ;cd$B>Tp}SR
z*=s#UD6>TxxyYaN=&+{&VkJNXT>@t0k=$?RrwVdbV&|VtmcLrgMFvpLCcij4ZYFaV
z%5UJ_Dan!xVDxK>mb?#UpHCg_RWv>1fOopRFsFej*)kjFlkc^#=Gb+`k>Q#|-8!H+
z+DtShEuW)Zp*eNCAjYK^l>$TsFJ8PbFc<|dM=<obNUReZ+$v+FpkY2f3!k1BmrSz5
zNv1zoHu4j8$N~<gP6RvFvA2c;A!N`9olTC-@B0>;1$9CH0mz5Tqer+L%vM49zPQw*
z+=;n<+iP*>Gd2X`dmiCYp49qs`7?;6>EFQgnY=gW>9FDB*d4kyCuO4m<N+R(@DJF_
z0>EApVMmxUpM40-I|A+5i2Ql+bHi=zNEbZo&(9}u_!hNxwe^dfaiE3MDzt_pqx=}R
zs5bthNDz1}!AW#tm{N}qh(_nUmm}itT>YWC+HXGd9!r~OifoSW3R`vs)9BLie@;(>
z(gk0T)G03{Cvo@{f^{2kJSZ3#iRC5o>b|ou$+ZJmi2dOf6`Ekn{@92=4ILwSAMg(5
z;kxw#+Hm_AhBW((pX%5Ml19L5eQRqAFC{4{35)^!!jty?Bqll<<<HKfU^hy)g~Qe6
zJrzy3sf7)dzfcGSbwD}^f=nj~UZv-OpSI=!3Pz6*Xhhz&?kC{Pg8o+Tm6eqR4`wP#
z(-*mPy%&ZS--o*Tu}pPqEW`}}J_0e(|Dc5lG_dpdtMzAI0sDWKg-Ll?UlL2#O0WP!
z3D8G&@cc#GjFwbUZOII_!RNA9YnQ_=I0<>p+<II{H8~~ax>;2_&HM5}(zNY13VA^k
z0HsU<2Yd}-Sb)jwB}6+V&CGuiPO@5PFHT#23sHepNK)d|S?UmLbIoW1_m$S)Yiqi3
z>RBxVDFhixK9Z|S6tbZK=k5{lIL`C+!{<8KU3cr_xkHl7EkZ_D9;*`vesN!bHpzLq
z+ONyBINgl^5=Ee*?iQ_px_%9`Ns}!o?qfK=W10RWU1!h|njh%t>Ct%&4gQzsClBGa
zBM3N#9Xi9Z2PSZbRDEHLz`a_#BcEiKdZ)X~5!_c~U=3_OPbv!)zmd<>9yc^Oe-I&m
zzJML7_VhfbM%)1~JJDj#<}t@;rY*Dn8EgcityBV%-L>4Gxu@!$lsX#=W>o6*q>I>%
zu(ua+aRn*`R&J3EF3e!ypzs6t_U%d>(*F5Gv0W_4tBf(nbN}2RZB238&Cjpiu%@zd
z_=j}0tun?Eya9I2KOdBMzpTJNcnB%wXa{hLx>I`nkfJ^R51{G*dmYVdEmA{3KGW+a
zaBrwWW_s27)T;M5{(V>*&l=K3di$sKMOg}FQh4awk1Atjj1%^=3JnJ(#}JRA7=X)#
z9|PQuTfAf?M=rp;wPGB_K_+JUZ{_TutHcvXJy7ylFgQXrcp8`(Rr3sTSw*?q;7yEu
zr9=GMo^Rfr^WARz`yVc(Z*&yx6`fU6#RBfyKLOQ<lnZ2D=kz9bXIwP+(OImK#yy>N
z^GRHXaCzO;hDkF&lT@)nqMCdhM*eDFUa7V%s#mIqOsUA*dv{SqZRF=qvNV~}*Dsh+
zvjE<<z6m}1yWLe1*cH!~3nqkV|7h!^3JD3(cW_RLzsuU}aKePyFpCKMqosFR<ZTcg
z6O#`$GqGzH!23%?I}{~}-^<;Id``knygUppO}!Ul?6a}CX_LM{OJXcibO+az<CPht
z$<sbmh9&c*ji$of67{%n69WKo`(j0({KMA^A~C>mS297R*Z@H9pHiXaNxi9(6NMh<
z%u80ge*yA=NB2R7LNLcze~EhSMtj+*V9K3xtC>akd|4Sk%^>;#3}oS`!otG3NovDg
zFNkZD&&347>VTlLL-iCOOiP7!%<Jj0N6~tTTqoR6;-K~iByPkHs5pbX4Gh%@M3pcL
zTEkJ1k}C0FegPI)4WFSp6YQ}tFxWpB)p_FO%BUNcK)r9&w3qS`C@I;QKlgcrR=?^$
z;bwu&GtUb@-;GIU$}na56O!@|0`5kr8a`Ol5)lyfHRxY_$Ro~(c^D~PIoLWCn|n61
zIt~WO6VP1KiiVV1O=8+y%d;b2=&Sn!AQSjHJRD}p9WWWT2l3c9Wl~@R3%qj%VN^k1
zAhp3_p=1Yj6749cH7s+l47Vg3R%0zc4tpyBGAV{?sC!N@YubZV`KuEUH_0T$9}Kv2
zFJ1p9y>fUJ<9{Vz>`Sf==6*DJ$!g6)79NG>hX1!vAt_&jSS2S01xCzUV#D7*co`}d
z>BhGKWMMEc=()}wi0>9Jdo)=pcZdvF&Q!u%AF?yY?jQXN5tw=oxD#DwzUY1D)_Y|f
zPY;xkJrqQVi<!DWHOMyjXxs1Q8Kk`a;9#vXz7#M2Vfw*aeVebIaLiHZt7}@mfXBb%
z;JZo!IYY@moZB=QB9R%01BhI}J_akT$o*6_e)T%plR@M1{k;ux0*<C^OpYDMxLJ)2
z8<1<LIiFP)Qdw0sa)h_(Ewu;`D+C(Q#H}$nYJe$O_DQlg4S2dd-*TYrI!Vj@!Qey2
zB!ll7WMU-%bHRAvp%9Ft`G7YaV>#@hR_!~^kymTxZP2t6COmX{Xx_b3f}Os{2$<!m
zi()XF1#0r2V4&5t%n@Z9s!cpPSizuH=9B&n530L|9j}qKF+MV48_fC;j#cM^2+Z)K
zJ1qwTe=?67C(R?~R?12m1Wx8o=jAyp?is%XB?eJcF}o(_;z+MPP&W`%!NERG*MQ7D
zZs$!Ewqlhya$dgEfW(F)?uwLT)_04uj2l6UWFgr1aphqFAA^gmBm!e~S7-Y8&#oQq
zinELF3)?Q`U->x;c;D6n3aHKd%-x<ojV_~`*x|!3jC@58L}5V*?W>qxZ+jul&|mMC
zSH_mh+b%<yOq<fmZE0K=n_5A2W0ooi4YGnfe8=lrM8qfVsWJq26#uJ8SqA^DtSr(g
z8GNZ2hc(YL;aI@fEAd**7$hwe1_Pluvbf`J=ALgHittVL+LIMM{Ew5dQI>)=sK1Zf
zPV|3-IwHpVN7K-G{i{~!a$i_Q>~t9ggGa}xiCd0ANWN024=@b#xKPJfE?<M_C%xCS
zl8!*TOKFvAvf?9?&G!P?JYrpi7QP0z@aG&BdzHaUR=umt4R0srk+rooC~Ik+l)<ID
zw*R0Whm@@F!}21y1AF+rqA<NDdZLRig@#{w!T-OiIDe6yeIxha`Y7eM<9nslqTz82
z*jSSkC%tL<QSDpxp1*G%xW0^5<6(DVlXLmXLz=r&9h0lUBQpvvH-Q1_=zCCNPmtYW
zksPdmDpVx?{J~=!_^xZ>Hz@cRoPL--Sb3)}s+%+-miN(p(M)u$#vwVFfFJ}LbBjZd
zSsMfPt_S5g>3^^4T|Q3!qO2TH^ot}+n5Dbqk#_yBpsA?9Lzp|WJSk@hbt`*Vo;NT|
zlzXRezk)`7M%?Fz;uz6H&0OIiHOJFE{-TIePOiVU+E2=5>rhFm3Q-X1p~8+Ab_Sy=
z#7^~e5wL_neFzMjPK~66t}V|>@1|-h2d|Uh8eM%+y{ErTbALPu7l#^=YaCF@^*-b5
zjo;=EJv_H4kXH!|S94RJ_b8=?(kaZ74nbH|@J`_}a#vqp@+;jrovGGy?D#Fxb(_nV
z>zC=7DkP2@e|YEMp&yst(9-=cI3tGqT*Y}yZP;+u=Jxy{?iKr=DVxTowSgg<#r>jd
z48{6s?Us5TLCG7|ELIr9Zc#GuFQuVsox6#ehK%PUnFS#aZe=MGtK;!eH#(lD%~CH>
z!tjBa>S@p0WIzSnCxqG$G3ivDbIDV=C}oT~dZhQ1crrGYCqA_Adu3A$sd1h@d4H<D
zMLHiy?O97uoPZPF57Od+xv)2v@LZw@4Nz^imcB2@nBQL$-ZL=xDtGaL**JUP%3E4N
zsm>%|!L)k0)D(Pgich9-%114Q=M~PJd2g&~7;yL5U$Ucdy}h%B*?REA8d?Ug`)Jn@
zA9jlQfAh5ErA`r=NHuwB=qSzoUR_3zoqxp8h=tSmfMvHNnhVtL0^>;l%X{Q|f!XX%
zpA=^h33!^S8!9Iic}I84+Rv_Eq|#HCs|`pCH)mewduAoogA#7r<$L`V`lt~fX=%-a
z)PsjUymt(eA3`WXiblkSj2b_k)^dkc#f10F3#q%^bUILt_q-!lR!3DFNbi4r<n=_F
z?=r`unz%T9RTjw-Y$}8hkMc|jIaW_WwI<_y&ns3A_FBa>JkTjWZd}<dIyacrn3#Wr
znwJ~_W(9j2bR@=Un7}MgArLe~O<BPZZ$v!s37DAq9VA(puVMtApKfPU1={gmbqb@3
zpp;%c1%p#Iwm{BZsLSp)(@XxatZ#glH$n0MedN4vc7sMUm9JO$wWa>7%n+^^MIxWJ
zg!^8>3~E#}85%x1izQyWIjB}f+I!4SG@q<UnRgrs9tXJy%!Gn}^Qj5ZE$>qsXn=p_
zkbv#YMNs7YSb)V&&vLkKrTX}mjh3#DTHT;-g%l^81FvYgfF*yqscM0#DprW~graN1
z?lk-@i3<8*JLzn}x$P%)>QD)R*Y@``vXx)+3wU@^f)jg_+*#whj#6Mg?qe&4@73b3
zlzrpSw4GU`ql<&4&K<wSC>0kMr!rxjq={2+%GS&yAweSBl5v+9u8)Orelrl6;Bih_
zI@Ww$q~x^oyfP9!_-X;dA|l-SxPLoVIr3Xtjs6bQ5}T4@zlW#nr}QDsxH<G;Ptwm?
z3aaQwTaI`Xri6I7^e^^g6}u*fhIQpQN}NbE&Vi3a-(i2u%%&sD@+lbSwp+9iG?c0s
zM9{be&P~NQ{&!AyMe@_P>3loyEtUSM_p{vpwz=m0d&npIp|k-r8zv+vNX!p)N-m4b
zc>9R-lS~o3xv^R{9akvc^}A~58{a7;etZRw8IaHsmHBCzrZB->amILc%Y*3W&(n4J
zd^@VO9Fpq<Bv9uVccF#5Q6Kc_mxO`V2BR0Hn%qK+)gwS&N00cRq#|qsU^8*~I4O!N
z=`E)z*FPG@lBZ7COkw~>nJsQ#x34kTCxLzyVvo&fNGPSNGkwi^>}z%E7qV-Abazld
zLjrYR=zB_pZwCF1vx{_?XRZ@8E{3I&?71j1%jrBz-MEo$W>RzM%6|!vBlZ%VUUg|u
zSL@HjtRFcyl1Z6|ZZ*9@HlJ<?*!6Hf-ku847sW(PVrX{X-luo$Iu)42n28R3(7<Uc
z-toZuZp)6ZxkI&j`?DGcU%#2qKQpvOF?<rya!T{z*EF{Ts-bD}0~9x`VsN*voq$$)
zm6R%|9LP}oK?&Y5xl|E*E%*apqC0JNDoz&FH|a0G_#Y?VYiJSbd63oESjrNCYJuW~
z4Losjw`cxwef+w;CW?}QMIYACgkcsW@|@xdQ*Ge4PlB1o2bRB35U-SJG^Di(wU*bk
z#+@s9zgpW{OQda`l@v&(ZByJw9z0GGM#Bv)<b*7fJw&<E%v&hhh|ZeNMf{Gq>&aE1
z#{W})Wb*W#2FGL$)$3oM>jNHqR%@xM?Nh|1kHOoy2+taey3@Nwr0d<g7?y;ysgX=t
z!N{(WL;E`c9Hrv!ry;#40VXMpA{0NnCiW)eVQ2?Mh2E%8_j$Wu{ar5?dpJwsRv*ud
zIuxL%<tiAFI11)qmQSE?ofFouYWSKv9f-l#?2s^moueP=MntkoMU<4IB>fm@vKI-@
zQXS7A2Z7%V$*ZG_4Sn?cHtP%G?s?@-mMR6}qehc*1R|0Xy7nYb49QDb2G60ON*_MF
z`6UIzYYUwaE#!0DbEbmEJ@z*w8<5x`F8iFpvvf?33@utU40w>L%CR#sOG4l*7Py@G
z{(w|`v!7&3G>>7ml$=2%t<#oADGge(8R{az68j`W*}j%q)LT9S3s(!n6L1v7Pi{K1
zT{C3h3Mnh3m8;YX(|maZg##^JxPxZvBCO>QX~YmUB5k~V00mnJ^~{cS3Qp|D8vj;t
zSuRf@W3wJe#)6~mxnd98uKy*qQpyAe{^Q#4XeCtPmntJ-8{DjOP#K|uCcpy|t(<T;
zvZ!KdOq}d>NdwDim<4hMU~5aq7!KzU<Hyf8FzHV3TPyB!j$)Pjek)mnv@ru_ug2K-
z_N25RLgJcsWD1zqS``sALvYETZi`M+lu`+NZM&x3$>N+6jC`0x4usehu8SLN%74uh
zbsGLLkm)t+GQJ5j!vXAW(o0%s*%Vey=9%?%8w~;ld1&8%DUjqrWF>S>+Ckox6s$Ac
zZHsDRbfhz0GPb=ZWu}!T5J7FIHCnu+<hvYQt3xc8*M&u}LFppHoHB1nrGy&WgW8S6
z`f2^{Rta&7Om(e{aF}UGpj=$Mde{>_D{-B>UAs?_p$2%~k|3$+`mVMMl3G%55IYoC
zwRBGp_jiH4>R-m6&s0|}(xB3UV}>sn%PKB+btT;2NO6k+U#QH2GqqmvwOpN_a_?dE
zB*OeL-z~dD?J*VfWfa;RCI!L<$xlir(IUldrqxB?IPi@|KPj*4*!mirw@i5>kLWRb
z+2H)TB~6XDY-n$UI=xKF*Wl=9Nxi|{k$+zwHLI0?t(jn8hp=c9;8besR7EtuGht4p
z?XVc1pJPms#w8Nfz!sY<6`lfZ-y>hs2XQhSVQS@=!y@jv#;`H2`a8$$K+{!wwn@Ve
z^jXBh@esrOc{D9VvA^@~Q-<j$X{IcSvEa+_7qq&1r{D70i#{`nQ?}^}qW~=#w|!r$
zH>BvR7B6ao%yJ+F4DF_bT+C8{q!vxK3B`Qidz&u)w#-BEKIrTDJ*{-eLbm#P@O!P*
z6E)*1-lOO@Dr3!Bw-Y!L1r>m>-bqQR=gj&}=vSr7uyl-K{0=des?*9AxJTS;lIZJ|
zYY?ooTWER>KiB4<PD+E+IwFUo_I6$tC|Q%31ZYbqP3+m_!qp&5i(_$!pShNRWbb9N
z5Iz?tW(^a*LB_TFqG~}o;Le4rjzR1*%%3k>iLh7yp7fLmU76oKTwINdTu&q>`ro$j
zs?q$#jGZvOle|1X7>pevH2Y2_^v)u##q5!xQy4w2vNbo}*kmK=>6_`qky08RH}z<D
z<m9@R8bah+9|Y$S>HOs5I~8eo&=7;q#)B4IWu29$lcr5A8V_m4`4~iX`SnqJQ0wP4
zznvVcN^#FizFoVcNl<&F#(@h@|4*?&EM2w8fJPrmFr*!VZgioK7I9l4N+Dz{hZ8bx
z$uF;G-h7PZwK`(|&9)`~-J9QTk-u<}s`?fDt$!;&4z4oB7|)(sZQut={0-ihH7&J^
z?BQZ-Wjp}JlRrNy`qU0d^|`M;2(M{tq~3qBXEM_a^>jU)mHz4dLslUh>fOml_qteI
zJzNOifD_)1YW#Kna$nlFq_tJ-jTsldL3hG`stRw^lBONflOvP7k?AH*@soAq&-P_k
z+g!8Pvv2z)Q<<Op{YdTUwC~!tLvDYJL}(sc{@S<yEcVPG0F;PXa$&_%FhuDDtV&4c
z9x;Imga9n{9`ShTrxu785Kcp(zpZ!8PvEp>LEivJTAtSz-nG1;aVoLEl%&W1IIOtT
z>|LKC>8XP#4xhd8O-v1@aIeJXGW8W8w8BYmzgOQrr}q>3^Wjn5(D#Y&v(q2ECw**I
zznX1!(Z*)qlenw$m2|Aeg8JJo39jkSuiSlG%Iv?eHqH9`*ct`MTJ+pY3q~SfxL}Dq
zuzITL3X)GsgDAd=8nKDsA45Y!`2vJwNk&C^MyjTUWN#yV8Q%v!)8Anv%q*H0H!cG3
zCAtD;EqwduDZW_kcKy%qb72tYc|fxi@`FAr#mUy67U!uzB8ZWU|LJHjLBw9bPD!B6
zZV7wf<MTCQ)wEy*#4#jN>fP@Iur++kP%?rFTxEmYjg6`)gDxHXU9kZNX<wN<Q%yE`
zmKQheVuMOdYczXw4?QBUE!`Dt%Mo=Y<_>NyXh_$YoiF}Uqe)D_!HN7AE1{)n*NqZP
z4#n0-)Oci5={OlmZc~tw6(!|7#M($@O#NejKn^_2itLm@#u^s9_4YN;<XER*5i9Jt
z+>zEtlFQl^*{^qMM1)zK32%3~b%gfLS?*86&PypS%Nkc_55(Gcpiovdg^G*4XgZp1
z_wHO5x&5P_+B1SPLvCDP9^pZ{9PCar?Th*g>aLCR?vGCv8)ha;&(ELQG4b%ZhP`;Y
ziGNk3hSwSu_*UVavKw)nw{l9RjGe~m%dvZvPE%4%Wod|Hv~mM-i9`eL>iF@QPjX3!
z0AMW8cQ+h;eU}MqB=Wr~Jh`|Vn)XY-5r&oA)k<5G@d3GvuN+d&mK|mISRpt1X!Gc|
zC@9r)7(O7>h`Dz8v#I&1ntGLh>-B_S1X>jo+JUlA)wIYQbyXjGrIomz0Kk-_-wv3P
z{!Dqf3!MA4Hy~ZrB4G3iXi|FdM{O`IIEW^$bIT?L?|>>u^QsD&N?C%65wTd9^T5y1
z`1T8u*I_>RxA`bE+Mzsc`M=5T4tR12f3oo2Zu?98gaoB)?pH`FH0NWmB3r#SYPw-;
zW_~h%K={(xr|e4=nz&2|n_YtoLaX9q^h=h<r8IPey!E4{Mm<*wH`y3Ub%K@I{oru%
z+XFvzLzY0Tq$JP115YG9qD7Sy<U=V%%_!YMaGWg$G0y|~1nf%L4#^K#KQ@b%Sf)Rk
z#obC&r|zzQr_o~Ah>~$M`KjF~t-D9;L6UQK?-nOpy7XKmj&t<gY#nTe1v}8=3fFPz
ztoOnC6~YI?gXgW*kIPJ`H_d-C3I-QNq9@@yw#>O82Uolm2GX!<Cd5+-vjn)49Hk=#
z`e|01#WWhr2V7eLHI6?x^R0}GuLr4&vTps^4qm_SUXSQYCjHCl-fh?{JK?YG%1gr}
zC)O*9T+0*D1ny=KrYZ@$uPsfx)VLV@mLw<rikttt{N&X|+g#T~uQh(ld)@kXv9opJ
zrg&-yELc@mc*AsOMgJ8ZJ~lsBDTM!*6AnyH4;nu1Q2Ec~tTkACX83+#vug8LVq+Vp
zBx~XGyXG@+rW?Bqq3^C4sR@xJlinl#qmqEvKigvI<K$%YSqt#`FtK4lAYSMQnXPQ5
zzi$5#0D@NhkMaj?l<4@p0AE(&qu(Y2##-J4S~?R;8Os@C*aGGm3iIL2MSV{2xljO?
zCk4JDi+4r^viOGkRX+XuH&UhSRqMLUB5kL-VZS63Gviq9SJJzA_Vj73stKtyX+4F2
z>m_l-p4KghTJ)V17NE9f#_^1zyDPki{#JHuNK+@S-@8>cB`kPFslC#cdhC{SydLo(
z!j`HIT1$x}j4qpQPX-0L<Lp>dtndAMU2E6s%U9}|7<Qs7@P5bPWnwk6g=Bsg^Rk)=
zlaDx-9C&Wu*Kj@Z{A2xP%v-yJvTH^fNLoIIwbEp2?kxx^<nFxKqY*(t-0=veaT6D~
z{$!pE?&~Ns=Ojhj-}KnxGj^Di#CNe8t)-cs{iZKlF@VnJk^B6akv3`dQ^T3r>}=02
zR*AdBZxLA2u#)<^W+6usToz{N3-#?qkiAY!=t=ShdL4fd8!9>Pr5IZY`*$PiJ|4J3
z7sX<h7Q37Wx3-QN3XgEp>+5dTy?an@dDD)kyOrX_@rI4$0oA@adsw@=NI0-QXm}uF
zgvWhLBB;k^(yK4qfAJ4O^PW^KaDRSaVcujo-0rz%pjGNRC$aNZf5yWyHaHDu6M=d3
zv2$0?tnR77Bd{>EPFk?vKL=sY4%@7rw1yOhp|u|z#wxck4IwEbiC2k+6Jv*pt&1#W
zFMeMCd404~r;W|HemxJ}c9vGX{WUAI2*$WztY-(zA;9S(1AjbX-__d?5##+vxk+aR
z*j3tcx!k@*Wi1_cu_Q9gFfK@hc!2mH$iG}1g+wgrGKC3?@K}$`vMDO=qee?44AeUO
z;jy0ykf6tqi};={v(htTrc~o7#hQ%D%_Vw2Y@~>Yc6%3Yb^@-$KZX0O_bi(59w~-W
zYtD7vec3E^5hLJ|_7gs_&+mHuRj}n9td{RE;H;aD-Atu-R3bgsaGhM+s!zF9|91JN
zlj+V{O(CD&)1)4aRS+vY#QRlKD#>HYv7xWalE{<_>exbZI(%GEfsI3Alqya8t>ouC
zoes>npN*zJqkD#m1AQ09i^~YD3Ee1~{x0|(GiAzqZ5%(m2niU-9+2ASvg@Z3Grtzr
zPAvN0h3WpB?--Y!a<n#E_DE}7Y!M*bU48l#u-PPXjzy>ilr;#wK8Qkl!{P5cxt;@a
zgKx^kiEZ9_Q;m8Fd?%f6IK{`{AAUp|i0IMlB5dlCmZ3_-e~e_a+df<hDX7KYpd`pu
z>>@|fw}dJKH;4)j^bA3971v4@^fTB9-b~!6;#YI8H7VE5$<c`lWPz!Yh|4_ULNEYN
zDKc#5iRA0h*GW)FpG_u3SIcR{v4~TP-41`JSE#zi;B+$nQ}1ZwO`l?#BDZp0Gyk|M
z$A%l?gcqxSk30}%$&6Vv8t8yBPDA`Ebv#ity8pVfZ~?*0ceoG1n15dZ<JM2aJHKj@
zfTb2|1#)CM4af+6sId~0NrQhk@&Cbr9|9%2j{Gk&{>}R-FGNJp3IA1VJ~ogG+lj##
zBSTMWc-@rQ-@)A-J-!%K$0)^wEW(|b1#vD6Xv}kZ=n<$etW>>Dr0+FRG8~Ux+SHE>
zg&ml5Fe1~P4DyTZqHwl`#2~edu|&KF;!oIUI-T`Jne}0Hu)yXNeb_3A&WA{}7bn;a
z8vV8`U#0NDpDtQRL^Bh`^(1@2Xl!IPZ}sUl%0!v106g9J)Xb1!d6<Lu7GTly%R^#A
zF$*sb$htleL+#Yb0NeE=tg(eFq(}S_OjR^@<Dvp-$9Wd0dTy%E<Dt^rd*@ltI_iqb
zz1wW~pEYZJdzETI+X6zke(cMt#i{$dm_XMqfGp}@J4vR<FjTDpSHqMYL_k(4PC@BR
z&#eeiL`pf#K*givB5hldj8<LO4}`VOxX9N2%3*ZMpoSu3{}mV_a6CiO4P)!tM|#+C
zq<h@SzirqByXE?ml-uUfp7R<<izs7k@eaWIUJQ_TH>|rH{fYdZ9UxmM#157pw3fP1
zp4_1i<DD=0Qq={C%e>o{=ivPD=e4!a>VY*a6(oZb1+IYyS#+Ed@lbB-luO6lODBaM
zIV2uWz`yE2PN?V{;l^7J=%!s>)Otv?o?Y;~LEIz#&7ct5sAWo=D+Ih4e>4hMZ#I9U
z0->-kwhWeSmWNr^IkVI}Ejxr;B7s3Q{_lrfkg{B%tg7D)$C$-{XN{n?SD8vb>kKUu
zdGpluvpR>N<0}TvgaH`Z@73Fm>2GrkSz&5|#*e+Nhr95?bPj&a-@3(|M8!EzfyFYY
z8QoZ(eIwY9h%i(K!46GwgLdKHENs5|v)L(l`LBK685rly4AUA^b>=@pGLR!NbuXo7
zo3=ks(M^zvH_-Gh3$dgI=(~qdVEbOIX>ktDhm04Dji~a6SJ_9Lkqid7yu$A<ulKP2
zHMCMTeM$L1GnF9<t&BkL<E?_%tbkku2q=h*nU7LjQ*cOkyDPrFb`DS9S!4K`l)sX0
z_SRmi2wr9bQ&n&|u&t%u+I$ae0bCCcCCE3LQ=2_kwqjJk^%@?R&1jSco3+=}?NFw6
zuhIgIg8zrTw+g6o>%xU;kWLY45u~wbX=!N|U4nEf-JyV>fI%oocP<*Fk(BQ4knTm-
znQN)v-uvADSO2-$qMLWdm}8E9#+<v=hMBFL{a_9=_WdC|QUkJszoN`$o}z&uO~27n
z=jBL9g_96!>P|@1F~5{1O9PGEsEL<Z>)-;F>IVaM+&g`3bbfx*s=MmVcNKxw)4_U+
z5_UrlN_&F&^KJN^yDeK?X%@w^i-Gl+h7dy14f4x0T;tp9fxuoWCH%kyOvXZ0M;S4X
zej{zw^uf54q_-9gJgB#fKSc1ta8IKdFbrMG_Ia53*W@rr=?cv&KFxzLm>-La|71f|
zy%1#@;m~ByD<HQ4s4#<Jjpx4C?UToMGhiGT>1-mzRZpJ{NR8%aNSwD~;M_rZE`cP6
z10HI?X`x4-N+HM7`;5jO?(=CTvcWJ4_g4G=x^-ywOk2Nq@z0vN;r!+ib89cV<f$a+
zl+nu*ZwXpsjW{}j=A+Ei-5An%*@v1w`>%_Mqi`S3Y4UhAne$w*bE;s!Wl2;Hm*lQR
zt@U}8($OK#l2!Exgz7}+u#yPgl<{v?uzU!AP$ZA`w9u!~d`{~lFmU-$B;6%zQH5@i
zS#4T;poT~SB7P<n?X&5W?_hi{#>QNAzcoQ;SAEXGz1dF!n-ICw1C}CY`AJoQZ`erV
zMFi;+;)0jO_#}r%TVqEOCoSBMAK$IVnq%eQDC<L#vP}=%tS+r6N+qfQokmW`C{F@*
zFuoMLNSZ~{H2M{|%$3#pT9*y_lqIRdAEx(EBeRY|n-QJOkV7LB>nSO6x+w3AP4mdf
z`sAB%A~~LKO;<xW`U||Yr$UE#KkTqTQf`*lZC2iTXKm!l;fLy5Q41nb>vUd5hqb$M
z;AllL@X+z}b7MjtjhvUF_~NO)@WXJxWiBOrd1}n)pyE?>OXOsR3#QWRFs85k5On{*
za2upl3Kb8tD1OR9hmk`g1$n?T4|-MHL62m+WtL2O=WPFjExaP=1a}_l;<^=e5Cc8Z
z*MDezBPRqOyXX1Zt=fVzr;r@dJTi~tq3Z8p-%Yr}bc-xnKw;G|13=V7Gtk`zoX}W@
z5uz$eE(e%U{D%43W51ntbPlxS|MlT8&70;GV(8z7r-J4%ac+sb2^6_PU!{=Jp}fyA
z*1@q++36tb7<)MXuG3ICJ*jy!GC<r9o?k|hPCEBEUSr5?gDp?hcpWr7STR%j8fKsp
z`NZjq5ULQ(_kcaf53`{&8`(;(9-hSR>TfZl-y*c1gHBv}#dpm<9Dp3SD4}Rm8ZYB+
z4802Wz;h4}th5ksLBgB!Tp&y(=ee)(GV8EGuGjDRW(zAySD>3!<2`CQDVqT8sk7nZ
z=T&W4!^uxsn$L@^ywv9sj}?cT?u0p)jIdcGubY;TlHw!WDmoOcAlT8Qy{n5$Kyc04
zcivDtBO%Ho=?_KX&olzqZq=KKD6QwFX#_M&qnhAgHMW-ICJOnUJwX{Ge9`)zg5=(e
z_T)`EIrdnrH<<p-FTHj#xLXsoDPbAyaUYn`--3Fy-N&ErJBXv6n5g<4GN!tIaeSvF
zEWln$k>*F^M?reha&p}Eu(I0!HTi~T)F)))VsRwoF0UTeSt$Nep{l4WhUl*K$YQd(
z&>CkTo}3stCOq$k7T5qFKm^nRZw3zb_v<bKxhh~Yeq^DCHdfjAb;|1pOLg{7ec!$m
zZPUDQPG=;9-|CyJYw}<hCOar7AaI+~q}4%QzO&f0GXN!cnb_aq&Ii750^xr3WGV5%
z`+|DugvuT7Lx1kSya1^ov=jr7>NNOdgP&%K6wzn_19d(7i{y1}V|cggizy#t(IYVv
zH3T9N%hSC&NwG~@^eZ8v#-@6G|22ec7i*#cG=E@adX3bcLL|_02qCc}!Rb!I!YO`#
z7rnVj(ib*CbWxSf<j{&H!q2DJp9~-<f85<KW*4<P-UL!iV_Fq<`U(no9wJ`eyLjSV
zg@&PBRnl7JCtb;phT4!-(9R^jjnN<2HJ9A=Ye4eZDjUVX#C&;vanReFC}Oy93TpEG
z#6`17ECl<G)fYcW<%G|uuYtzZ3NN4C8Uit2#t{V;l`g?gq<!zIG#Q*lgCHy{=+r67
zfl(o$NSwPt1e_>9n%uwdM?mFszBmf1v5H%eFbJy>=rb)hgs>9sC{&r<ipAVCP#%<R
zSsStytXJsb*Z<j&%3d!OC0=z0DM40UNRGa9mRBPY>kYPls&qshc*52wyRdK<Jn$%`
z(jVV_>NJc;eVf#<jTc?}>CaZK=!14lHk$CT^@Z#cDY<vXB{9?<kBl9}tko~)3qz*?
zYydoZ>5~RWICpZ@Q}s7)yXl`wpw);Yg@w<MLK_smZp)~OdSM8>FfM93`p~i4sus+^
z@e#%3LK^9JF@Vbgm#u`<+AfBKNyDwU+f8cOj1)eSy>Bs%Gu7yDh!>S2-#0fpr->PJ
ze~XxGe((e$H-dpSv!wdr@yn%0Du>L0dEV7pFYgfQpxr;h<=Oz~lZJVKz8HnpS4bcm
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
bvv~h|)ZV2eITgJM1}-m;L;E;;LbLw|6_qN3


From 4839c234329c9365bd73668cb17b198e6345498d Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Sun, 8 Jan 2023 19:04:24 +0800
Subject: [PATCH 121/158] Remove heap.md for temporary.

---
 docs/chapter_heap/heap.md | 54 ---------------------------------------
 1 file changed, 54 deletions(-)
 delete mode 100644 docs/chapter_heap/heap.md

diff --git a/docs/chapter_heap/heap.md b/docs/chapter_heap/heap.md
deleted file mode 100644
index b0151622f..000000000
--- a/docs/chapter_heap/heap.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# 堆
-
-「堆 Heap」是一种特殊的树状数据结构，并且是一颗「完全二叉树」。堆主要分为两种：
-
-- 「大顶堆 Max Heap」，任意结点的值 $\geq$ 其子结点的值，因此根结点的值最大；
-- 「小顶堆 Min Heap」，任意结点的值 $\leq$ 其子结点的值，因此根结点的值最小；
-
-（图）
-
-!!! tip ""
-
-    大顶堆和小顶堆的定义、性质、操作本质上是相同的，区别只是大顶堆在求最大值，小顶堆在求最小值。
-
-## 堆常用操作
-
-值得说明的是，多数编程语言提供的是「优先队列 Priority Queue」，其是一种抽象数据结构，**定义为具有出队优先级的队列**。
-
-而恰好，堆的定义与优先队列的操作逻辑完全吻合，大顶堆就是一个元素从大到小出队的优先队列。从使用角度看，我们可以将「优先队列」和「堆」理解为等价的数据结构，下文将统一使用 “堆” 这个名称。
-
-堆的常用操作见下表（方法命名以 Java 为例）。
-
-<p align="center"> Table. 堆的常用操作 </p>
-
-<div class="center-table" markdown>
-
-| 方法      | 描述                                         |
-| --------- | -------------------------------------------- |
-| add()     | 元素入堆                                     |
-| poll()    | 堆顶元素出堆                                 |
-| peek()    | 访问堆顶元素（大 / 小顶堆分别为最大 / 小值） |
-| size()    | 获取堆的元素数量                             |
-| isEmpty() | 判断堆是否为空                               |
-
-</div>
-
-```java
-
-```
-
-## 堆的实现
-
-!!! tip
-
-    下文使用「大顶堆」来举例，「小顶堆」的用法与实现可以简单地将所有 $>$ ($<$) 替换为 $<$ ($>$) 即可。
-
-我们一般使用「数组」来存储「堆」，这是因为完全二叉树非常适合用数组来表示（在二叉树章节有详细解释）。
-
-
-
-## 堆常见应用
-
-- 优先队列。
-- 堆排序。
-- 获取数据 Top K 大（小）元素。

From 3ba37dba3a55f02b46484a41fcfeacc2881c6a47 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Sun, 8 Jan 2023 19:08:07 +0800
Subject: [PATCH 122/158] Fix the test case of the binary tree dfs in Java.

---
 codes/java/chapter_tree/binary_tree_dfs.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/codes/java/chapter_tree/binary_tree_dfs.java b/codes/java/chapter_tree/binary_tree_dfs.java
index d1ef063b0..ad5337f22 100644
--- a/codes/java/chapter_tree/binary_tree_dfs.java
+++ b/codes/java/chapter_tree/binary_tree_dfs.java
@@ -43,7 +43,7 @@ public class binary_tree_dfs {
     public static void main(String[] args) {
         /* 初始化二叉树 */
         // 这里借助了一个从数组直接生成二叉树的函数
-        TreeNode root = TreeNode.arrToTree(new Integer[] { 1, null, 3, 4, 5 });
+        TreeNode root = TreeNode.arrToTree(new Integer[] { 1, 2, 3, 4, 5, 6, 7 });
         System.out.println("\n初始化二叉树\n");
         PrintUtil.printTree(root);
 

From 73e345283841496b6ed37df8cf838434c9530ee8 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Sun, 8 Jan 2023 19:41:05 +0800
Subject: [PATCH 123/158] Add Swift language blocks to the docs.

---
 .../worst_best_time_complexity.c              |  12 +--
 codes/csharp/hello-algo.csproj                |   4 +-
 .../chapter_array_and_linkedlist/array.swift  |  12 +--
 .../linked_list.md                            | 100 ++++++++++++------
 docs/chapter_array_and_linkedlist/list.md     |  43 ++++++++
 .../time_complexity.md                        |  12 +--
 docs/chapter_hashing/hash_map.md              |  50 ++++++---
 docs/chapter_preface/about_the_book.md        |  13 +++
 docs/chapter_searching/binary_search.md       |  18 ++++
 docs/chapter_searching/hashing_search.md      |  12 +++
 docs/chapter_searching/linear_search.md       |  12 +++
 docs/chapter_sorting/bubble_sort.md           |  12 +++
 docs/chapter_sorting/insertion_sort.md        |   6 ++
 docs/chapter_sorting/merge_sort.md            |   6 ++
 docs/chapter_sorting/quick_sort.md            |  28 ++++-
 docs/chapter_stack_and_queue/deque.md         |   6 ++
 docs/chapter_stack_and_queue/queue.md         |  18 ++++
 docs/chapter_stack_and_queue/stack.md         |  18 ++++
 docs/chapter_tree/avl_tree.md                 |  48 +++++++++
 docs/chapter_tree/binary_search_tree.md       |  18 ++++
 docs/chapter_tree/binary_tree.md              |  24 +++++
 docs/chapter_tree/binary_tree_traversal.md    |  12 +++
 22 files changed, 414 insertions(+), 70 deletions(-)

diff --git a/codes/c/chapter_computational_complexity/worst_best_time_complexity.c b/codes/c/chapter_computational_complexity/worst_best_time_complexity.c
index 9173f32d4..2570ff3c3 100644
--- a/codes/c/chapter_computational_complexity/worst_best_time_complexity.c
+++ b/codes/c/chapter_computational_complexity/worst_best_time_complexity.c
@@ -15,12 +15,12 @@ int *randomNumbers(int n) {
         nums[i] = i + 1;
     }
     // 随机打乱数组元素 
-	for (int i = n - 1; i > 0; i--) {
-		int j = rand() % (i + 1);
-		int temp = nums[i];
-		nums[i] = nums[j];
-		nums[j] = temp; 
-	}
+    for (int i = n - 1; i > 0; i--) {
+        int j = rand() % (i + 1);
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
     return nums;
 }
 
diff --git a/codes/csharp/hello-algo.csproj b/codes/csharp/hello-algo.csproj
index 2ef4da851..d96d728b1 100644
--- a/codes/csharp/hello-algo.csproj
+++ b/codes/csharp/hello-algo.csproj
@@ -11,8 +11,8 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
     <PackageReference Include="NUnit" Version="3.13.3" />
-	<PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
-	<PackageReference Include="coverlet.collector" Version="3.1.0" />
+  <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
+  <PackageReference Include="coverlet.collector" Version="3.1.0" />
   </ItemGroup>
 
 </Project>
diff --git a/codes/swift/chapter_array_and_linkedlist/array.swift b/codes/swift/chapter_array_and_linkedlist/array.swift
index c0c7ab9b9..08cd0707f 100644
--- a/codes/swift/chapter_array_and_linkedlist/array.swift
+++ b/codes/swift/chapter_array_and_linkedlist/array.swift
@@ -4,7 +4,7 @@
  * Author: nuomi1 (nuomi1@qq.com)
  */
 
-// 随机返回一个数组元素
+/* 随机返回一个数组元素 */
 func randomAccess(nums: [Int]) -> Int {
     // 在区间 [0, nums.count) 中随机抽取一个数字
     let randomIndex = nums.indices.randomElement()!
@@ -13,7 +13,7 @@ func randomAccess(nums: [Int]) -> Int {
     return randomNum
 }
 
-// 扩展数组长度
+/* 扩展数组长度 */
 func extend(nums: [Int], enlarge: Int) -> [Int] {
     // 初始化一个扩展长度后的数组
     var res = Array(repeating: 0, count: nums.count + enlarge)
@@ -25,7 +25,7 @@ func extend(nums: [Int], enlarge: Int) -> [Int] {
     return res
 }
 
-// 在数组的索引 index 处插入元素 num
+/* 在数组的索引 index 处插入元素 num */
 func insert(nums: inout [Int], num: Int, index: Int) {
     // 把索引 index 以及之后的所有元素向后移动一位
     for i in sequence(first: nums.count - 1, next: { $0 > index + 1 ? $0 - 1 : nil }) {
@@ -35,7 +35,7 @@ func insert(nums: inout [Int], num: Int, index: Int) {
     nums[index] = num
 }
 
-// 删除索引 index 处元素
+/* 删除索引 index 处元素 */
 func remove(nums: inout [Int], index: Int) {
     let count = nums.count
     // 把索引 index 之后的所有元素向前移动一位
@@ -44,7 +44,7 @@ func remove(nums: inout [Int], index: Int) {
     }
 }
 
-// 遍历数组
+/* 遍历数组 */
 func traverse(nums: [Int]) {
     var count = 0
     // 通过索引遍历数组
@@ -57,7 +57,7 @@ func traverse(nums: [Int]) {
     }
 }
 
-// 在数组中查找指定元素
+/* 在数组中查找指定元素 */
 func find(nums: [Int], target: Int) -> Int {
     for i in nums.indices {
         if nums[i] == target {
diff --git a/docs/chapter_array_and_linkedlist/linked_list.md b/docs/chapter_array_and_linkedlist/linked_list.md
index f054802d4..aa9c93ec7 100644
--- a/docs/chapter_array_and_linkedlist/linked_list.md
+++ b/docs/chapter_array_and_linkedlist/linked_list.md
@@ -112,6 +112,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+
+    ```
+
 **尾结点指向什么？** 我们一般将链表的最后一个结点称为「尾结点」，其指向的是「空」，在 Java / C++ / Python 中分别记为 `null` / `nullptr` / `None` 。在不引起歧义下，本书都使用 `null` 来表示空。
 
 **链表初始化方法**。建立链表分为两步，第一步是初始化各个结点对象，第二步是构建引用指向关系。完成后，即可以从链表的首个结点（即头结点）出发，访问其余所有的结点。
@@ -122,7 +128,7 @@ comments: true
 
 === "Java"
 
-    ```java title=""
+    ```java title="linked_list.java"
     /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
     // 初始化各个结点 
     ListNode n0 = new ListNode(1);
@@ -139,7 +145,7 @@ comments: true
 
 === "C++"
 
-    ```cpp title=""
+    ```cpp title="linked_list.cpp"
     /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
     // 初始化各个结点 
     ListNode* n0 = new ListNode(1);
@@ -156,7 +162,7 @@ comments: true
 
 === "Python"
 
-    ```python title=""
+    ```python title="linked_list.py"
     """ 初始化链表 1 -> 3 -> 2 -> 5 -> 4 """
     # 初始化各个结点 
     n0 = ListNode(1)
@@ -173,7 +179,7 @@ comments: true
 
 === "Go"
 
-    ```go title=""
+    ```go title="linked_list.go"
     /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
     // 初始化各个结点
     n0 := NewListNode(1)
@@ -191,7 +197,7 @@ comments: true
 
 === "JavaScript"
 
-    ```js title=""
+    ```js title="linked_list.js"
     /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
     // 初始化各个结点
     const n0 = new ListNode(1);
@@ -208,7 +214,7 @@ comments: true
 
 === "TypeScript"
 
-    ```typescript title=""
+    ```typescript title="linked_list.ts"
     /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
     // 初始化各个结点
     const n0 = new ListNode(1);
@@ -225,13 +231,13 @@ comments: true
 
 === "C"
 
-    ```c title=""
+    ```c title="linked_list.c"
 
     ```
 
 === "C#"
 
-    ```csharp title=""
+    ```csharp title="linked_list.cs"
     /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
     // 初始化各个结点 
     ListNode n0 = new ListNode(1);
@@ -246,6 +252,12 @@ comments: true
     n3.next = n4;
     ```
 
+=== "Swift"
+
+    ```swift title="linked_list.swift"
+
+    ```
+
 ## 链表优点
 
 **在链表中，插入与删除结点的操作效率高**。例如，如果想在链表中间的两个结点 `A` , `B` 之间插入一个新结点 `P` ，我们只需要改变两个结点指针即可，时间复杂度为 $O(1)$ ，相比数组的插入操作高效很多。在链表中删除某个结点也很方便，只需要改变一个结点指针即可。
@@ -256,7 +268,7 @@ comments: true
 
 === "Java"
 
-    ```java title=""
+    ```java title="linked_list.java"
     /* 在链表的结点 n0 之后插入结点 P */
     void insert(ListNode n0, ListNode P) {
         ListNode n1 = n0.next;
@@ -277,7 +289,7 @@ comments: true
 
 === "C++"
 
-    ```cpp title=""
+    ```cpp title="linked_list.cpp"
     /* 在链表的结点 n0 之后插入结点 P */
     void insert(ListNode* n0, ListNode* P) {
         ListNode* n1 = n0->next;
@@ -300,7 +312,7 @@ comments: true
 
 === "Python"
 
-    ```python title=""
+    ```python title="linked_list.py"
     """ 在链表的结点 n0 之后插入结点 P """
     def insert(n0, P):
         n1 = n0.next
@@ -319,7 +331,7 @@ comments: true
 
 === "Go"
 
-    ```go title=""
+    ```go title="linked_list.go"
     /* 在链表的结点 n0 之后插入结点 P */
     func insert(n0 *ListNode, P *ListNode) {
         n1 := n0.Next
@@ -341,7 +353,7 @@ comments: true
 
 === "JavaScript"
 
-    ```js title=""
+    ```js title="linked_list.js"
     /* 在链表的结点 n0 之后插入结点 P */
     function insert(n0, P) {
         let n1 = n0.next;
@@ -362,7 +374,7 @@ comments: true
 
 === "TypeScript"
 
-    ```typescript title=""
+    ```typescript title="linked_list.ts"
     /* 在链表的结点 n0 之后插入结点 P */
     function insert(n0: ListNode, P: ListNode): void {
         const n1 = n0.next;
@@ -383,13 +395,13 @@ comments: true
 
 === "C"
 
-    ```c title=""
+    ```c title="linked_list.c"
 
     ```
 
 === "C#"
 
-    ```csharp title=""
+    ```csharp title="linked_list.cs"
     // 在链表的结点 n0 之后插入结点 P
     void Insert(ListNode n0, ListNode P)
     {
@@ -410,13 +422,19 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="linked_list.swift"
+
+    ```
+
 ## 链表缺点
 
 **链表访问结点效率低**。上节提到，数组可以在 $O(1)$ 时间下访问任意元素，但链表无法直接访问任意结点。这是因为计算机需要从头结点出发，一个一个地向后遍历到目标结点。例如，倘若想要访问链表索引为 `index` （即第 `index + 1` 个）的结点，那么需要 `index` 次访问操作。
 
 === "Java"
 
-    ```java title=""
+    ```java title="linked_list.java"
     /* 访问链表中索引为 index 的结点 */
     ListNode access(ListNode head, int index) {
         for (int i = 0; i < index; i++) {
@@ -430,7 +448,7 @@ comments: true
 
 === "C++"
 
-    ```cpp title=""
+    ```cpp title="linked_list.cpp"
     /* 访问链表中索引为 index 的结点 */
     ListNode* access(ListNode* head, int index) {
         for (int i = 0; i < index; i++) {
@@ -444,7 +462,7 @@ comments: true
 
 === "Python"
 
-    ```python title=""
+    ```python title="linked_list.py"
     """ 访问链表中索引为 index 的结点 """
     def access(head, index):
         for _ in range(index):
@@ -456,7 +474,7 @@ comments: true
 
 === "Go"
 
-    ```go title=""
+    ```go title="linked_list.go"
     /* 访问链表中索引为 index 的结点 */
     func access(head *ListNode, index int) *ListNode {
         for i := 0; i < index; i++ {
@@ -471,7 +489,7 @@ comments: true
 
 === "JavaScript"
 
-    ```js title=""
+    ```js title="linked_list.js"
     /* 访问链表中索引为 index 的结点 */
     function access(head, index) {
         for (let i = 0; i < index; i++) {
@@ -485,7 +503,7 @@ comments: true
 
 === "TypeScript"
 
-    ```typescript title=""
+    ```typescript title="linked_list.ts"
     /* 访问链表中索引为 index 的结点 */
     function access(head: ListNode | null, index: number): ListNode | null {
         for (let i = 0; i < index; i++) {
@@ -500,13 +518,13 @@ comments: true
 
 === "C"
 
-    ```c title=""
+    ```c title="linked_list.c"
 
     ```
 
 === "C#"
 
-    ```csharp title=""
+    ```csharp title="linked_list.cs"
     // 访问链表中索引为 index 的结点
     ListNode Access(ListNode head, int index)
     {
@@ -520,6 +538,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="linked_list.swift"
+
+    ```
+
 **链表的内存占用多**。链表以结点为单位，每个结点除了保存值外，还需额外保存指针（引用）。这意味着同样数据量下，链表比数组需要占用更多内存空间。
 
 ## 链表常用操作
@@ -528,7 +552,7 @@ comments: true
 
 === "Java"
 
-    ```java title=""
+    ```java title="linked_list.java"
     /* 在链表中查找值为 target 的首个结点 */
     int find(ListNode head, int target) {
         int index = 0;
@@ -544,7 +568,7 @@ comments: true
 
 === "C++"
 
-    ```cpp title=""
+    ```cpp title="linked_list.cpp"
     /* 在链表中查找值为 target 的首个结点 */
     int find(ListNode* head, int target) {
         int index = 0;
@@ -560,7 +584,7 @@ comments: true
 
 === "Python"
 
-    ```python title=""
+    ```python title="linked_list.py"
     """ 在链表中查找值为 target 的首个结点 """
     def find(head, target):
         index = 0
@@ -574,7 +598,7 @@ comments: true
 
 === "Go"
 
-    ```go title=""
+    ```go title="linked_list.go"
     /* 在链表中查找值为 target 的首个结点 */
     func find(head *ListNode, target int) int {
         index := 0
@@ -591,7 +615,7 @@ comments: true
 
 === "JavaScript"
 
-    ```js title=""
+    ```js title="linked_list.js"
     /* 在链表中查找值为 target 的首个结点 */
     function find(head, target) {
         let index = 0;
@@ -608,7 +632,7 @@ comments: true
 
 === "TypeScript"
 
-    ```typescript title=""
+    ```typescript title="linked_list.ts"
     /* 在链表中查找值为 target 的首个结点 */
     function find(head: ListNode | null, target: number): number {
         let index = 0;
@@ -625,13 +649,13 @@ comments: true
 
 === "C"
 
-    ```c title=""
+    ```c title="linked_list.c"
 
     ```
 
 === "C#"
 
-    ```csharp title=""
+    ```csharp title="linked_list.cs"
     // 在链表中查找值为 target 的首个结点
     int Find(ListNode head, int target)
     {
@@ -647,6 +671,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="linked_list.swift"
+
+    ```
+
 ## 常见链表类型
 
 **单向链表**。即上述介绍的普通链表。单向链表的结点有「值」和指向下一结点的「指针（引用）」两项数据。我们将首个结点称为头结点，尾结点指向 `null` 。
@@ -760,6 +790,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+
+    ```
+
 ![linkedlist_common_types](linked_list.assets/linkedlist_common_types.png)
 
 <p align="center"> Fig. 常见链表类型 </p>
diff --git a/docs/chapter_array_and_linkedlist/list.md b/docs/chapter_array_and_linkedlist/list.md
index 19de6d778..d1109d65b 100644
--- a/docs/chapter_array_and_linkedlist/list.md
+++ b/docs/chapter_array_and_linkedlist/list.md
@@ -91,6 +91,12 @@ comments: true
     List<int> list = numbers.ToList();
     ```
 
+=== "Swift"
+
+    ```swift title="list.swift"
+
+    ```
+
 **访问与更新元素**。列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。
 
 === "Java"
@@ -169,6 +175,12 @@ comments: true
     list[1] = 0;  // 将索引 1 处的元素更新为 0
     ```
 
+=== "Swift"
+
+    ```swift title="list.swift"
+
+    ```
+
 **在列表中添加、插入、删除元素**。相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
 
 === "Java"
@@ -317,6 +329,12 @@ comments: true
     list.RemoveAt(3);
     ```
 
+=== "Swift"
+
+    ```swift title="list.swift"
+
+    ```
+
 **遍历列表**。与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
 
 === "Java"
@@ -437,6 +455,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="list.swift"
+
+    ```
+
 **拼接两个列表**。再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。
 
 === "Java"
@@ -502,6 +526,12 @@ comments: true
     list.AddRange(list1);  // 将列表 list1 拼接到 list 之后
     ```
 
+=== "Swift"
+
+    ```swift title="list.swift"
+
+    ```
+
 **排序列表**。排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
 
 === "Java"
@@ -559,6 +589,12 @@ comments: true
     list.Sort(); // 排序后，列表元素从小到大排列
     ```
 
+=== "Swift"
+
+    ```swift title="list.swift"
+
+    ```
+
 ## 列表简易实现 *
 
 为了帮助加深对列表的理解，我们在此提供一个列表的简易版本的实现。需要关注三个核心点：
@@ -1220,3 +1256,10 @@ comments: true
         }
     }
     ```
+
+=== "Swift"
+
+    ```swift title="my_list.swift"
+
+    ```
+
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 217981ae8..7b0e66fbd 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -421,12 +421,12 @@ $$
 
     ```go title=""
     func algorithm(n int) {
-        a := 1		// +1
-        a = a + 1	// +1
-        a = a * 2	// +1
+        a := 1      // +1
+        a = a + 1   // +1
+        a = a * 2   // +1
         // 循环 n 次
-        for i := 0; i < n; i++ {	// +1
-            fmt.Println(a)	        // +1
+        for i := 0; i < n; i++ {   // +1
+            fmt.Println(a)         // +1
         }
     }
     ```
@@ -2657,7 +2657,7 @@ $$
 
 === "Swift"
 
-    ```swift title=""
+    ```swift title="worst_best_time_complexity.swift"
     // 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱
     func randomNumbers(n: Int) -> [Int] {
         // 生成数组 nums = { 1, 2, 3, ..., n }
diff --git a/docs/chapter_hashing/hash_map.md b/docs/chapter_hashing/hash_map.md
index d8244d80a..3a69d88fc 100644
--- a/docs/chapter_hashing/hash_map.md
+++ b/docs/chapter_hashing/hash_map.md
@@ -108,25 +108,25 @@ comments: true
 
 === "Go"
 
-    ```go title="hash_map_test.go"
-	/* 初始化哈希表 */
-	mapp := make(map[int]string)
+    ```go title="hash_map.go"
+    /* 初始化哈希表 */
+    mapp := make(map[int]string)
 
-	/* 添加操作 */
-	// 在哈希表中添加键值对 (key, value)
-	mapp[12836] = "小哈"
-	mapp[15937] = "小啰"
-	mapp[16750] = "小算"
-	mapp[13276] = "小法"
-	mapp[10583] = "小鸭"
+    /* 添加操作 */
+    // 在哈希表中添加键值对 (key, value)
+    mapp[12836] = "小哈"
+    mapp[15937] = "小啰"
+    mapp[16750] = "小算"
+    mapp[13276] = "小法"
+    mapp[10583] = "小鸭"
 
-	/* 查询操作 */
-	// 向哈希表输入键 key ，得到值 value
-	name := mapp[15937]
+    /* 查询操作 */
+    // 向哈希表输入键 key ，得到值 value
+    name := mapp[15937]
 
-	/* 删除操作 */
-	// 在哈希表中删除键值对 (key, value)
-	delete(mapp, 10583)
+    /* 删除操作 */
+    // 在哈希表中删除键值对 (key, value)
+    delete(mapp, 10583)
     ```
 
 === "JavaScript"
@@ -207,6 +207,12 @@ comments: true
     map.Remove(10583);
     ```
 
+=== "Swift"
+
+    ```swift title="hash_map.swift"
+
+    ```
+
 遍历哈希表有三种方式，即 **遍历键值对、遍历键、遍历值**。
 
 === "Java"
@@ -339,6 +345,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="hash_map.swift"
+
+    ```
+
 ## 哈希函数
 
 哈希表中存储元素的数据结构被称为「桶 Bucket」，底层实现可能是数组、链表、二叉树（红黑树），或是它们的组合。
@@ -756,6 +768,12 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="array_hash_map.swift"
+
+    ```
+
 ## 哈希冲突
 
 细心的同学可能会发现，**哈希函数 $f(x) = x \% 100$ 会在某些情况下失效**。具体地，当输入的 key 后两位相同时，哈希函数的计算结果也相同，指向同一个 value 。例如，分别查询两个学号 12836 和 20336 ，则有
diff --git a/docs/chapter_preface/about_the_book.md b/docs/chapter_preface/about_the_book.md
index cb926b941..2fba23502 100644
--- a/docs/chapter_preface/about_the_book.md
+++ b/docs/chapter_preface/about_the_book.md
@@ -192,6 +192,19 @@ comments: true
      */
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
 """
 在 Java, C, C++, C#, Go, JS, TS 的代码注释中，`/* ... */` 用于注释函数、类、测试样例等标题， `// ...` 用于解释代码内容；类似地，在 Python 中，`""" ... """` 用于注释标题， `# ...` 用于解释代码。
 
diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
index 8827588ef..466e76658 100644
--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@@ -210,6 +210,12 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_search.swift"
+
+    ```
+
 ### “左闭右开”实现
 
 当然，我们也可以使用“左闭右开”的表示方法，写出相同功能的二分查找代码。
@@ -374,6 +380,12 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_search.swift"
+
+    ```
+
 ### 两种表示对比
 
 对比下来，两种表示的代码写法有以下不同点：
@@ -460,6 +472,12 @@ $$
     int m = i + (j - i) / 2;
     ```
 
+=== "Swift"
+
+    ```swift title=""
+
+    ```
+
 ## 复杂度分析
 
 **时间复杂度 $O(\log n)$ ：** 其中 $n$ 为数组或链表长度；每轮排除一半的区间，因此循环轮数为 $\log_2 n$ ，使用 $O(\log n)$ 时间。
diff --git a/docs/chapter_searching/hashing_search.md b/docs/chapter_searching/hashing_search.md
index a70a55483..12746d2ef 100644
--- a/docs/chapter_searching/hashing_search.md
+++ b/docs/chapter_searching/hashing_search.md
@@ -95,6 +95,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="hashing_search.swift"
+
+    ```
+
 再比如，如果我们想要给定一个目标结点值 `target` ，获取对应的链表结点对象，那么也可以使用哈希查找实现。
 
 ![hash_search_listnode](hashing_search.assets/hash_search_listnode.png)
@@ -179,6 +185,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="hashing_search.swift"
+
+    ```
+
 ## 复杂度分析
 
 **时间复杂度：** $O(1)$ ，哈希表的查找操作使用 $O(1)$ 时间。
diff --git a/docs/chapter_searching/linear_search.md b/docs/chapter_searching/linear_search.md
index 1c07027e6..be98c013d 100644
--- a/docs/chapter_searching/linear_search.md
+++ b/docs/chapter_searching/linear_search.md
@@ -122,6 +122,12 @@ comments: true
 
     ```
 
+=== "Swift"
+
+    ```swift title="linear_search.swift"
+
+    ```
+
 再比如，我们想要在给定一个目标结点值 `target` ，返回此结点对象，也可以在链表中进行线性查找。
 
 === "Java"
@@ -238,6 +244,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="linear_search.swift"
+
+    ```
+
 ## 复杂度分析
 
 **时间复杂度 $O(n)$ ：** 其中 $n$ 为数组或链表长度。
diff --git a/docs/chapter_sorting/bubble_sort.md b/docs/chapter_sorting/bubble_sort.md
index bb35fabe4..1dbc56475 100644
--- a/docs/chapter_sorting/bubble_sort.md
+++ b/docs/chapter_sorting/bubble_sort.md
@@ -212,6 +212,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="bubble_sort.swift"
+
+    ```
+
 ## 算法特性
 
 **时间复杂度 $O(n^2)$ ：** 各轮「冒泡」遍历的数组长度为 $n - 1$ , $n - 2$ , $\cdots$ , $2$ , $1$ 次，求和为 $\frac{(n - 1) n}{2}$ ，因此使用 $O(n^2)$ 时间。
@@ -414,3 +420,9 @@ comments: true
         }
     }
     ```
+
+=== "Swift"
+
+    ```swift title="bubble_sort.swift"
+
+    ```
diff --git a/docs/chapter_sorting/insertion_sort.md b/docs/chapter_sorting/insertion_sort.md
index 85016f718..679182f42 100644
--- a/docs/chapter_sorting/insertion_sort.md
+++ b/docs/chapter_sorting/insertion_sort.md
@@ -175,6 +175,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="insertion_sort.swift"
+
+    ```
+
 ## 算法特性
 
 **时间复杂度 $O(n^2)$ ：** 最差情况下，各轮插入操作循环 $n - 1$ , $n-2$ , $\cdots$ , $2$ , $1$ 次，求和为 $\frac{(n - 1) n}{2}$ ，使用 $O(n^2)$ 时间。
diff --git a/docs/chapter_sorting/merge_sort.md b/docs/chapter_sorting/merge_sort.md
index 48a5046c7..396baa089 100644
--- a/docs/chapter_sorting/merge_sort.md
+++ b/docs/chapter_sorting/merge_sort.md
@@ -388,6 +388,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="merge_sort.swift"
+
+    ```
+
 下面重点解释一下合并方法 `merge()` 的流程：
 
 1. 初始化一个辅助数组 `tmp` 暂存待合并区间 `[left, right]` 内的元素，后续通过覆盖原数组 `nums` 的元素来实现合并；
diff --git a/docs/chapter_sorting/quick_sort.md b/docs/chapter_sorting/quick_sort.md
index ebc161caa..f8dcc3238 100644
--- a/docs/chapter_sorting/quick_sort.md
+++ b/docs/chapter_sorting/quick_sort.md
@@ -223,6 +223,12 @@ comments: true
 
     ```
 
+=== "Swift"
+
+    ```swift title="quick_sort.swift"
+
+    ```
+
 !!! note "快速排序的分治思想"
 
     哨兵划分的实质是将 **一个长数组的排序问题** 简化为 **两个短数组的排序问题**。
@@ -359,6 +365,12 @@ comments: true
 
     ```
 
+=== "Swift"
+
+    ```swift title="quick_sort.swift"
+
+    ```
+
 ## 算法特性
 
 **平均时间复杂度 $O(n \log n)$ ：** 平均情况下，哨兵划分的递归层数为 $\log n$ ，每层中的总循环数为 $n$ ，总体使用 $O(n \log n)$ 时间。
@@ -574,6 +586,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="quick_sort.swift"
+
+    ```
+
 ## 尾递归优化
 
 **普通快速排序在某些输入下的空间效率变差**。仍然以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 0 ，那么将形成一个高度为 $n - 1$ 的递归树，此时使用的栈帧空间大小劣化至 $O(n)$ 。
@@ -652,10 +670,10 @@ comments: true
             // 对两个子数组中较短的那个执行快排
             if pivot-left < right-pivot {
                 quickSort(nums, left, pivot-1)   // 递归排序左子数组
-                left = pivot + 1				 // 剩余待排序区间为 [pivot + 1, right]
+                left = pivot + 1                 // 剩余待排序区间为 [pivot + 1, right]
             } else {
                 quickSort(nums, pivot+1, right)  // 递归排序右子数组
-                right = pivot - 1				 // 剩余待排序区间为 [left, pivot - 1]
+                right = pivot - 1                // 剩余待排序区间为 [left, pivot - 1]
             }
         }
     }
@@ -734,3 +752,9 @@ comments: true
         }
     }
     ```
+
+=== "Swift"
+
+    ```swift title="quick_sort.swift"
+
+    ```
diff --git a/docs/chapter_stack_and_queue/deque.md b/docs/chapter_stack_and_queue/deque.md
index c178c0e0a..52b0540d5 100644
--- a/docs/chapter_stack_and_queue/deque.md
+++ b/docs/chapter_stack_and_queue/deque.md
@@ -192,3 +192,9 @@ comments: true
     /* 判断双向队列是否为空 */
     bool isEmpty = deque.Count == 0;
     ```
+
+=== "Swift"
+
+    ```swift title="deque.swift"
+
+    ```
diff --git a/docs/chapter_stack_and_queue/queue.md b/docs/chapter_stack_and_queue/queue.md
index 8a964d3b7..ce47edb38 100644
--- a/docs/chapter_stack_and_queue/queue.md
+++ b/docs/chapter_stack_and_queue/queue.md
@@ -228,6 +228,12 @@ comments: true
     bool isEmpty = queue.Count() == 0;
     ```
 
+=== "Swift"
+
+    ```swift title="queue.swift"
+
+    ```
+
 ## 队列实现
 
 队列需要一种可以在一端添加，并在另一端删除的数据结构，也可以使用链表或数组来实现。
@@ -612,6 +618,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="linkedlist_queue.swift"
+
+    ```
+
 ### 基于数组的实现
 
 数组的删除首元素的时间复杂度为 $O(n)$ ，因此不适合直接用来实现队列。然而，我们可以借助两个指针 `front` , `rear` 来分别记录队首和队尾的索引位置，在入队 / 出队时分别将 `front` / `rear` 向后移动一位即可，这样每次仅需操作一个元素，时间复杂度降至 $O(1)$ 。
@@ -1015,6 +1027,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="array_queue.swift"
+
+    ```
+
 ## 队列典型应用
 
 - **淘宝订单**。购物者下单后，订单就被加入到队列之中，随后系统再根据顺序依次处理队列中的订单。在双十一时，在短时间内会产生海量的订单，如何处理「高并发」则是工程师们需要重点思考的问题。
diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index 985a4cf66..374de7424 100644
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -228,6 +228,12 @@ comments: true
     bool isEmpty = stack.Count()==0;
     ```
 
+=== "Swift"
+
+    ```swift title="stack.swift"
+
+    ```
+
 ## 栈的实现
 
 为了更加清晰地了解栈的运行机制，接下来我们来自己动手实现一个栈类。
@@ -591,6 +597,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="linkedlist_stack.swift"
+
+    ```
+
 ### 基于数组的实现
 
 使用「数组」实现栈时，将数组的尾部当作栈顶，这样可以保证入栈与出栈操作的时间复杂度都为 $O(1)$ 。准确地说，由于入栈的元素可能是源源不断的，我们需要使用可以动态扩容的「列表」。
@@ -870,6 +882,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="array_stack.swift"
+
+    ```
+
 !!! tip
 
     某些语言并未专门提供栈类，但我们可以直接把该语言的「数组」或「链表」看作栈来使用，并通过“脑补”来屏蔽无关操作，而无需像上述代码去特意包装一层。
diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md
index fe08828c1..43e0d9f45 100644
--- a/docs/chapter_tree/avl_tree.md
+++ b/docs/chapter_tree/avl_tree.md
@@ -94,6 +94,12 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
     }
     ```
 
+=== "Swift"
+
+    ```swift title="avl_tree.swift"
+
+    ```
+
 「结点高度」是最远叶结点到该结点的距离，即走过的「边」的数量。需要特别注意，**叶结点的高度为 0 ，空结点的高度为 -1** 。我们封装两个工具函数，分别用于获取与更新结点的高度。
 
 === "Java"
@@ -176,6 +182,12 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
     }
     ```
 
+=== "Swift"
+
+    ```swift title="avl_tree.swift"
+
+    ```
+
 ### 结点平衡因子
 
 结点的「平衡因子 Balance Factor」是 **结点的左子树高度减去右子树高度**，并定义空结点的平衡因子为 0 。同样地，我们将获取结点平衡因子封装成函数，以便后续使用。
@@ -247,6 +259,12 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
     }
     ```
 
+=== "Swift"
+
+    ```swift title="avl_tree.swift"
+
+    ```
+
 !!! note
 
     设平衡因子为 $f$ ，则一棵 AVL 树的任意结点的平衡因子皆满足 $-1 \le f \le 1$ 。
@@ -361,6 +379,12 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
     
     ```
 
+=== "Swift"
+
+    ```swift title="avl_tree.swift"
+
+    ```
+
 ### Case 2 - 左旋
 
 类似地，如果将取上述失衡二叉树的“镜像”，那么则需要「左旋」操作。
@@ -457,6 +481,12 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
     }
     ```
 
+=== "Swift"
+
+    ```swift title="avl_tree.swift"
+
+    ```
+
 ### Case 3 - 先左后右
 
 对于下图的失衡结点 3 ，**单一使用左旋或右旋都无法使子树恢复平衡**，此时需要「先左旋后右旋」，即先对 `child` 执行「左旋」，再对 `node` 执行「右旋」。
@@ -626,6 +656,12 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
     }
     ```
 
+=== "Swift"
+
+    ```swift title="avl_tree.swift"
+
+    ```
+
 ## AVL 树常用操作
 
 ### 插入结点
@@ -744,6 +780,12 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
     }
     ```
 
+=== "Swift"
+
+    ```swift title="avl_tree.swift"
+
+    ```
+
 ### 删除结点
 
 「AVL 树」删除结点操作与「二叉搜索树」删除结点操作总体相同。类似地，**在删除结点后，也需要从底至顶地执行旋转操作，使所有失衡结点恢复平衡**。
@@ -902,6 +944,12 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
     }
     ```
 
+=== "Swift"
+
+    ```swift title="avl_tree.swift"
+
+    ```
+
 ### 查找结点
 
 「AVL 树」的结点查找操作与「二叉搜索树」一致，在此不再赘述。
diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md
index 60a5598bd..979612852 100644
--- a/docs/chapter_tree/binary_search_tree.md
+++ b/docs/chapter_tree/binary_search_tree.md
@@ -192,6 +192,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_search_tree.swift"
+
+    ```
+
 ### 插入结点
 
 给定一个待插入元素 `num` ，为了保持二叉搜索树“左子树 < 根结点 < 右子树”的性质，插入操作分为两步：
@@ -422,6 +428,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_search_tree.swift"
+
+    ```
+
 为了插入结点，需要借助 **辅助结点 `prev`** 保存上一轮循环的结点，这样在遍历到 $\text{null}$ 时，我们也可以获取到其父结点，从而完成结点插入操作。
 
 与查找结点相同，插入结点使用 $O(\log n)$ 时间。
@@ -808,6 +820,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_search_tree.swift"
+
+    ```
+
 ## 二叉搜索树的优势
 
 假设给定 $n$ 个数字，最常用的存储方式是「数组」，那么对于这串乱序的数字，常见操作的效率为：
diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md
index 7977ab6a2..077c03e0d 100644
--- a/docs/chapter_tree/binary_tree.md
+++ b/docs/chapter_tree/binary_tree.md
@@ -106,6 +106,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+
+    ```
+
 结点的两个指针分别指向「左子结点 Left Child Node」和「右子结点 Right Child Node」，并且称该结点为两个子结点的「父结点 Parent Node」。给定二叉树某结点，将左子结点以下的树称为该结点的「左子树 Left Subtree」，右子树同理。
 
 除了叶结点外，每个结点都有子结点和子树。例如，若将上图的「结点 2」看作父结点，那么其左子结点和右子结点分别为「结点 4」和「结点 5」，左子树和右子树分别为「结点 4 以下的树」和「结点 5 以下的树」。
@@ -263,6 +269,12 @@ comments: true
     n2.right = n5;
     ```
 
+=== "Swift"
+
+    ```swift title="binary_tree.swift"
+
+    ```
+
 **插入与删除结点**。与链表类似，插入与删除结点都可以通过修改指针实现。
 
 ![binary_tree_add_remove](binary_tree.assets/binary_tree_add_remove.png)
@@ -358,6 +370,12 @@ comments: true
     n1.left = n2;
     ```
 
+=== "Swift"
+
+    ```swift title="binary_tree.swift"
+
+    ```
+
 !!! note
 
     插入结点会改变二叉树的原有逻辑结构，删除结点往往意味着删除了该结点的所有子树。因此，二叉树中的插入与删除一般都是由一套操作配合完成的，这样才能实现有意义的操作。
@@ -495,6 +513,12 @@ comments: true
     int?[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };
     ```
 
+=== "Swift"
+
+    ```swift title=""
+
+    ```
+
 ![array_representation_with_empty](binary_tree.assets/array_representation_with_empty.png)
 
 回顾「完全二叉树」的定义，其只有最底层有空结点，并且最底层的结点尽量靠左，因而所有空结点都一定出现在层序遍历序列的末尾。**因为我们先验地确定了空位的位置，所以在使用数组表示完全二叉树时，可以省略存储“空位”**。因此，完全二叉树非常适合使用数组来表示。
diff --git a/docs/chapter_tree/binary_tree_traversal.md b/docs/chapter_tree/binary_tree_traversal.md
index f46348412..c64077072 100644
--- a/docs/chapter_tree/binary_tree_traversal.md
+++ b/docs/chapter_tree/binary_tree_traversal.md
@@ -185,6 +185,12 @@ comments: true
     
     ```
 
+=== "Swift"
+
+    ```swift title="binary_tree_bfs.swift"
+
+    ```
+
 ## 前序、中序、后序遍历
 
 相对地，前、中、后序遍历皆属于「深度优先遍历 Depth-First Traversal」，其体现着一种“先走到尽头，再回头继续”的回溯遍历方式。
@@ -443,6 +449,12 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_tree_dfs.swift"
+
+    ```
+
 !!! note
 
     使用循环一样可以实现前、中、后序遍历，但代码相对繁琐，有兴趣的同学可以自行实现。

From 230c7723d53746c1fcf8c3d08849d5d67730336d Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Sun, 8 Jan 2023 19:55:08 +0800
Subject: [PATCH 124/158] Update comment format of array.swift

---
 .../chapter_array_and_linkedlist/array.swift     | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/codes/swift/chapter_array_and_linkedlist/array.swift b/codes/swift/chapter_array_and_linkedlist/array.swift
index 08cd0707f..344dc5abc 100644
--- a/codes/swift/chapter_array_and_linkedlist/array.swift
+++ b/codes/swift/chapter_array_and_linkedlist/array.swift
@@ -69,34 +69,34 @@ func find(nums: [Int], target: Int) -> Int {
 
 @main
 enum _Array {
-    // Driver Code
+    /* Driver Code */
     static func main() {
-        // 初始化数组
+        /* 初始化数组 */
         let arr = Array(repeating: 0, count: 5)
         print("数组 arr = \(arr)")
         var nums = [1, 3, 2, 5, 4]
         print("数组 nums = \(nums)")
 
-        // 随机访问
+        /* 随机访问 */
         let randomNum = randomAccess(nums: nums)
         print("在 nums 中获取随机元素 \(randomNum)")
 
-        // 长度扩展
+        /* 长度扩展 */
         nums = extend(nums: nums, enlarge: 3)
         print("将数组长度扩展至 8 ，得到 nums = \(nums)")
 
-        // 插入元素
+        /* 插入元素 */
         insert(nums: &nums, num: 6, index: 3)
         print("在索引 3 处插入数字 6 ，得到 nums = \(nums)")
 
-        // 删除元素
+        /* 删除元素 */
         remove(nums: &nums, index: 2)
         print("删除索引 2 处的元素，得到 nums = \(nums)")
 
-        // 遍历数组
+        /* 遍历数组 */
         traverse(nums: nums)
 
-        // 查找元素
+        /* 查找元素 */
         let index = find(nums: nums, target: 3)
         print("在 nums 中查找元素 3 ，得到索引 = \(index)")
     }

From 7556558704ec593d0509869c8b5a0d5a297baa7e Mon Sep 17 00:00:00 2001
From: nuomi1 <nuomi1@qq.com>
Date: Sun, 8 Jan 2023 20:22:59 +0800
Subject: [PATCH 125/158] feat: add Swift codes for linked_list article

---
 codes/swift/Package.swift                     |  2 +
 .../linked_list.swift                         | 91 +++++++++++++++++++
 codes/swift/utils/PrintUtil.swift             | 10 ++
 .../linked_list.md                            | 73 ++++++++++++++-
 4 files changed, 173 insertions(+), 3 deletions(-)
 create mode 100644 codes/swift/chapter_array_and_linkedlist/linked_list.swift

diff --git a/codes/swift/Package.swift b/codes/swift/Package.swift
index d9368354b..4cf3601c7 100644
--- a/codes/swift/Package.swift
+++ b/codes/swift/Package.swift
@@ -10,6 +10,7 @@ let package = Package(
         .executable(name: "space_complexity", targets: ["space_complexity"]),
         .executable(name: "leetcode_two_sum", targets: ["leetcode_two_sum"]),
         .executable(name: "array", targets: ["array"]),
+        .executable(name: "linked_list", targets: ["linked_list"]),
     ],
     targets: [
         .target(name: "utils", path: "utils"),
@@ -18,5 +19,6 @@ let package = Package(
         .executableTarget(name: "space_complexity", dependencies: ["utils"], path: "chapter_computational_complexity", sources: ["space_complexity.swift"]),
         .executableTarget(name: "leetcode_two_sum", path: "chapter_computational_complexity", sources: ["leetcode_two_sum.swift"]),
         .executableTarget(name: "array", path: "chapter_array_and_linkedlist", sources: ["array.swift"]),
+        .executableTarget(name: "linked_list", dependencies: ["utils"], path: "chapter_array_and_linkedlist", sources: ["linked_list.swift"]),
     ]
 )
diff --git a/codes/swift/chapter_array_and_linkedlist/linked_list.swift b/codes/swift/chapter_array_and_linkedlist/linked_list.swift
new file mode 100644
index 000000000..06837f750
--- /dev/null
+++ b/codes/swift/chapter_array_and_linkedlist/linked_list.swift
@@ -0,0 +1,91 @@
+/**
+ * File: linked_list.swift
+ * Created Time: 2023-01-08
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+/* 在链表的结点 n0 之后插入结点 P */
+func insert(n0: ListNode, P: ListNode) {
+    let n1 = n0.next
+    n0.next = P
+    P.next = n1
+}
+
+/* 删除链表的结点 n0 之后的首个结点 */
+func remove(n0: ListNode) {
+    if n0.next == nil {
+        return
+    }
+    // n0 -> P -> n1
+    let P = n0.next
+    let n1 = P?.next
+    n0.next = n1
+    P?.next = nil
+}
+
+/* 访问链表中索引为 index 的结点 */
+func access(head: ListNode, index: Int) -> ListNode? {
+    var head: ListNode? = head
+    for _ in 0 ..< index {
+        head = head?.next
+        if head == nil {
+            return nil
+        }
+    }
+    return head
+}
+
+/* 在链表中查找值为 target 的首个结点 */
+func find(head: ListNode, target: Int) -> Int {
+    var head: ListNode? = head
+    var index = 0
+    while head != nil {
+        if head?.val == target {
+            return index
+        }
+        head = head?.next
+        index += 1
+    }
+    return -1
+}
+
+@main
+enum LinkedList {
+    /* Driver Code */
+    static func main() {
+        /* 初始化链表 */
+        // 初始化各个结点
+        let n0 = ListNode(x: 1)
+        let n1 = ListNode(x: 3)
+        let n2 = ListNode(x: 2)
+        let n3 = ListNode(x: 5)
+        let n4 = ListNode(x: 4)
+        // 构建引用指向
+        n0.next = n1
+        n1.next = n2
+        n2.next = n3
+        n3.next = n4
+        print("初始化的链表为")
+        PrintUtil.printLinkedList(head: n0)
+
+        /* 插入结点 */
+        insert(n0: n0, P: ListNode(x: 0))
+        print("插入结点后的链表为")
+        PrintUtil.printLinkedList(head: n0)
+
+        /* 删除结点 */
+        remove(n0: n0)
+        print("删除结点后的链表为")
+        PrintUtil.printLinkedList(head: n0)
+
+        /* 访问结点 */
+        let node = access(head: n0, index: 3)
+        print("链表中索引 3 处的结点的值 = \(node!.val)")
+
+        /* 查找结点 */
+        let index = find(head: n0, target: 2)
+        print("链表中值为 2 的结点的索引 = \(index)")
+    }
+}
diff --git a/codes/swift/utils/PrintUtil.swift b/codes/swift/utils/PrintUtil.swift
index f2b54693d..cbeab1225 100644
--- a/codes/swift/utils/PrintUtil.swift
+++ b/codes/swift/utils/PrintUtil.swift
@@ -15,6 +15,16 @@ public enum PrintUtil {
         }
     }
 
+    public static func printLinkedList(head: ListNode) {
+        var head: ListNode? = head
+        var list: [String] = []
+        while head != nil {
+            list.append("\(head!.val)")
+            head = head?.next
+        }
+        print(list.joined(separator: " -> "))
+    }
+
     public static func printTree(root: TreeNode?) {
         printTree(root: root, prev: nil, isLeft: false)
     }
diff --git a/docs/chapter_array_and_linkedlist/linked_list.md b/docs/chapter_array_and_linkedlist/linked_list.md
index aa9c93ec7..7aa2754ca 100644
--- a/docs/chapter_array_and_linkedlist/linked_list.md
+++ b/docs/chapter_array_and_linkedlist/linked_list.md
@@ -115,7 +115,15 @@ comments: true
 === "Swift"
 
     ```swift title=""
+    /* 链表结点类 */
+    class ListNode {
+        var val: Int // 结点值
+        var next: ListNode? // 指向下一结点的指针（引用）
 
+        init(x: Int) { // 构造函数
+            val = x
+        }
+    }
     ```
 
 **尾结点指向什么？** 我们一般将链表的最后一个结点称为「尾结点」，其指向的是「空」，在 Java / C++ / Python 中分别记为 `null` / `nullptr` / `None` 。在不引起歧义下，本书都使用 `null` 来表示空。
@@ -255,7 +263,18 @@ comments: true
 === "Swift"
 
     ```swift title="linked_list.swift"
-
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各个结点
+    let n0 = ListNode(x: 1)
+    let n1 = ListNode(x: 3)
+    let n2 = ListNode(x: 2)
+    let n3 = ListNode(x: 5)
+    let n4 = ListNode(x: 4)
+    // 构建引用指向
+    n0.next = n1
+    n1.next = n2
+    n2.next = n3
+    n3.next = n4
     ```
 
 ## 链表优点
@@ -425,7 +444,24 @@ comments: true
 === "Swift"
 
     ```swift title="linked_list.swift"
+    /* 在链表的结点 n0 之后插入结点 P */
+    func insert(n0: ListNode, P: ListNode) {
+        let n1 = n0.next
+        n0.next = P
+        P.next = n1
+    }
 
+    /* 删除链表的结点 n0 之后的首个结点 */
+    func remove(n0: ListNode) {
+        if n0.next == nil {
+            return
+        }
+        // n0 -> P -> n1
+        let P = n0.next
+        let n1 = P?.next
+        n0.next = n1
+        P?.next = nil
+    }
     ```
 
 ## 链表缺点
@@ -541,7 +577,17 @@ comments: true
 === "Swift"
 
     ```swift title="linked_list.swift"
-
+    /* 访问链表中索引为 index 的结点 */
+    func access(head: ListNode, index: Int) -> ListNode? {
+        var head: ListNode? = head
+        for _ in 0 ..< index {
+            head = head?.next
+            if head == nil {
+                return nil
+            }
+        }
+        return head
+    }
     ```
 
 **链表的内存占用多**。链表以结点为单位，每个结点除了保存值外，还需额外保存指针（引用）。这意味着同样数据量下，链表比数组需要占用更多内存空间。
@@ -674,7 +720,19 @@ comments: true
 === "Swift"
 
     ```swift title="linked_list.swift"
-
+    /* 在链表中查找值为 target 的首个结点 */
+    func find(head: ListNode, target: Int) -> Int {
+        var head: ListNode? = head
+        var index = 0
+        while head != nil {
+            if head?.val == target {
+                return index
+            }
+            head = head?.next
+            index += 1
+        }
+        return -1
+    }
     ```
 
 ## 常见链表类型
@@ -793,7 +851,16 @@ comments: true
 === "Swift"
 
     ```swift title=""
+    /* 双向链表结点类 */
+    class ListNode {
+        var val: Int // 结点值
+        var next: ListNode? // 指向后继结点的指针（引用）
+        var prev: ListNode? // 指向前驱结点的指针（引用）
 
+        init(x: Int) { // 构造函数
+            val = x
+        }
+    }
     ```
 
 ![linkedlist_common_types](linked_list.assets/linkedlist_common_types.png)

From e8f7d8f8bab845eeca8082a0035cf01002739cfd Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Sun, 8 Jan 2023 20:30:09 +0800
Subject: [PATCH 126/158] Update .gitignore

---
 .gitignore                           |   4 +-
 codes/java/chapter_heap/my_heap.java | 115 ---------------------------
 2 files changed, 1 insertion(+), 118 deletions(-)
 delete mode 100644 codes/java/chapter_heap/my_heap.java

diff --git a/.gitignore b/.gitignore
index e93873c95..c960a1bb3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,7 @@
 # Editor
 .vscode/
 .idea/
+hello-algo.iml
 
 # mkdocs files
 site/
@@ -13,6 +14,3 @@ docs/overrides/
 
 # python files
 __pycache__
-
-# in-progress articles
-docs/chapter_heap
diff --git a/codes/java/chapter_heap/my_heap.java b/codes/java/chapter_heap/my_heap.java
deleted file mode 100644
index da2dffc0a..000000000
--- a/codes/java/chapter_heap/my_heap.java
+++ /dev/null
@@ -1,115 +0,0 @@
-/**
- * File: my_heap.java
- * Created Time: 2023-01-07
- * Author: Krahets (krahets@163.com)
- */
-
-package chapter_heap;
-
-import include.*;
-import java.util.*;
-
-class MaxHeap {
-    private List<Integer> heap;
-
-    public MaxHeap() {
-        heap = new ArrayList<>();
-    }
-
-    public MaxHeap(List<Integer> nums) {
-        // 将元素拷贝至堆中
-        heap = new ArrayList<>(nums);
-        // 堆化除叶结点外的其他所有结点
-        for (int i = parent(size() - 1); i >= 0; i--) {
-            heapify(i);
-        }
-    }
-
-    /* 获取左子结点 */
-    private int left(int i) {
-        return 2 * i + 1;
-    }
-
-    /* 获取右子结点 */
-    private int right(int i) {
-        return 2 * i + 2;
-    }
-    
-    /* 获取父结点 */
-    private int parent(int i) {
-        return (i - 1) / 2;
-    }
-
-    /* 交换元素 */
-    private void swap(int i, int j) {
-        int tmp = heap.get(i);
-        heap.set(i, j);
-        heap.set(j, tmp);
-    }
-
-    public int size() {
-        return heap.size();
-    }
-
-    public boolean isEmpty() {
-        return size() == 0;
-    }
-
-    /* 获取堆顶元素 */
-    public int peek() {
-        return heap.get(0);
-    }
-
-    /* 元素入堆 */
-    public void push(int val) {
-        heap.add(val);
-
-        // 从底至顶堆化
-        int i = size();
-        while (true) {
-            int p = parent(i);
-            if (p < 0 || heap.get(i) > heap.get(p))
-                break;
-            swap(i, p);
-            i = p;
-        }
-    }
-
-    /* 元素出堆 */
-    public int poll() {
-        // 判空处理
-        if (isEmpty())
-            throw new EmptyStackException();
-        // 交换根结点与右下角（即最后一个）结点
-        swap(0, size() - 1);
-        // 删除结点
-        int val = heap.remove(size() - 1);
-        // 从顶至底堆化
-        heapify(0);
-        // 返回堆顶元素
-        return val;
-    }
-
-    /* 从结点 i 开始，从顶至底堆化 */
-    private void heapify(int i) {
-        while (true) {
-            // 判断结点 i, l, r 中的最大结点，记为 ma ；
-            int l = left(i), r = right(i), ma = i;
-            if (heap.get(l) > heap.get(ma)) ma = l;
-            if (heap.get(r) > heap.get(ma)) ma = r;
-            // 若结点 i 最大，则无需继续堆化，跳出
-            if (ma == i) break;
-            // 交换结点 i 与结点 max
-            swap(i, ma);
-            // 循环向下堆化
-            i = ma;
-        }
-    }
-}
-
-
-public class my_heap {
-    public static void main(String[] args) {
-
-    }
-}

From b73ac7bf4b0d3c21ece986a40b734d7f561cc7e4 Mon Sep 17 00:00:00 2001
From: reanon <793584285@qq.com>
Date: Tue, 3 Jan 2023 14:39:31 +0800
Subject: [PATCH 127/158] style(go): fix go code style     Make the classes and
 methods in the package private, in case misuse

---
 .../chapter_array_and_linkedlist/my_list.go   | 24 ++++-----
 .../space_complexity.go                       | 32 ++++++------
 codes/go/chapter_hashing/array_hash_map.go    | 32 ++++++------
 .../chapter_searching/hashing_search_test.go  |  3 +-
 codes/go/chapter_sorting/merge_sort.go        | 12 ++---
 codes/go/chapter_sorting/quick_sort.go        | 20 +++----
 codes/go/chapter_sorting/quick_sort_test.go   |  6 +--
 .../go/chapter_stack_and_queue/array_queue.go | 38 +++++++-------
 .../go/chapter_stack_and_queue/array_stack.go | 36 ++++++-------
 .../go/chapter_stack_and_queue/deque_test.go  | 30 +++++------
 .../linkedlist_deque.go                       | 52 +++++++++----------
 .../linkedlist_queue.go                       | 34 ++++++------
 .../linkedlist_stack.go                       | 34 ++++++------
 .../go/chapter_stack_and_queue/queue_test.go  | 52 +++++++++----------
 .../go/chapter_stack_and_queue/stack_test.go  | 52 +++++++++----------
 codes/go/chapter_tree/binary_search_tree.go   | 24 ++++-----
 .../chapter_tree/binary_search_tree_test.go   | 24 ++++-----
 codes/go/pkg/print_utils.go                   |  4 +-
 18 files changed, 255 insertions(+), 254 deletions(-)

diff --git a/codes/go/chapter_array_and_linkedlist/my_list.go b/codes/go/chapter_array_and_linkedlist/my_list.go
index 8f13630be..134096d0a 100644
--- a/codes/go/chapter_array_and_linkedlist/my_list.go
+++ b/codes/go/chapter_array_and_linkedlist/my_list.go
@@ -5,7 +5,7 @@
 package chapter_array_and_linkedlist
 
 /* 列表类简易实现 */
-type MyList struct {
+type myList struct {
 	numsCapacity int
 	nums         []int
 	numsSize     int
@@ -13,8 +13,8 @@ type MyList struct {
 }
 
 /* 构造函数 */
-func newMyList() *MyList {
-	return &MyList{
+func newMyList() *myList {
+	return &myList{
 		numsCapacity: 10,              // 列表容量
 		nums:         make([]int, 10), // 数组（存储列表元素）
 		numsSize:     0,               // 列表长度（即当前元素数量）
@@ -23,17 +23,17 @@ func newMyList() *MyList {
 }
 
 /* 获取列表长度（即当前元素数量） */
-func (l *MyList) size() int {
+func (l *myList) size() int {
 	return l.numsSize
 }
 
 /*  获取列表容量 */
-func (l *MyList) capacity() int {
+func (l *myList) capacity() int {
 	return l.numsCapacity
 }
 
 /* 访问元素 */
-func (l *MyList) get(index int) int {
+func (l *myList) get(index int) int {
 	// 索引如果越界则抛出异常，下同
 	if index >= l.numsSize {
 		panic("索引越界")
@@ -42,7 +42,7 @@ func (l *MyList) get(index int) int {
 }
 
 /* 更新元素 */
-func (l *MyList) set(num, index int) {
+func (l *myList) set(num, index int) {
 	if index >= l.numsSize {
 		panic("索引越界")
 	}
@@ -50,7 +50,7 @@ func (l *MyList) set(num, index int) {
 }
 
 /* 尾部添加元素 */
-func (l *MyList) add(num int) {
+func (l *myList) add(num int) {
 	// 元素数量超出容量时，触发扩容机制
 	if l.numsSize == l.numsCapacity {
 		l.extendCapacity()
@@ -61,7 +61,7 @@ func (l *MyList) add(num int) {
 }
 
 /* 中间插入元素 */
-func (l *MyList) insert(num, index int) {
+func (l *myList) insert(num, index int) {
 	if index >= l.numsSize {
 		panic("索引越界")
 	}
@@ -79,7 +79,7 @@ func (l *MyList) insert(num, index int) {
 }
 
 /* 删除元素 */
-func (l *MyList) remove(index int) int {
+func (l *myList) remove(index int) int {
 	if index >= l.numsSize {
 		panic("索引越界")
 	}
@@ -95,7 +95,7 @@ func (l *MyList) remove(index int) int {
 }
 
 /* 列表扩容 */
-func (l *MyList) extendCapacity() {
+func (l *myList) extendCapacity() {
 	// 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组
 	l.nums = append(l.nums, make([]int, l.numsCapacity*(l.extendRatio-1))...)
 	// 更新列表容量
@@ -103,7 +103,7 @@ func (l *MyList) extendCapacity() {
 }
 
 /* 返回有效长度的列表 */
-func (l *MyList) toArray() []int {
+func (l *myList) toArray() []int {
 	// 仅转换有效长度范围内的列表元素
 	return l.nums[:l.numsSize]
 }
diff --git a/codes/go/chapter_computational_complexity/space_complexity.go b/codes/go/chapter_computational_complexity/space_complexity.go
index eb3ebec97..93f5b3380 100644
--- a/codes/go/chapter_computational_complexity/space_complexity.go
+++ b/codes/go/chapter_computational_complexity/space_complexity.go
@@ -9,31 +9,31 @@ import (
 	"strconv"
 )
 
-/* Node 结构体 */
-type Node struct {
+/* 结构体 */
+type node struct {
 	val  int
-	next *Node
+	next *node
 }
 
-/* TreeNode 二叉树 */
-type TreeNode struct {
+/* treeNode 二叉树 */
+type treeNode struct {
 	val   int
-	left  *TreeNode
-	right *TreeNode
+	left  *treeNode
+	right *treeNode
 }
 
-/* 创建 Node 结构体  */
-func newNode(val int) *Node {
-	return &Node{val: val}
+/* 创建 node 结构体  */
+func newNode(val int) *node {
+	return &node{val: val}
 }
 
-/* 创建 TreeNode 结构体 */
-func newTreeNode(val int) *TreeNode {
-	return &TreeNode{val: val}
+/* 创建 treeNode 结构体 */
+func newTreeNode(val int) *treeNode {
+	return &treeNode{val: val}
 }
 
 /* 输出二叉树 */
-func printTree(root *TreeNode) {
+func printTree(root *treeNode) {
 	if root == nil {
 		return
 	}
@@ -72,7 +72,7 @@ func spaceLinear(n int) {
 	// 长度为 n 的数组占用 O(n) 空间
 	_ = make([]int, n)
 	// 长度为 n 的列表占用 O(n) 空间
-	var nodes []*Node
+	var nodes []*node
 	for i := 0; i < n; i++ {
 		nodes = append(nodes, newNode(i))
 	}
@@ -112,7 +112,7 @@ func spaceQuadraticRecur(n int) int {
 }
 
 /* 指数阶（建立满二叉树） */
-func buildTree(n int) *TreeNode {
+func buildTree(n int) *treeNode {
 	if n == 0 {
 		return nil
 	}
diff --git a/codes/go/chapter_hashing/array_hash_map.go b/codes/go/chapter_hashing/array_hash_map.go
index a962b6a4d..5fb1480cc 100644
--- a/codes/go/chapter_hashing/array_hash_map.go
+++ b/codes/go/chapter_hashing/array_hash_map.go
@@ -7,30 +7,30 @@ package chapter_hashing
 import "fmt"
 
 /* 键值对 int->String */
-type Entry struct {
+type entry struct {
 	key int
 	val string
 }
 
 /* 基于数组简易实现的哈希表 */
-type ArrayHashMap struct {
-	bucket []*Entry
+type arrayHashMap struct {
+	bucket []*entry
 }
 
-func newArrayHashMap() *ArrayHashMap {
+func newArrayHashMap() *arrayHashMap {
 	// 初始化一个长度为 100 的桶（数组）
-	bucket := make([]*Entry, 100)
-	return &ArrayHashMap{bucket: bucket}
+	bucket := make([]*entry, 100)
+	return &arrayHashMap{bucket: bucket}
 }
 
 /* 哈希函数 */
-func (a *ArrayHashMap) hashFunc(key int) int {
+func (a *arrayHashMap) hashFunc(key int) int {
 	index := key % 100
 	return index
 }
 
 /* 查询操作 */
-func (a *ArrayHashMap) get(key int) string {
+func (a *arrayHashMap) get(key int) string {
 	index := a.hashFunc(key)
 	pair := a.bucket[index]
 	if pair == nil {
@@ -40,22 +40,22 @@ func (a *ArrayHashMap) get(key int) string {
 }
 
 /* 添加操作 */
-func (a *ArrayHashMap) put(key int, val string) {
-	pair := &Entry{key: key, val: val}
+func (a *arrayHashMap) put(key int, val string) {
+	pair := &entry{key: key, val: val}
 	index := a.hashFunc(key)
 	a.bucket[index] = pair
 }
 
 /* 删除操作 */
-func (a *ArrayHashMap) remove(key int) {
+func (a *arrayHashMap) remove(key int) {
 	index := a.hashFunc(key)
 	// 置为 nil ，代表删除
 	a.bucket[index] = nil
 }
 
 /* 获取所有键对 */
-func (a *ArrayHashMap) entrySet() []*Entry {
-	var pairs []*Entry
+func (a *arrayHashMap) entrySet() []*entry {
+	var pairs []*entry
 	for _, pair := range a.bucket {
 		if pair != nil {
 			pairs = append(pairs, pair)
@@ -65,7 +65,7 @@ func (a *ArrayHashMap) entrySet() []*Entry {
 }
 
 /* 获取所有键 */
-func (a *ArrayHashMap) keySet() []int {
+func (a *arrayHashMap) keySet() []int {
 	var keys []int
 	for _, pair := range a.bucket {
 		if pair != nil {
@@ -76,7 +76,7 @@ func (a *ArrayHashMap) keySet() []int {
 }
 
 /* 获取所有值 */
-func (a *ArrayHashMap) valueSet() []string {
+func (a *arrayHashMap) valueSet() []string {
 	var values []string
 	for _, pair := range a.bucket {
 		if pair != nil {
@@ -87,7 +87,7 @@ func (a *ArrayHashMap) valueSet() []string {
 }
 
 /* 打印哈希表 */
-func (a *ArrayHashMap) print() {
+func (a *arrayHashMap) print() {
 	for _, pair := range a.bucket {
 		if pair != nil {
 			fmt.Println(pair.key, "->", pair.val)
diff --git a/codes/go/chapter_searching/hashing_search_test.go b/codes/go/chapter_searching/hashing_search_test.go
index 4bccd038f..18cf5c651 100644
--- a/codes/go/chapter_searching/hashing_search_test.go
+++ b/codes/go/chapter_searching/hashing_search_test.go
@@ -6,8 +6,9 @@ package chapter_searching
 
 import (
 	"fmt"
-	. "github.com/krahets/hello-algo/pkg"
 	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
 )
 
 func TestHashingSearch(t *testing.T) {
diff --git a/codes/go/chapter_sorting/merge_sort.go b/codes/go/chapter_sorting/merge_sort.go
index 1b3a3932d..43aff01a7 100644
--- a/codes/go/chapter_sorting/merge_sort.go
+++ b/codes/go/chapter_sorting/merge_sort.go
@@ -8,25 +8,25 @@ package chapter_sorting
 // 左子数组区间 [left, mid]
 // 右子数组区间 [mid + 1, right]
 func merge(nums []int, left, mid, right int) {
-	// 初始化辅助数组 借助 copy模块
+	// 初始化辅助数组 借助 copy 模块
 	tmp := make([]int, right-left+1)
 	for i := left; i <= right; i++ {
 		tmp[i-left] = nums[i]
 	}
 	// 左子数组的起始索引和结束索引
-	left_start, left_end := left-left, mid-left
+	leftStart, leftEnd := left-left, mid-left
 	// 右子数组的起始索引和结束索引
-	right_start, right_end := mid+1-left, right-left
+	rightStart, rightEnd := mid+1-left, right-left
 	// i, j 分别指向左子数组、右子数组的首元素
-	i, j := left_start, right_start
+	i, j := leftStart, rightStart
 	// 通过覆盖原数组 nums 来合并左子数组和右子数组
 	for k := left; k <= right; k++ {
 		// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
-		if i > left_end {
+		if i > leftEnd {
 			nums[k] = tmp[j]
 			j++
 			// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
-		} else if j > right_end || tmp[i] <= tmp[j] {
+		} else if j > rightEnd || tmp[i] <= tmp[j] {
 			nums[k] = tmp[i]
 			i++
 			// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
diff --git a/codes/go/chapter_sorting/quick_sort.go b/codes/go/chapter_sorting/quick_sort.go
index 88aa14264..853bce452 100644
--- a/codes/go/chapter_sorting/quick_sort.go
+++ b/codes/go/chapter_sorting/quick_sort.go
@@ -5,16 +5,16 @@
 package chapter_sorting
 
 // 快速排序
-type QuickSort struct{}
+type quickSort struct{}
 
 // 快速排序（中位基准数优化）
-type QuickSortMedian struct{}
+type quickSortMedian struct{}
 
 // 快速排序（尾递归优化）
-type QuickSortTailCall struct{}
+type quickSortTailCall struct{}
 
 /* 哨兵划分 */
-func (q *QuickSort) partition(nums []int, left, right int) int {
+func (q *quickSort) partition(nums []int, left, right int) int {
 	// 以 nums[left] 作为基准数
 	i, j := left, right
 	for i < j {
@@ -33,7 +33,7 @@ func (q *QuickSort) partition(nums []int, left, right int) int {
 }
 
 /* 快速排序 */
-func (q *QuickSort) quickSort(nums []int, left, right int) {
+func (q *quickSort) quickSort(nums []int, left, right int) {
 	// 子数组长度为 1 时终止递归
 	if left >= right {
 		return
@@ -46,7 +46,7 @@ func (q *QuickSort) quickSort(nums []int, left, right int) {
 }
 
 /* 选取三个元素的中位数 */
-func (q *QuickSortMedian) medianThree(nums []int, left, mid, right int) int {
+func (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {
 	if (nums[left] > nums[mid]) != (nums[left] > nums[right]) {
 		return left
 	} else if (nums[mid] < nums[left]) != (nums[mid] > nums[right]) {
@@ -56,7 +56,7 @@ func (q *QuickSortMedian) medianThree(nums []int, left, mid, right int) int {
 }
 
 /* 哨兵划分（三数取中值）*/
-func (q *QuickSortMedian) partition(nums []int, left, right int) int {
+func (q *quickSortMedian) partition(nums []int, left, right int) int {
 	// 以 nums[left] 作为基准数
 	med := q.medianThree(nums, left, (left+right)/2, right)
 	// 将中位数交换至数组最左端
@@ -79,7 +79,7 @@ func (q *QuickSortMedian) partition(nums []int, left, right int) int {
 }
 
 /* 快速排序 */
-func (q *QuickSortMedian) quickSort(nums []int, left, right int) {
+func (q *quickSortMedian) quickSort(nums []int, left, right int) {
 	// 子数组长度为 1 时终止递归
 	if left >= right {
 		return
@@ -92,7 +92,7 @@ func (q *QuickSortMedian) quickSort(nums []int, left, right int) {
 }
 
 /* 哨兵划分 */
-func (q *QuickSortTailCall) partition(nums []int, left, right int) int {
+func (q *quickSortTailCall) partition(nums []int, left, right int) int {
 	// 以 nums[left] 作为基准数
 	i, j := left, right
 	for i < j {
@@ -111,7 +111,7 @@ func (q *QuickSortTailCall) partition(nums []int, left, right int) int {
 }
 
 /* 快速排序（尾递归优化）*/
-func (q *QuickSortTailCall) quickSort(nums []int, left, right int) {
+func (q *quickSortTailCall) quickSort(nums []int, left, right int) {
 	// 子数组长度为 1 时终止
 	for left < right {
 		// 哨兵划分操作
diff --git a/codes/go/chapter_sorting/quick_sort_test.go b/codes/go/chapter_sorting/quick_sort_test.go
index 86ae0115a..d780663e1 100644
--- a/codes/go/chapter_sorting/quick_sort_test.go
+++ b/codes/go/chapter_sorting/quick_sort_test.go
@@ -11,7 +11,7 @@ import (
 
 // 快速排序
 func TestQuickSort(t *testing.T) {
-	q := QuickSort{}
+	q := quickSort{}
 	nums := []int{4, 1, 3, 1, 5, 2}
 	q.quickSort(nums, 0, len(nums)-1)
 	fmt.Println("快速排序完成后 nums = ", nums)
@@ -19,7 +19,7 @@ func TestQuickSort(t *testing.T) {
 
 // 快速排序（中位基准数优化）
 func TestQuickSortMedian(t *testing.T) {
-	q := QuickSortMedian{}
+	q := quickSortMedian{}
 	nums := []int{4, 1, 3, 1, 5, 2}
 	q.quickSort(nums, 0, len(nums)-1)
 	fmt.Println("快速排序（中位基准数优化）完成后 nums = ", nums)
@@ -27,7 +27,7 @@ func TestQuickSortMedian(t *testing.T) {
 
 // 快速排序（尾递归优化）
 func TestQuickSortTailCall(t *testing.T) {
-	q := QuickSortTailCall{}
+	q := quickSortTailCall{}
 	nums := []int{4, 1, 3, 1, 5, 2}
 	q.quickSort(nums, 0, len(nums)-1)
 	fmt.Println("快速排序（尾递归优化）完成后 nums = ", nums)
diff --git a/codes/go/chapter_stack_and_queue/array_queue.go b/codes/go/chapter_stack_and_queue/array_queue.go
index 863768ba8..7d0367df8 100644
--- a/codes/go/chapter_stack_and_queue/array_queue.go
+++ b/codes/go/chapter_stack_and_queue/array_queue.go
@@ -5,16 +5,16 @@
 package chapter_stack_and_queue
 
 /* 基于环形数组实现的队列 */
-type ArrayQueue struct {
+type arrayQueue struct {
 	data     []int // 用于存储队列元素的数组
 	capacity int   // 队列容量（即最多容量的元素个数）
 	front    int   // 头指针，指向队首
 	rear     int   // 尾指针，指向队尾 + 1
 }
 
-// NewArrayQueue 基于环形数组实现的队列
-func NewArrayQueue(capacity int) *ArrayQueue {
-	return &ArrayQueue{
+// newArrayQueue 基于环形数组实现的队列
+func newArrayQueue(capacity int) *arrayQueue {
+	return &arrayQueue{
 		data:     make([]int, capacity),
 		capacity: capacity,
 		front:    0,
@@ -22,21 +22,21 @@ func NewArrayQueue(capacity int) *ArrayQueue {
 	}
 }
 
-// Size 获取队列的长度
-func (q *ArrayQueue) Size() int {
+// size 获取队列的长度
+func (q *arrayQueue) size() int {
 	size := (q.capacity + q.rear - q.front) % q.capacity
 	return size
 }
 
-// IsEmpty 判断队列是否为空
-func (q *ArrayQueue) IsEmpty() bool {
+// isEmpty 判断队列是否为空
+func (q *arrayQueue) isEmpty() bool {
 	return q.rear-q.front == 0
 }
 
-// Offer 入队
-func (q *ArrayQueue) Offer(v int) {
+// offer 入队
+func (q *arrayQueue) offer(v int) {
 	// 当 rear == capacity 表示队列已满
-	if q.Size() == q.capacity {
+	if q.size() == q.capacity {
 		return
 	}
 	// 尾结点后添加
@@ -45,9 +45,9 @@ func (q *ArrayQueue) Offer(v int) {
 	q.rear = (q.rear + 1) % q.capacity
 }
 
-// Poll 出队
-func (q *ArrayQueue) Poll() any {
-	if q.IsEmpty() {
+// poll 出队
+func (q *arrayQueue) poll() any {
+	if q.isEmpty() {
 		return nil
 	}
 	v := q.data[q.front]
@@ -56,9 +56,9 @@ func (q *ArrayQueue) Poll() any {
 	return v
 }
 
-// Peek 访问队首元素
-func (q *ArrayQueue) Peek() any {
-	if q.IsEmpty() {
+// peek 访问队首元素
+func (q *arrayQueue) peek() any {
+	if q.isEmpty() {
 		return nil
 	}
 	v := q.data[q.front]
@@ -66,6 +66,6 @@ func (q *ArrayQueue) Peek() any {
 }
 
 // 获取 Slice 用于打印
-func (s *ArrayQueue) toSlice() []int {
-	return s.data[s.front:s.rear]
+func (q *arrayQueue) toSlice() []int {
+	return q.data[q.front:q.rear]
 }
diff --git a/codes/go/chapter_stack_and_queue/array_stack.go b/codes/go/chapter_stack_and_queue/array_stack.go
index dca97404d..ef32ebe4c 100644
--- a/codes/go/chapter_stack_and_queue/array_stack.go
+++ b/codes/go/chapter_stack_and_queue/array_stack.go
@@ -5,47 +5,47 @@
 package chapter_stack_and_queue
 
 /* 基于数组实现的栈 */
-type ArrayStack struct {
+type arrayStack struct {
 	data []int // 数据
 }
 
-func NewArrayStack() *ArrayStack {
-	return &ArrayStack{
+func newArrayStack() *arrayStack {
+	return &arrayStack{
 		// 设置栈的长度为 0，容量为 16
 		data: make([]int, 0, 16),
 	}
 }
 
-// Size 栈的长度
-func (s *ArrayStack) Size() int {
+// size 栈的长度
+func (s *arrayStack) size() int {
 	return len(s.data)
 }
 
-// IsEmpty 栈是否为空
-func (s *ArrayStack) IsEmpty() bool {
-	return s.Size() == 0
+// isEmpty 栈是否为空
+func (s *arrayStack) isEmpty() bool {
+	return s.size() == 0
 }
 
-// Push 入栈
-func (s *ArrayStack) Push(v int) {
+// push 入栈
+func (s *arrayStack) push(v int) {
 	// 切片会自动扩容
 	s.data = append(s.data, v)
 }
 
-// Pop 出栈
-func (s *ArrayStack) Pop() any {
+// pop 出栈
+func (s *arrayStack) pop() any {
 	// 弹出栈前，先判断是否为空
-	if s.IsEmpty() {
+	if s.isEmpty() {
 		return nil
 	}
-	val := s.Peek()
+	val := s.peek()
 	s.data = s.data[:len(s.data)-1]
 	return val
 }
 
-// Peek 获取栈顶元素
-func (s *ArrayStack) Peek() any {
-	if s.IsEmpty() {
+// peek 获取栈顶元素
+func (s *arrayStack) peek() any {
+	if s.isEmpty() {
 		return nil
 	}
 	val := s.data[len(s.data)-1]
@@ -53,6 +53,6 @@ func (s *ArrayStack) Peek() any {
 }
 
 // 获取 Slice 用于打印
-func (s *ArrayStack) toSlice() []int {
+func (s *arrayStack) toSlice() []int {
 	return s.data
 }
diff --git a/codes/go/chapter_stack_and_queue/deque_test.go b/codes/go/chapter_stack_and_queue/deque_test.go
index 647ac642e..4c0f2f533 100644
--- a/codes/go/chapter_stack_and_queue/deque_test.go
+++ b/codes/go/chapter_stack_and_queue/deque_test.go
@@ -51,48 +51,48 @@ func TestDeque(t *testing.T) {
 
 func TestLinkedListDeque(t *testing.T) {
 	// 初始化队列
-	deque := NewLinkedListDeque()
+	deque := newLinkedListDeque()
 
 	// 元素入队
-	deque.OfferLast(2)
-	deque.OfferLast(5)
-	deque.OfferLast(4)
-	deque.OfferFirst(3)
-	deque.OfferFirst(1)
+	deque.offerLast(2)
+	deque.offerLast(5)
+	deque.offerLast(4)
+	deque.offerFirst(3)
+	deque.offerFirst(1)
 	fmt.Print("队列 deque = ")
 	PrintList(deque.toList())
 
 	// 访问队首元素
-	front := deque.PeekFirst()
+	front := deque.peekFirst()
 	fmt.Println("队首元素 front =", front)
-	rear := deque.PeekLast()
+	rear := deque.peekLast()
 	fmt.Println("队尾元素 rear =", rear)
 
 	// 元素出队
-	pollFirst := deque.PollFirst()
+	pollFirst := deque.pollFirst()
 	fmt.Print("队首出队元素 pollFirst = ", pollFirst, "，队首出队后 deque = ")
 	PrintList(deque.toList())
-	pollLast := deque.PollLast()
+	pollLast := deque.pollLast()
 	fmt.Print("队尾出队元素 pollLast = ", pollLast, "，队尾出队后 deque = ")
 	PrintList(deque.toList())
 
 	// 获取队的长度
-	size := deque.Size()
+	size := deque.size()
 	fmt.Println("队的长度 size =", size)
 
 	// 判断是否为空
-	isEmpty := deque.IsEmpty()
+	isEmpty := deque.isEmpty()
 	fmt.Println("队是否为空 =", isEmpty)
 }
 
 // BenchmarkArrayQueue 67.92 ns/op in Mac M1 Pro
 func BenchmarkLinkedListDeque(b *testing.B) {
-	stack := NewLinkedListDeque()
+	stack := newLinkedListDeque()
 	// use b.N for looping
 	for i := 0; i < b.N; i++ {
-		stack.OfferLast(777)
+		stack.offerLast(777)
 	}
 	for i := 0; i < b.N; i++ {
-		stack.PollFirst()
+		stack.pollFirst()
 	}
 }
diff --git a/codes/go/chapter_stack_and_queue/linkedlist_deque.go b/codes/go/chapter_stack_and_queue/linkedlist_deque.go
index 019aa778b..b1db77ca6 100644
--- a/codes/go/chapter_stack_and_queue/linkedlist_deque.go
+++ b/codes/go/chapter_stack_and_queue/linkedlist_deque.go
@@ -8,31 +8,31 @@ import (
 	"container/list"
 )
 
-// LinkedListDeque 基于链表实现的双端队列, 使用内置包 list 来实现栈
-type LinkedListDeque struct {
+// linkedListDeque 基于链表实现的双端队列, 使用内置包 list 来实现栈
+type linkedListDeque struct {
 	data *list.List
 }
 
-// NewLinkedListDeque 初始化双端队列
-func NewLinkedListDeque() *LinkedListDeque {
-	return &LinkedListDeque{
+// newLinkedListDeque 初始化双端队列
+func newLinkedListDeque() *linkedListDeque {
+	return &linkedListDeque{
 		data: list.New(),
 	}
 }
 
-// OfferFirst 队首元素入队
-func (s *LinkedListDeque) OfferFirst(value any) {
+// offerFirst 队首元素入队
+func (s *linkedListDeque) offerFirst(value any) {
 	s.data.PushFront(value)
 }
 
-// OfferLast 队尾元素入队
-func (s *LinkedListDeque) OfferLast(value any) {
+// offerLast 队尾元素入队
+func (s *linkedListDeque) offerLast(value any) {
 	s.data.PushBack(value)
 }
 
-// PollFirst 队首元素出队
-func (s *LinkedListDeque) PollFirst() any {
-	if s.IsEmpty() {
+// pollFirst 队首元素出队
+func (s *linkedListDeque) pollFirst() any {
+	if s.isEmpty() {
 		return nil
 	}
 	e := s.data.Front()
@@ -40,9 +40,9 @@ func (s *LinkedListDeque) PollFirst() any {
 	return e.Value
 }
 
-// PollLast 队尾元素出队
-func (s *LinkedListDeque) PollLast() any {
-	if s.IsEmpty() {
+// pollLast 队尾元素出队
+func (s *linkedListDeque) pollLast() any {
+	if s.isEmpty() {
 		return nil
 	}
 	e := s.data.Back()
@@ -50,35 +50,35 @@ func (s *LinkedListDeque) PollLast() any {
 	return e.Value
 }
 
-// PeekFirst 访问队首元素
-func (s *LinkedListDeque) PeekFirst() any {
-	if s.IsEmpty() {
+// peekFirst 访问队首元素
+func (s *linkedListDeque) peekFirst() any {
+	if s.isEmpty() {
 		return nil
 	}
 	e := s.data.Front()
 	return e.Value
 }
 
-// PeekLast 访问队尾元素
-func (s *LinkedListDeque) PeekLast() any {
-	if s.IsEmpty() {
+// peekLast 访问队尾元素
+func (s *linkedListDeque) peekLast() any {
+	if s.isEmpty() {
 		return nil
 	}
 	e := s.data.Back()
 	return e.Value
 }
 
-// Size 获取队列的长度
-func (s *LinkedListDeque) Size() int {
+// size 获取队列的长度
+func (s *linkedListDeque) size() int {
 	return s.data.Len()
 }
 
-// IsEmpty 判断队列是否为空
-func (s *LinkedListDeque) IsEmpty() bool {
+// isEmpty 判断队列是否为空
+func (s *linkedListDeque) isEmpty() bool {
 	return s.data.Len() == 0
 }
 
 // 获取 List 用于打印
-func (s *LinkedListDeque) toList() *list.List {
+func (s *linkedListDeque) toList() *list.List {
 	return s.data
 }
diff --git a/codes/go/chapter_stack_and_queue/linkedlist_queue.go b/codes/go/chapter_stack_and_queue/linkedlist_queue.go
index d30461805..f5d164a82 100644
--- a/codes/go/chapter_stack_and_queue/linkedlist_queue.go
+++ b/codes/go/chapter_stack_and_queue/linkedlist_queue.go
@@ -9,26 +9,26 @@ import (
 )
 
 /* 基于链表实现的队列 */
-type LinkedListQueue struct {
+type linkedListQueue struct {
 	// 使用内置包 list 来实现队列
 	data *list.List
 }
 
-// NewLinkedListQueue 初始化链表
-func NewLinkedListQueue() *LinkedListQueue {
-	return &LinkedListQueue{
+// newLinkedListQueue 初始化链表
+func newLinkedListQueue() *linkedListQueue {
+	return &linkedListQueue{
 		data: list.New(),
 	}
 }
 
-// Offer 入队
-func (s *LinkedListQueue) Offer(value any) {
+// offer 入队
+func (s *linkedListQueue) offer(value any) {
 	s.data.PushBack(value)
 }
 
-// Poll 出队
-func (s *LinkedListQueue) Poll() any {
-	if s.IsEmpty() {
+// poll 出队
+func (s *linkedListQueue) poll() any {
+	if s.isEmpty() {
 		return nil
 	}
 	e := s.data.Front()
@@ -36,26 +36,26 @@ func (s *LinkedListQueue) Poll() any {
 	return e.Value
 }
 
-// Peek 访问队首元素
-func (s *LinkedListQueue) Peek() any {
-	if s.IsEmpty() {
+// peek 访问队首元素
+func (s *linkedListQueue) peek() any {
+	if s.isEmpty() {
 		return nil
 	}
 	e := s.data.Front()
 	return e.Value
 }
 
-// Size 获取队列的长度
-func (s *LinkedListQueue) Size() int {
+// size 获取队列的长度
+func (s *linkedListQueue) size() int {
 	return s.data.Len()
 }
 
-// IsEmpty 判断队列是否为空
-func (s *LinkedListQueue) IsEmpty() bool {
+// isEmpty 判断队列是否为空
+func (s *linkedListQueue) isEmpty() bool {
 	return s.data.Len() == 0
 }
 
 // 获取 List 用于打印
-func (s *LinkedListQueue) toList() *list.List {
+func (s *linkedListQueue) toList() *list.List {
 	return s.data
 }
diff --git a/codes/go/chapter_stack_and_queue/linkedlist_stack.go b/codes/go/chapter_stack_and_queue/linkedlist_stack.go
index ab8a06284..8509c2b83 100644
--- a/codes/go/chapter_stack_and_queue/linkedlist_stack.go
+++ b/codes/go/chapter_stack_and_queue/linkedlist_stack.go
@@ -9,26 +9,26 @@ import (
 )
 
 /* 基于链表实现的栈 */
-type LinkedListStack struct {
+type linkedListStack struct {
 	// 使用内置包 list 来实现栈
 	data *list.List
 }
 
-// NewLinkedListStack 初始化链表
-func NewLinkedListStack() *LinkedListStack {
-	return &LinkedListStack{
+// newLinkedListStack 初始化链表
+func newLinkedListStack() *linkedListStack {
+	return &linkedListStack{
 		data: list.New(),
 	}
 }
 
-// Push 入栈
-func (s *LinkedListStack) Push(value int) {
+// push 入栈
+func (s *linkedListStack) push(value int) {
 	s.data.PushBack(value)
 }
 
-// Pop 出栈
-func (s *LinkedListStack) Pop() any {
-	if s.IsEmpty() {
+// pop 出栈
+func (s *linkedListStack) pop() any {
+	if s.isEmpty() {
 		return nil
 	}
 	e := s.data.Back()
@@ -36,26 +36,26 @@ func (s *LinkedListStack) Pop() any {
 	return e.Value
 }
 
-// Peek 访问栈顶元素
-func (s *LinkedListStack) Peek() any {
-	if s.IsEmpty() {
+// peek 访问栈顶元素
+func (s *linkedListStack) peek() any {
+	if s.isEmpty() {
 		return nil
 	}
 	e := s.data.Back()
 	return e.Value
 }
 
-// Size 获取栈的长度
-func (s *LinkedListStack) Size() int {
+// size 获取栈的长度
+func (s *linkedListStack) size() int {
 	return s.data.Len()
 }
 
-// IsEmpty 判断栈是否为空
-func (s *LinkedListStack) IsEmpty() bool {
+// isEmpty 判断栈是否为空
+func (s *linkedListStack) isEmpty() bool {
 	return s.data.Len() == 0
 }
 
 // 获取 List 用于打印
-func (s *LinkedListStack) toList() *list.List {
+func (s *linkedListStack) toList() *list.List {
 	return s.data
 }
diff --git a/codes/go/chapter_stack_and_queue/queue_test.go b/codes/go/chapter_stack_and_queue/queue_test.go
index 368becbc7..b9ec79df2 100644
--- a/codes/go/chapter_stack_and_queue/queue_test.go
+++ b/codes/go/chapter_stack_and_queue/queue_test.go
@@ -48,87 +48,87 @@ func TestQueue(t *testing.T) {
 func TestArrayQueue(t *testing.T) {
 	// 初始化队列，使用队列的通用接口
 	capacity := 10
-	queue := NewArrayQueue(capacity)
+	queue := newArrayQueue(capacity)
 
 	// 元素入队
-	queue.Offer(1)
-	queue.Offer(3)
-	queue.Offer(2)
-	queue.Offer(5)
-	queue.Offer(4)
+	queue.offer(1)
+	queue.offer(3)
+	queue.offer(2)
+	queue.offer(5)
+	queue.offer(4)
 	fmt.Print("队列 queue = ")
 	PrintSlice(queue.toSlice())
 
 	// 访问队首元素
-	peek := queue.Peek()
+	peek := queue.peek()
 	fmt.Println("队首元素 peek =", peek)
 
 	// 元素出队
-	poll := queue.Poll()
+	poll := queue.poll()
 	fmt.Print("出队元素 poll = ", poll, ", 出队后 queue = ")
 	PrintSlice(queue.toSlice())
 
 	// 获取队的长度
-	size := queue.Size()
+	size := queue.size()
 	fmt.Println("队的长度 size =", size)
 
 	// 判断是否为空
-	isEmpty := queue.IsEmpty()
+	isEmpty := queue.isEmpty()
 	fmt.Println("队是否为空 =", isEmpty)
 }
 
 func TestLinkedListQueue(t *testing.T) {
 	// 初始化队
-	queue := NewLinkedListQueue()
+	queue := newLinkedListQueue()
 
 	// 元素入队
-	queue.Offer(1)
-	queue.Offer(3)
-	queue.Offer(2)
-	queue.Offer(5)
-	queue.Offer(4)
+	queue.offer(1)
+	queue.offer(3)
+	queue.offer(2)
+	queue.offer(5)
+	queue.offer(4)
 	fmt.Print("队列 queue = ")
 	PrintList(queue.toList())
 
 	// 访问队首元素
-	peek := queue.Peek()
+	peek := queue.peek()
 	fmt.Println("队首元素 peek =", peek)
 
 	// 元素出队
-	poll := queue.Poll()
+	poll := queue.poll()
 	fmt.Print("出队元素 poll = ", poll, ", 出队后 queue = ")
 	PrintList(queue.toList())
 
 	// 获取队的长度
-	size := queue.Size()
+	size := queue.size()
 	fmt.Println("队的长度 size =", size)
 
 	// 判断是否为空
-	isEmpty := queue.IsEmpty()
+	isEmpty := queue.isEmpty()
 	fmt.Println("队是否为空 =", isEmpty)
 }
 
 // BenchmarkArrayQueue 8 ns/op in Mac M1 Pro
 func BenchmarkArrayQueue(b *testing.B) {
 	capacity := 1000
-	stack := NewArrayQueue(capacity)
+	stack := newArrayQueue(capacity)
 	// use b.N for looping
 	for i := 0; i < b.N; i++ {
-		stack.Offer(777)
+		stack.offer(777)
 	}
 	for i := 0; i < b.N; i++ {
-		stack.Poll()
+		stack.poll()
 	}
 }
 
 // BenchmarkLinkedQueue 62.66 ns/op in Mac M1 Pro
 func BenchmarkLinkedQueue(b *testing.B) {
-	stack := NewLinkedListQueue()
+	stack := newLinkedListQueue()
 	// use b.N for looping
 	for i := 0; i < b.N; i++ {
-		stack.Offer(777)
+		stack.offer(777)
 	}
 	for i := 0; i < b.N; i++ {
-		stack.Poll()
+		stack.poll()
 	}
 }
diff --git a/codes/go/chapter_stack_and_queue/stack_test.go b/codes/go/chapter_stack_and_queue/stack_test.go
index 9dc97e697..a4cf338b7 100644
--- a/codes/go/chapter_stack_and_queue/stack_test.go
+++ b/codes/go/chapter_stack_and_queue/stack_test.go
@@ -46,85 +46,85 @@ func TestStack(t *testing.T) {
 
 func TestArrayStack(t *testing.T) {
 	// 初始化栈, 使用接口承接
-	stack := NewArrayStack()
+	stack := newArrayStack()
 
 	// 元素入栈
-	stack.Push(1)
-	stack.Push(3)
-	stack.Push(2)
-	stack.Push(5)
-	stack.Push(4)
+	stack.push(1)
+	stack.push(3)
+	stack.push(2)
+	stack.push(5)
+	stack.push(4)
 	fmt.Print("栈 stack = ")
 	PrintSlice(stack.toSlice())
 
 	// 访问栈顶元素
-	peek := stack.Peek()
+	peek := stack.peek()
 	fmt.Println("栈顶元素 peek =", peek)
 
 	// 元素出栈
-	pop := stack.Pop()
+	pop := stack.pop()
 	fmt.Print("出栈元素 pop = ", pop, ", 出栈后 stack = ")
 	PrintSlice(stack.toSlice())
 
 	// 获取栈的长度
-	size := stack.Size()
+	size := stack.size()
 	fmt.Println("栈的长度 size =", size)
 
 	// 判断是否为空
-	isEmpty := stack.IsEmpty()
+	isEmpty := stack.isEmpty()
 	fmt.Println("栈是否为空 =", isEmpty)
 }
 
 func TestLinkedListStack(t *testing.T) {
 	// 初始化栈
-	stack := NewLinkedListStack()
+	stack := newLinkedListStack()
 	// 元素入栈
-	stack.Push(1)
-	stack.Push(3)
-	stack.Push(2)
-	stack.Push(5)
-	stack.Push(4)
+	stack.push(1)
+	stack.push(3)
+	stack.push(2)
+	stack.push(5)
+	stack.push(4)
 	fmt.Print("栈 stack = ")
 	PrintList(stack.toList())
 
 	// 访问栈顶元素
-	peek := stack.Peek()
+	peek := stack.peek()
 	fmt.Println("栈顶元素 peek =", peek)
 
 	// 元素出栈
-	pop := stack.Pop()
+	pop := stack.pop()
 	fmt.Print("出栈元素 pop = ", pop, ", 出栈后 stack = ")
 	PrintList(stack.toList())
 
 	// 获取栈的长度
-	size := stack.Size()
+	size := stack.size()
 	fmt.Println("栈的长度 size =", size)
 
 	// 判断是否为空
-	isEmpty := stack.IsEmpty()
+	isEmpty := stack.isEmpty()
 	fmt.Println("栈是否为空 =", isEmpty)
 }
 
 // BenchmarkArrayStack 8 ns/op in Mac M1 Pro
 func BenchmarkArrayStack(b *testing.B) {
-	stack := NewArrayStack()
+	stack := newArrayStack()
 	// use b.N for looping
 	for i := 0; i < b.N; i++ {
-		stack.Push(777)
+		stack.push(777)
 	}
 	for i := 0; i < b.N; i++ {
-		stack.Pop()
+		stack.pop()
 	}
 }
 
 // BenchmarkLinkedListStack 65.02 ns/op in Mac M1 Pro
 func BenchmarkLinkedListStack(b *testing.B) {
-	stack := NewLinkedListStack()
+	stack := newLinkedListStack()
 	// use b.N for looping
 	for i := 0; i < b.N; i++ {
-		stack.Push(777)
+		stack.push(777)
 	}
 	for i := 0; i < b.N; i++ {
-		stack.Pop()
+		stack.pop()
 	}
 }
diff --git a/codes/go/chapter_tree/binary_search_tree.go b/codes/go/chapter_tree/binary_search_tree.go
index c8fc5d62c..61ed400d5 100644
--- a/codes/go/chapter_tree/binary_search_tree.go
+++ b/codes/go/chapter_tree/binary_search_tree.go
@@ -10,26 +10,26 @@ import (
 	. "github.com/krahets/hello-algo/pkg"
 )
 
-type BinarySearchTree struct {
+type binarySearchTree struct {
 	root *TreeNode
 }
 
-func NewBinarySearchTree(nums []int) *BinarySearchTree {
+func newBinarySearchTree(nums []int) *binarySearchTree {
 	// sorting array
 	sort.Ints(nums)
 	root := buildBinarySearchTree(nums, 0, len(nums)-1)
-	return &BinarySearchTree{
+	return &binarySearchTree{
 		root: root,
 	}
 }
 
 /* 获取根结点 */
-func (bst *BinarySearchTree) GetRoot() *TreeNode {
+func (bst *binarySearchTree) getRoot() *TreeNode {
 	return bst.root
 }
 
 /* 获取中序遍历的下一个结点 */
-func (bst *BinarySearchTree) GetInOrderNext(node *TreeNode) *TreeNode {
+func (bst *binarySearchTree) getInOrderNext(node *TreeNode) *TreeNode {
 	if node == nil {
 		return node
 	}
@@ -41,7 +41,7 @@ func (bst *BinarySearchTree) GetInOrderNext(node *TreeNode) *TreeNode {
 }
 
 /* 查找结点 */
-func (bst *BinarySearchTree) Search(num int) *TreeNode {
+func (bst *binarySearchTree) search(num int) *TreeNode {
 	node := bst.root
 	// 循环查找，越过叶结点后跳出
 	for node != nil {
@@ -61,7 +61,7 @@ func (bst *BinarySearchTree) Search(num int) *TreeNode {
 }
 
 /* 插入结点 */
-func (bst *BinarySearchTree) Insert(num int) *TreeNode {
+func (bst *binarySearchTree) insert(num int) *TreeNode {
 	cur := bst.root
 	// 若树为空，直接提前返回
 	if cur == nil {
@@ -92,7 +92,7 @@ func (bst *BinarySearchTree) Insert(num int) *TreeNode {
 }
 
 /* 删除结点 */
-func (bst *BinarySearchTree) Remove(num int) *TreeNode {
+func (bst *binarySearchTree) remove(num int) *TreeNode {
 	cur := bst.root
 	// 若树为空，直接提前返回
 	if cur == nil {
@@ -136,10 +136,10 @@ func (bst *BinarySearchTree) Remove(num int) *TreeNode {
 		// 子结点数为 2
 	} else {
 		// 获取中序遍历中待删除结点 cur 的下一个结点
-		next := bst.GetInOrderNext(cur)
+		next := bst.getInOrderNext(cur)
 		temp := next.Val
 		// 递归删除结点 next
-		bst.Remove(next.Val)
+		bst.remove(next.Val)
 		// 将 next 的值复制给 cur
 		cur.Val = temp
 	}
@@ -160,7 +160,7 @@ func buildBinarySearchTree(nums []int, left, right int) *TreeNode {
 	return root
 }
 
-// Print binary search tree
-func (bst *BinarySearchTree) Print() {
+// print binary search tree
+func (bst *binarySearchTree) print() {
 	PrintTree(bst.root)
 }
diff --git a/codes/go/chapter_tree/binary_search_tree_test.go b/codes/go/chapter_tree/binary_search_tree_test.go
index cdf7d8d48..877f1b541 100644
--- a/codes/go/chapter_tree/binary_search_tree_test.go
+++ b/codes/go/chapter_tree/binary_search_tree_test.go
@@ -11,31 +11,31 @@ import (
 
 func TestBinarySearchTree(t *testing.T) {
 	nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
-	bst := NewBinarySearchTree(nums)
+	bst := newBinarySearchTree(nums)
 	fmt.Println("\n初始化的二叉树为:")
-	bst.Print()
+	bst.print()
 
 	// 获取根结点
-	node := bst.GetRoot()
+	node := bst.getRoot()
 	fmt.Println("\n二叉树的根结点为:", node.Val)
 
 	// 查找结点
-	node = bst.Search(5)
+	node = bst.search(5)
 	fmt.Println("\n查找到的结点对象为", node, "，结点值 =", node.Val)
 
 	// 插入结点
-	node = bst.Insert(16)
+	node = bst.insert(16)
 	fmt.Println("\n插入结点后 16 的二叉树为:")
-	bst.Print()
+	bst.print()
 
 	// 删除结点
-	bst.Remove(1)
+	bst.remove(1)
 	fmt.Println("\n删除结点 1 后的二叉树为:")
-	bst.Print()
-	bst.Remove(2)
+	bst.print()
+	bst.remove(2)
 	fmt.Println("\n删除结点 2 后的二叉树为:")
-	bst.Print()
-	bst.Remove(4)
+	bst.print()
+	bst.remove(4)
 	fmt.Println("\n删除结点 4 后的二叉树为:")
-	bst.Print()
+	bst.print()
 }
diff --git a/codes/go/pkg/print_utils.go b/codes/go/pkg/print_utils.go
index a42d48b2f..575ab6b94 100644
--- a/codes/go/pkg/print_utils.go
+++ b/codes/go/pkg/print_utils.go
@@ -76,7 +76,7 @@ func printTreeHelper(root *TreeNode, prev *trunk, isLeft bool) {
 	printTreeHelper(root.Left, trunk, false)
 }
 
-// trunk Help to Print tree structure
+// trunk Help to print tree structure
 type trunk struct {
 	prev *trunk
 	str  string
@@ -103,4 +103,4 @@ func PrintMap[K comparable, V any](m map[K]V) {
 	for key, value := range m {
 		fmt.Println(key, "->", value)
 	}
-}
\ No newline at end of file
+}

From 33e2c4f4d31450ac03b201746bca3c3248addcc5 Mon Sep 17 00:00:00 2001
From: reanon <793584285@qq.com>
Date: Sun, 8 Jan 2023 20:00:36 +0800
Subject: [PATCH 128/158] fix(tree): fix ArrToTree in go code

---
 codes/go/chapter_tree/binary_tree_bfs_test.go |  2 +-
 codes/go/chapter_tree/binary_tree_dfs_test.go |  2 +-
 codes/go/pkg/tree_node.go                     | 17 +++++++++++------
 codes/go/pkg/tree_node_test.go                |  2 +-
 4 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/codes/go/chapter_tree/binary_tree_bfs_test.go b/codes/go/chapter_tree/binary_tree_bfs_test.go
index d32dbdca9..7b1bbf1f5 100644
--- a/codes/go/chapter_tree/binary_tree_bfs_test.go
+++ b/codes/go/chapter_tree/binary_tree_bfs_test.go
@@ -14,7 +14,7 @@ import (
 func TestLevelOrder(t *testing.T) {
 	/* 初始化二叉树 */
 	// 这里借助了一个从数组直接生成二叉树的函数
-	root := ArrToTree([]int{1, 2, 3, 4, 5, 6, 7})
+	root := ArrToTree([]any{1, 2, 3, 4, 5, 6, 7})
 	fmt.Println("\n初始化二叉树: ")
 	PrintTree(root)
 
diff --git a/codes/go/chapter_tree/binary_tree_dfs_test.go b/codes/go/chapter_tree/binary_tree_dfs_test.go
index b0db8086c..9e0dfe22f 100644
--- a/codes/go/chapter_tree/binary_tree_dfs_test.go
+++ b/codes/go/chapter_tree/binary_tree_dfs_test.go
@@ -14,7 +14,7 @@ import (
 func TestPreInPostOrderTraversal(t *testing.T) {
 	/* 初始化二叉树 */
 	// 这里借助了一个从数组直接生成二叉树的函数
-	root := ArrToTree([]int{1, 2, 3, 4, 5, 6, 7})
+	root := ArrToTree([]any{1, 2, 3, 4, 5, 6, 7})
 	fmt.Println("\n初始化二叉树: ")
 	PrintTree(root)
 
diff --git a/codes/go/pkg/tree_node.go b/codes/go/pkg/tree_node.go
index b1e630e67..23eb3d154 100644
--- a/codes/go/pkg/tree_node.go
+++ b/codes/go/pkg/tree_node.go
@@ -23,11 +23,12 @@ func NewTreeNode(v int) *TreeNode {
 }
 
 // ArrToTree Generate a binary tree given an array
-func ArrToTree(arr []int) *TreeNode {
+func ArrToTree(arr []any) *TreeNode {
 	if len(arr) <= 0 {
 		return nil
 	}
-	root := NewTreeNode(arr[0])
+	// TreeNode only accept integer value for now.
+	root := NewTreeNode(arr[0].(int))
 	// Let container.list as queue
 	queue := list.New()
 	queue.PushBack(root)
@@ -37,13 +38,17 @@ func ArrToTree(arr []int) *TreeNode {
 		node := queue.Remove(queue.Front()).(*TreeNode)
 		i++
 		if i < len(arr) {
-			node.Left = NewTreeNode(arr[i])
-			queue.PushBack(node.Left)
+			if arr[i] != nil {
+				node.Left = NewTreeNode(arr[i].(int))
+				queue.PushBack(node.Left)
+			}
 		}
 		i++
 		if i < len(arr) {
-			node.Right = NewTreeNode(arr[i])
-			queue.PushBack(node.Right)
+			if arr[i] != nil {
+				node.Right = NewTreeNode(arr[i].(int))
+				queue.PushBack(node.Right)
+			}
 		}
 	}
 	return root
diff --git a/codes/go/pkg/tree_node_test.go b/codes/go/pkg/tree_node_test.go
index bb1885ee1..ec7831bf7 100644
--- a/codes/go/pkg/tree_node_test.go
+++ b/codes/go/pkg/tree_node_test.go
@@ -10,7 +10,7 @@ import (
 )
 
 func TestTreeNode(t *testing.T) {
-	arr := []int{2, 3, 5, 6, 7}
+	arr := []any{1, 2, 3, nil, 5, 6, nil}
 	node := ArrToTree(arr)
 
 	// print tree

From 0243957015fb75675ae48ea1dcab8038aafb72e6 Mon Sep 17 00:00:00 2001
From: reanon <793584285@qq.com>
Date: Sun, 8 Jan 2023 20:29:13 +0800
Subject: [PATCH 129/158] doc(code): modify go code in docs

---
 docs/chapter_array_and_linkedlist/list.md     | 25 +++---
 .../space_complexity.md                       | 16 ++--
 docs/chapter_hashing/hash_map.md              | 24 +++---
 docs/chapter_sorting/merge_sort.md            | 19 +++--
 docs/chapter_sorting/quick_sort.md            | 10 +--
 docs/chapter_stack_and_queue/queue.md         | 78 +++++++++++--------
 docs/chapter_stack_and_queue/stack.md         | 78 +++++++++++--------
 docs/chapter_tree/binary_search_tree.md       | 10 +--
 8 files changed, 143 insertions(+), 117 deletions(-)

diff --git a/docs/chapter_array_and_linkedlist/list.md b/docs/chapter_array_and_linkedlist/list.md
index d1109d65b..ca4774a04 100644
--- a/docs/chapter_array_and_linkedlist/list.md
+++ b/docs/chapter_array_and_linkedlist/list.md
@@ -864,7 +864,7 @@ comments: true
 
     ```go title="my_list.go"
     /* 列表类简易实现 */
-    type MyList struct {
+    type myList struct {
         numsCapacity int
         nums         []int
         numsSize     int
@@ -872,8 +872,8 @@ comments: true
     }
 
     /* 构造函数 */
-    func newMyList() *MyList {
-        return &MyList{
+    func newMyList() *myList {
+        return &myList{
             numsCapacity: 10,              // 列表容量
             nums:         make([]int, 10), // 数组（存储列表元素）
             numsSize:     0,               // 列表长度（即当前元素数量）
@@ -882,17 +882,17 @@ comments: true
     }
 
     /* 获取列表长度（即当前元素数量） */
-    func (l *MyList) size() int {
+    func (l *myList) size() int {
         return l.numsSize
     }
 
     /*  获取列表容量 */
-    func (l *MyList) capacity() int {
+    func (l *myList) capacity() int {
         return l.numsCapacity
     }
 
     /* 访问元素 */
-    func (l *MyList) get(index int) int {
+    func (l *myList) get(index int) int {
         // 索引如果越界则抛出异常，下同
         if index >= l.numsSize {
             panic("索引越界")
@@ -901,7 +901,7 @@ comments: true
     }
 
     /* 更新元素 */
-    func (l *MyList) set(num, index int) {
+    func (l *myList) set(num, index int) {
         if index >= l.numsSize {
             panic("索引越界")
         }
@@ -909,7 +909,7 @@ comments: true
     }
 
     /* 尾部添加元素 */
-    func (l *MyList) add(num int) {
+    func (l *myList) add(num int) {
         // 元素数量超出容量时，触发扩容机制
         if l.numsSize == l.numsCapacity {
             l.extendCapacity()
@@ -920,7 +920,7 @@ comments: true
     }
 
     /* 中间插入元素 */
-    func (l *MyList) insert(num, index int) {
+    func (l *myList) insert(num, index int) {
         if index >= l.numsSize {
             panic("索引越界")
         }
@@ -938,20 +938,23 @@ comments: true
     }
 
     /* 删除元素 */
-    func (l *MyList) Remove(index int) {
+    func (l *myList) remove(index int) int {
         if index >= l.numsSize {
             panic("索引越界")
         }
+        num := l.nums[index]
         // 索引 i 之后的元素都向前移动一位
         for j := index; j < l.numsSize-1; j++ {
             l.nums[j] = l.nums[j+1]
         }
         // 更新元素数量
         l.numsSize--
+        // 返回被删除元素
+        return num
     }
 
     /* 列表扩容 */
-    func (l *MyList) extendCapacity() {
+    func (l *myList) extendCapacity() {
         // 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组
         l.nums = append(l.nums, make([]int, l.numsCapacity*(l.extendRatio-1))...)
         // 更新列表容量
diff --git a/docs/chapter_computational_complexity/space_complexity.md b/docs/chapter_computational_complexity/space_complexity.md
index 1756f2e24..f563f4953 100644
--- a/docs/chapter_computational_complexity/space_complexity.md
+++ b/docs/chapter_computational_complexity/space_complexity.md
@@ -103,14 +103,14 @@ comments: true
 
     ```go title=""
     /* 结构体 */
-    type Node struct {
+    type node struct {
         val  int
-        next *Node
+        next *node
     }
-    
-    /* 创建 Node 结构体 */
-    func newNode(val int) *Node {
-        return &Node{val: val}
+
+    /* 创建 node 结构体  */
+    func newNode(val int) *node {
+        return &node{val: val}
     }
     
     /* 函数 */
@@ -687,7 +687,7 @@ $$
         // 长度为 n 的数组占用 O(n) 空间
         _ = make([]int, n)
         // 长度为 n 的列表占用 O(n) 空间
-        var nodes []*Node
+        var nodes []*node
         for i := 0; i < n; i++ {
             nodes = append(nodes, newNode(i))
         }
@@ -1108,7 +1108,7 @@ $$
 
     ```go title="space_complexity.go"
     /* 指数阶（建立满二叉树） */
-    func buildTree(n int) *TreeNode {
+    func buildTree(n int) *treeNode {
         if n == 0 {
             return nil
         }
diff --git a/docs/chapter_hashing/hash_map.md b/docs/chapter_hashing/hash_map.md
index 3a69d88fc..2d8a66a5d 100644
--- a/docs/chapter_hashing/hash_map.md
+++ b/docs/chapter_hashing/hash_map.md
@@ -524,30 +524,30 @@ $$
 
     ```go title="array_hash_map.go"
     /* 键值对 int->String */
-    type Entry struct {
+    type entry struct {
         key int
         val string
     }
 
     /* 基于数组简易实现的哈希表 */
-    type ArrayHashMap struct {
-        bucket []*Entry
+    type arrayHashMap struct {
+        bucket []*entry
     }
 
-    func newArrayHashMap() *ArrayHashMap {
+    func newArrayHashMap() *arrayHashMap {
         // 初始化一个长度为 100 的桶（数组）
-        bucket := make([]*Entry, 100)
-        return &ArrayHashMap{bucket: bucket}
+        bucket := make([]*entry, 100)
+        return &arrayHashMap{bucket: bucket}
     }
 
     /* 哈希函数 */
-    func (a *ArrayHashMap) hashFunc(key int) int {
+    func (a *arrayHashMap) hashFunc(key int) int {
         index := key % 100
         return index
     }
 
     /* 查询操作 */
-    func (a *ArrayHashMap) get(key int) string {
+    func (a *arrayHashMap) get(key int) string {
         index := a.hashFunc(key)
         pair := a.bucket[index]
         if pair == nil {
@@ -557,16 +557,16 @@ $$
     }
 
     /* 添加操作 */
-    func (a *ArrayHashMap) put(key int, val string) {
-        pair := &Entry{key: key, val: val}
+    func (a *arrayHashMap) put(key int, val string) {
+        pair := &entry{key: key, val: val}
         index := a.hashFunc(key)
         a.bucket[index] = pair
     }
 
     /* 删除操作 */
-    func (a *ArrayHashMap) remove(key int) {
+    func (a *arrayHashMap) remove(key int) {
         index := a.hashFunc(key)
-        // 置为空字符，代表删除
+        // 置为 nil ，代表删除
         a.bucket[index] = nil
     }
     ```
diff --git a/docs/chapter_sorting/merge_sort.md b/docs/chapter_sorting/merge_sort.md
index 396baa089..ae0cfc7c2 100644
--- a/docs/chapter_sorting/merge_sort.md
+++ b/docs/chapter_sorting/merge_sort.md
@@ -201,36 +201,35 @@ comments: true
         右子数组区间 [mid + 1, right]
     */
     func merge(nums []int, left, mid, right int) {
-        // 初始化辅助数组 借助 copy模块
+        // 初始化辅助数组 借助 copy 模块
         tmp := make([]int, right-left+1)
         for i := left; i <= right; i++ {
             tmp[i-left] = nums[i]
         }
         // 左子数组的起始索引和结束索引
-        left_start, left_end := left-left, mid-left
+        leftStart, leftEnd := left-left, mid-left
         // 右子数组的起始索引和结束索引
-        right_start, right_end := mid+1-left, right-left
+        rightStart, rightEnd := mid+1-left, right-left
         // i, j 分别指向左子数组、右子数组的首元素
-        i, j := left_start, right_start
+        i, j := leftStart, rightStart
         // 通过覆盖原数组 nums 来合并左子数组和右子数组
         for k := left; k <= right; k++ {
             // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
-            if i > left_end {
+            if i > leftEnd {
                 nums[k] = tmp[j]
                 j++
-            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
-            } else if j > right_end || tmp[i] <= tmp[j] {
+                // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            } else if j > rightEnd || tmp[i] <= tmp[j] {
                 nums[k] = tmp[i]
                 i++
-            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+                // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
             } else {
                 nums[k] = tmp[j]
                 j++
             }
         }
     }
-    
-    /* 归并排序 */
+
     func mergeSort(nums []int, left, right int) {
         // 终止条件
         if left >= right {
diff --git a/docs/chapter_sorting/quick_sort.md b/docs/chapter_sorting/quick_sort.md
index f8dcc3238..3eeac9c65 100644
--- a/docs/chapter_sorting/quick_sort.md
+++ b/docs/chapter_sorting/quick_sort.md
@@ -111,21 +111,21 @@ comments: true
     ```go title="quick_sort.go"
     /* 哨兵划分 */
     func partition(nums []int, left, right int) int {
-        //以 nums[left] 作为基准数
+        // 以 nums[left] 作为基准数
         i, j := left, right
         for i < j {
             for i < j && nums[j] >= nums[left] {
-                j-- //从右向左找首个小于基准数的元素
+                j-- // 从右向左找首个小于基准数的元素
             }
             for i < j && nums[i] <= nums[left] {
-                i++ //从左向右找首个大于基准数的元素
+                i++ // 从左向右找首个大于基准数的元素
             }
             //元素交换
             nums[i], nums[j] = nums[j], nums[i]
         }
-        //将基准数交换至两子数组的分界线
+        // 将基准数交换至两子数组的分界线
         nums[i], nums[left] = nums[left], nums[i]
-        return i //返回基准数的索引
+        return i // 返回基准数的索引
     }
     ```
 
diff --git a/docs/chapter_stack_and_queue/queue.md b/docs/chapter_stack_and_queue/queue.md
index ce47edb38..0c589fa69 100644
--- a/docs/chapter_stack_and_queue/queue.md
+++ b/docs/chapter_stack_and_queue/queue.md
@@ -404,43 +404,49 @@ comments: true
 
     ```go title="linkedlist_queue.go"
     /* 基于链表实现的队列 */
-    type LinkedListQueue struct {
+    type linkedListQueue struct {
         // 使用内置包 list 来实现队列
         data *list.List
     }
-    // NewLinkedListQueue 初始化链表
-    func NewLinkedListQueue() *LinkedListQueue {
-        return &LinkedListQueue{
+
+    // newLinkedListQueue 初始化链表
+    func newLinkedListQueue() *linkedListQueue {
+        return &linkedListQueue{
             data: list.New(),
         }
     }
-    // Offer 入队
-    func (s *LinkedListQueue) Offer(value any) {
+
+    // offer 入队
+    func (s *linkedListQueue) offer(value any) {
         s.data.PushBack(value)
     }
-    // Poll 出队
-    func (s *LinkedListQueue) Poll() any {
-        if s.IsEmpty() {
+
+    // poll 出队
+    func (s *linkedListQueue) poll() any {
+        if s.isEmpty() {
             return nil
         }
         e := s.data.Front()
         s.data.Remove(e)
         return e.Value
     }
-    // Peek 访问队首元素
-    func (s *LinkedListQueue) Peek() any {
-        if s.IsEmpty() {
+
+    // peek 访问队首元素
+    func (s *linkedListQueue) peek() any {
+        if s.isEmpty() {
             return nil
         }
         e := s.data.Front()
         return e.Value
     }
-    // Size 获取队列的长度
-    func (s *LinkedListQueue) Size() int {
+
+    // size 获取队列的长度
+    func (s *linkedListQueue) size() int {
         return s.data.Len()
     }
-    // IsEmpty 判断队列是否为空
-    func (s *LinkedListQueue) IsEmpty() bool {
+
+    // isEmpty 判断队列是否为空
+    func (s *linkedListQueue) isEmpty() bool {
         return s.data.Len() == 0
     }
     ```
@@ -805,34 +811,38 @@ comments: true
 
     ```go title="array_queue.go"
     /* 基于环形数组实现的队列 */
-    type ArrayQueue struct {
+    type arrayQueue struct {
         data     []int // 用于存储队列元素的数组
         capacity int   // 队列容量（即最多容量的元素个数）
         front    int   // 头指针，指向队首
         rear     int   // 尾指针，指向队尾 + 1
     }
-    // NewArrayQueue 基于环形数组实现的队列
-    func NewArrayQueue(capacity int) *ArrayQueue {
-        return &ArrayQueue{
+
+    // newArrayQueue 基于环形数组实现的队列
+    func newArrayQueue(capacity int) *arrayQueue {
+        return &arrayQueue{
             data:     make([]int, capacity),
             capacity: capacity,
             front:    0,
             rear:     0,
         }
     }
-    // Size 获取队列的长度
-    func (q *ArrayQueue) Size() int {
+
+    // size 获取队列的长度
+    func (q *arrayQueue) size() int {
         size := (q.capacity + q.rear - q.front) % q.capacity
         return size
     }
-    // IsEmpty 判断队列是否为空
-    func (q *ArrayQueue) IsEmpty() bool {
+
+    // isEmpty 判断队列是否为空
+    func (q *arrayQueue) isEmpty() bool {
         return q.rear-q.front == 0
     }
-    // Offer 入队
-    func (q *ArrayQueue) Offer(v int) {
+
+    // offer 入队
+    func (q *arrayQueue) offer(v int) {
         // 当 rear == capacity 表示队列已满
-        if q.Size() == q.capacity {
+        if q.size() == q.capacity {
             return
         }
         // 尾结点后添加
@@ -840,9 +850,10 @@ comments: true
         // 尾指针向后移动一位，越过尾部后返回到数组头部
         q.rear = (q.rear + 1) % q.capacity
     }
-    // Poll 出队
-    func (q *ArrayQueue) Poll() any {
-        if q.IsEmpty() {
+
+    // poll 出队
+    func (q *arrayQueue) poll() any {
+        if q.isEmpty() {
             return nil
         }
         v := q.data[q.front]
@@ -850,9 +861,10 @@ comments: true
         q.front = (q.front + 1) % q.capacity
         return v
     }
-    // Peek 访问队首元素
-    func (q *ArrayQueue) Peek() any {
-        if q.IsEmpty() {
+
+    // peek 访问队首元素
+    func (q *arrayQueue) peek() any {
+        if q.isEmpty() {
             return nil
         }
         v := q.data[q.front]
diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index 374de7424..8bb343c4f 100644
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -378,43 +378,49 @@ comments: true
 
     ```go title="linkedlist_stack.go"
     /* 基于链表实现的栈 */
-    type LinkedListStack struct {
+    type linkedListStack struct {
         // 使用内置包 list 来实现栈
         data *list.List
     }
-    // NewLinkedListStack 初始化链表
-    func NewLinkedListStack() *LinkedListStack {
-        return &LinkedListStack{
+
+    // newLinkedListStack 初始化链表
+    func newLinkedListStack() *linkedListStack {
+        return &linkedListStack{
             data: list.New(),
         }
     }
-    // Push 入栈
-    func (s *LinkedListStack) Push(value int) {
+
+    // push 入栈
+    func (s *linkedListStack) push(value int) {
         s.data.PushBack(value)
     }
-    // Pop 出栈
-    func (s *LinkedListStack) Pop() any {
-        if s.IsEmpty() {
+
+    // pop 出栈
+    func (s *linkedListStack) pop() any {
+        if s.isEmpty() {
             return nil
         }
         e := s.data.Back()
         s.data.Remove(e)
         return e.Value
     }
-    // Peek 访问栈顶元素
-    func (s *LinkedListStack) Peek() any {
-        if s.IsEmpty() {
+
+    // peek 访问栈顶元素
+    func (s *linkedListStack) peek() any {
+        if s.isEmpty() {
             return nil
         }
         e := s.data.Back()
         return e.Value
     }
-    // Size 获取栈的长度
-    func (s *LinkedListStack) Size() int {
+
+    // size 获取栈的长度
+    func (s *linkedListStack) size() int {
         return s.data.Len()
     }
-    // IsEmpty 判断栈是否为空
-    func (s *LinkedListStack) IsEmpty() bool {
+
+    // isEmpty 判断栈是否为空
+    func (s *linkedListStack) isEmpty() bool {
         return s.data.Len() == 0
     }
     ```
@@ -716,41 +722,47 @@ comments: true
 
     ```go title="array_stack.go"
     /* 基于数组实现的栈 */
-    type ArrayStack struct {
+    type arrayStack struct {
         data []int // 数据
     }
-    func NewArrayStack() *ArrayStack {
-        return &ArrayStack{
+
+    func newArrayStack() *arrayStack {
+        return &arrayStack{
             // 设置栈的长度为 0，容量为 16
             data: make([]int, 0, 16),
         }
     }
-    // Size 栈的长度
-    func (s *ArrayStack) Size() int {
+
+    // size 栈的长度
+    func (s *arrayStack) size() int {
         return len(s.data)
     }
-    // IsEmpty 栈是否为空
-    func (s *ArrayStack) IsEmpty() bool {
-        return s.Size() == 0
+
+    // isEmpty 栈是否为空
+    func (s *arrayStack) isEmpty() bool {
+        return s.size() == 0
     }
-    // Push 入栈
-    func (s *ArrayStack) Push(v int) {
+
+    // push 入栈
+    func (s *arrayStack) push(v int) {
         // 切片会自动扩容
         s.data = append(s.data, v)
     }
-    // Pop 出栈
-    func (s *ArrayStack) Pop() any {
+
+    // pop 出栈
+    func (s *arrayStack) pop() any {
         // 弹出栈前，先判断是否为空
-        if s.IsEmpty() {
+        if s.isEmpty() {
             return nil
         }
-        val := s.Peek()
+        val := s.peek()
         s.data = s.data[:len(s.data)-1]
         return val
     }
-    // Peek 获取栈顶元素
-    func (s *ArrayStack) Peek() any {
-        if s.IsEmpty() {
+
+    // peek 获取栈顶元素
+    func (s *arrayStack) peek() any {
+        if s.isEmpty() {
             return nil
         }
         val := s.data[len(s.data)-1]
diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md
index 979612852..e3ddfaaac 100644
--- a/docs/chapter_tree/binary_search_tree.md
+++ b/docs/chapter_tree/binary_search_tree.md
@@ -103,7 +103,7 @@ comments: true
 
     ```go title="binary_search_tree.go"
     /* 查找结点 */
-    func (bst *BinarySearchTree) Search(num int) *TreeNode {
+    func (bst *binarySearchTree) search(num int) *TreeNode {
         node := bst.root
         // 循环查找，越过叶结点后跳出
         for node != nil {
@@ -299,7 +299,7 @@ comments: true
 
     ```go title="binary_search_tree.go"
     /* 插入结点 */
-    func (bst *BinarySearchTree) Insert(num int) *TreeNode {
+    func (bst *binarySearchTree) insert(num int) *TreeNode {
         cur := bst.root
         // 若树为空，直接提前返回
         if cur == nil {
@@ -609,7 +609,7 @@ comments: true
 
     ```go title="binary_search_tree.go"
     /* 删除结点 */
-    func (bst *BinarySearchTree) Remove(num int) *TreeNode {
+    func (bst *binarySearchTree) remove(num int) *TreeNode {
         cur := bst.root
         // 若树为空，直接提前返回
         if cur == nil {
@@ -653,10 +653,10 @@ comments: true
             // 子结点数为 2
         } else {
             // 获取中序遍历中待删除结点 cur 的下一个结点
-            next := bst.GetInOrderNext(cur)
+            next := bst.getInOrderNext(cur)
             temp := next.Val
             // 递归删除结点 next
-            bst.Remove(next.Val)
+            bst.remove(next.Val)
             // 将 next 的值复制给 cur
             cur.Val = temp
         }

From b6abf2b09280d746f261e5508356e369acc189c0 Mon Sep 17 00:00:00 2001
From: sjinzh <99076655+sjinzh@users.noreply.github.com>
Date: Sun, 8 Jan 2023 20:38:48 +0800
Subject: [PATCH 130/158] (PR #217)update a .gitignore file in the codes/zig
 dir

---
 codes/zig/.gitignore                          |  2 +
 codes/zig/build.zig                           | 46 ++++++++++++++
 .../leetcode_two_sum.zig                      | 61 +++++++++++++++++++
 .../worst_best_time_complexity.zig            |  9 ++-
 codes/zig/include/PrintUtil.zig               | 13 ++++
 codes/zig/include/include.zig                 |  5 ++
 6 files changed, 131 insertions(+), 5 deletions(-)
 create mode 100644 codes/zig/.gitignore
 create mode 100644 codes/zig/build.zig
 create mode 100644 codes/zig/chapter_computational_complexity/leetcode_two_sum.zig
 create mode 100644 codes/zig/include/PrintUtil.zig
 create mode 100644 codes/zig/include/include.zig

diff --git a/codes/zig/.gitignore b/codes/zig/.gitignore
new file mode 100644
index 000000000..4a0641ed7
--- /dev/null
+++ b/codes/zig/.gitignore
@@ -0,0 +1,2 @@
+zig-cache/
+zig-out/
\ No newline at end of file
diff --git a/codes/zig/build.zig b/codes/zig/build.zig
new file mode 100644
index 000000000..b04b3fd18
--- /dev/null
+++ b/codes/zig/build.zig
@@ -0,0 +1,46 @@
+const std = @import("std");
+
+// zig version 0.10.0
+pub fn build(b: *std.build.Builder) void {
+    const target = b.standardTargetOptions(.{});
+    const mode = b.standardReleaseOptions();
+
+    // "chapter_computational_complexity/time_complexity.zig"
+    // Run Command: zig build run_time_complexity
+    const exe_time_complexity = b.addExecutable("time_complexity", "chapter_computational_complexity/time_complexity.zig");
+    exe_time_complexity.addPackagePath("include", "include/include.zig");
+    exe_time_complexity.setTarget(target);
+    exe_time_complexity.setBuildMode(mode);
+    exe_time_complexity.install();
+    const run_cmd_time_complexity = exe_time_complexity.run();
+    run_cmd_time_complexity.step.dependOn(b.getInstallStep());
+    if (b.args) |args| run_cmd_time_complexity.addArgs(args);
+    const run_step_time_complexity = b.step("run_time_complexity", "Run time_complexity");
+    run_step_time_complexity.dependOn(&run_cmd_time_complexity.step);
+
+    // "chapter_computational_complexity/worst_best_time_complexity.zig"
+    // Run Command: zig build run_worst_best_time_complexity
+    const exe_worst_best_time_complexity = b.addExecutable("worst_best_time_complexity", "chapter_computational_complexity/worst_best_time_complexity.zig");
+    exe_worst_best_time_complexity.addPackagePath("include", "include/include.zig");
+    exe_worst_best_time_complexity.setTarget(target);
+    exe_worst_best_time_complexity.setBuildMode(mode);
+    exe_worst_best_time_complexity.install();
+    const run_cmd_worst_best_time_complexity = exe_worst_best_time_complexity.run();
+    run_cmd_worst_best_time_complexity.step.dependOn(b.getInstallStep());
+    if (b.args) |args| run_cmd_worst_best_time_complexity.addArgs(args);
+    const run_step_worst_best_time_complexity = b.step("run_worst_best_time_complexity", "Run worst_best_time_complexity");
+    run_step_worst_best_time_complexity.dependOn(&run_cmd_worst_best_time_complexity.step);
+
+    // "chapter_computational_complexity/leetcode_two_sum.zig"
+    // Run Command: zig build run_leetcode_two_sum
+    const exe_leetcode_two_sum = b.addExecutable("leetcode_two_sum", "chapter_computational_complexity/leetcode_two_sum.zig");
+    exe_leetcode_two_sum.addPackagePath("include", "include/include.zig");
+    exe_leetcode_two_sum.setTarget(target);
+    exe_leetcode_two_sum.setBuildMode(mode);
+    exe_leetcode_two_sum.install();
+    const run_cmd_leetcode_two_sum = exe_leetcode_two_sum.run();
+    run_cmd_leetcode_two_sum.step.dependOn(b.getInstallStep());
+    if (b.args) |args| run_cmd_leetcode_two_sum.addArgs(args);
+    const run_step_leetcode_two_sum = b.step("run_leetcode_two_sum", "Run leetcode_two_sum");
+    run_step_leetcode_two_sum.dependOn(&run_cmd_leetcode_two_sum.step);
+}
diff --git a/codes/zig/chapter_computational_complexity/leetcode_two_sum.zig b/codes/zig/chapter_computational_complexity/leetcode_two_sum.zig
new file mode 100644
index 000000000..66b96f95e
--- /dev/null
+++ b/codes/zig/chapter_computational_complexity/leetcode_two_sum.zig
@@ -0,0 +1,61 @@
+// File: leetcode_two_sum.zig
+// Created Time: 2023-01-07
+// Author: sjinzh (sjinzh@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+const SolutionBruteForce = struct {
+    pub fn twoSum(self: *SolutionBruteForce, nums: []i32, target: i32) [2]i32 {
+        _ = self;
+        var size: usize = nums.len;
+        var i: usize = 0;
+        // 两层循环，时间复杂度 O(n^2)
+        while (i < size - 1) : (i += 1) {
+            var j = i + 1;
+            while (j < size) : (j += 1) {
+                if (nums[i] + nums[j] == target) {
+                    return [_]i32{@intCast(i32, i), @intCast(i32, j)};
+                }
+            }
+        }
+        return undefined;
+    }
+};
+
+const SolutionHashMap = struct {
+    pub fn twoSum(self: *SolutionHashMap, nums: []i32, target: i32) ![2]i32 {
+        _ = self;
+        var size: usize = nums.len;
+        // 辅助哈希表，空间复杂度 O(n)
+        var dic = std.AutoHashMap(i32, i32).init(std.heap.page_allocator);
+        defer dic.deinit();
+        var i: usize = 0;
+        // 单层循环，时间复杂度 O(n)
+        while (i < size) : (i += 1) {
+            if (dic.contains(target - nums[i])) {
+                return [_]i32{dic.get(target - nums[i]).?, @intCast(i32, i)};
+            }
+            try dic.put(nums[i], @intCast(i32, i));
+        }
+        return undefined;
+    }
+};
+
+// Driver Code
+pub fn main() !void {
+    // ======= Test Case =======
+    var nums = [_]i32{ 2, 7, 11, 15 };
+    var target: i32 = 9;
+    // 方法一
+    var slt1 = SolutionBruteForce{};
+    var res = slt1.twoSum(&nums, target);
+    std.debug.print("方法一 res = ", .{});
+    inc.PrintUtil.printArray(i32, &res); 
+    // 方法二
+    var slt2 = SolutionHashMap{};
+    res = try slt2.twoSum(&nums, target);
+    std.debug.print("方法二 res = ", .{});
+    inc.PrintUtil.printArray(i32, &res); 
+}
+
diff --git a/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig b/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig
index dacf45952..bd2a1464a 100644
--- a/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig
+++ b/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig
@@ -3,6 +3,7 @@
 // Author: sjinzh (sjinzh@gmail.com)
 
 const std = @import("std");
+const inc = @import("include");
 
 // 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱
 pub fn randomNumbers(comptime n: usize) [n]i32 {
@@ -26,17 +27,15 @@ pub fn findOne(nums: []i32) i32 {
 }
 
 // Driver Code
-pub fn main() !void {
+pub fn main() void {
     var i: i32 = 0;
     while (i < 10) : (i += 1) {
         const n: usize = 100;
         var nums = randomNumbers(n);
         var index = findOne(&nums);
         std.debug.print("\n数组 [ 1, 2, ..., n ] 被打乱后 = ", .{});
-        for (nums) |num, j| {
-            std.debug.print("{}{s}", .{num, if (j == nums.len-1) "" else "," });
-        }
-        std.debug.print("\n数字 1 的索引为 {}\n", .{index});
+        inc.PrintUtil.printArray(i32, &nums);
+        std.debug.print("数字 1 的索引为 {}\n", .{index});
     }
 }
 
diff --git a/codes/zig/include/PrintUtil.zig b/codes/zig/include/PrintUtil.zig
new file mode 100644
index 000000000..5adac2a6e
--- /dev/null
+++ b/codes/zig/include/PrintUtil.zig
@@ -0,0 +1,13 @@
+// File: TreeNode.zig
+// Created Time: 2023-01-07
+// Author: sjinzh (sjinzh@gmail.com)
+
+const std = @import("std");
+
+// Print an Array
+pub fn printArray(comptime T: type, nums: []T) void {
+    std.debug.print("[", .{});
+    for (nums) |num, j| {
+        std.debug.print("{}{s}", .{num, if (j == nums.len-1) "]\n" else ", " });
+     }
+}
diff --git a/codes/zig/include/include.zig b/codes/zig/include/include.zig
new file mode 100644
index 000000000..b4f347821
--- /dev/null
+++ b/codes/zig/include/include.zig
@@ -0,0 +1,5 @@
+// File: include.zig
+// Created Time: 2023-01-04
+// Author: sjinzh (sjinzh@gmail.com)
+
+pub const PrintUtil = @import("PrintUtil.zig");
\ No newline at end of file

From 3b52df2a8f2725f88db56c4696ea9a3ef48b1663 Mon Sep 17 00:00:00 2001
From: nuomi1 <nuomi1@qq.com>
Date: Sun, 8 Jan 2023 20:53:24 +0800
Subject: [PATCH 131/158] style: update comment format

---
 .../space_complexity.swift                    | 16 +++++------
 .../time_complexity.swift                     | 23 +++++++--------
 .../worst_best_time_complexity.swift          |  6 ++--
 docs/chapter_array_and_linkedlist/array.md    | 14 +++++-----
 .../space_complexity.md                       | 20 ++++++-------
 .../time_complexity.md                        | 28 +++++++++----------
 .../chapter_data_structure/data_and_memory.md |  2 +-
 7 files changed, 55 insertions(+), 54 deletions(-)

diff --git a/codes/swift/chapter_computational_complexity/space_complexity.swift b/codes/swift/chapter_computational_complexity/space_complexity.swift
index 92a1187a0..fdd29f8e2 100644
--- a/codes/swift/chapter_computational_complexity/space_complexity.swift
+++ b/codes/swift/chapter_computational_complexity/space_complexity.swift
@@ -6,14 +6,14 @@
 
 import utils
 
-// 函数
+/* 函数 */
 @discardableResult
 func function() -> Int {
     // do something
     return 0
 }
 
-// 常数阶
+/* 常数阶 */
 func constant(n: Int) {
     // 常量、变量、对象占用 O(1) 空间
     let a = 0
@@ -30,7 +30,7 @@ func constant(n: Int) {
     }
 }
 
-// 线性阶
+/* 线性阶 */
 func linear(n: Int) {
     // 长度为 n 的数组占用 O(n) 空间
     let nums = Array(repeating: 0, count: n)
@@ -40,7 +40,7 @@ func linear(n: Int) {
     let map = Dictionary(uniqueKeysWithValues: (0 ..< n).map { ($0, "\($0)") })
 }
 
-// 线性阶（递归实现）
+/* 线性阶（递归实现） */
 func linearRecur(n: Int) {
     print("递归 n = \(n)")
     if n == 1 {
@@ -49,13 +49,13 @@ func linearRecur(n: Int) {
     linearRecur(n: n - 1)
 }
 
-// 平方阶
+/* 平方阶 */
 func quadratic(n: Int) {
     // 二维列表占用 O(n^2) 空间
     let numList = Array(repeating: Array(repeating: 0, count: n), count: n)
 }
 
-// 平方阶（递归实现）
+/* 平方阶（递归实现） */
 @discardableResult
 func quadraticRecur(n: Int) -> Int {
     if n <= 0 {
@@ -67,7 +67,7 @@ func quadraticRecur(n: Int) -> Int {
     return quadraticRecur(n: n - 1)
 }
 
-// 指数阶（建立满二叉树）
+/* 指数阶（建立满二叉树） */
 func buildTree(n: Int) -> TreeNode? {
     if n == 0 {
         return nil
@@ -80,7 +80,7 @@ func buildTree(n: Int) -> TreeNode? {
 
 @main
 enum SpaceComplexity {
-    // Driver Code
+    /* Driver Code */
     static func main() {
         let n = 5
         // 常数阶
diff --git a/codes/swift/chapter_computational_complexity/time_complexity.swift b/codes/swift/chapter_computational_complexity/time_complexity.swift
index 44addb800..a0e0a9cff 100644
--- a/codes/swift/chapter_computational_complexity/time_complexity.swift
+++ b/codes/swift/chapter_computational_complexity/time_complexity.swift
@@ -4,7 +4,7 @@
  * Author: nuomi1 (nuomi1@qq.com)
  */
 
-// 常数阶
+/* 常数阶 */
 func constant(n: Int) -> Int {
     var count = 0
     let size = 100_000
@@ -14,7 +14,7 @@ func constant(n: Int) -> Int {
     return count
 }
 
-// 线性阶
+/* 线性阶 */
 func linear(n: Int) -> Int {
     var count = 0
     for _ in 0 ..< n {
@@ -23,7 +23,7 @@ func linear(n: Int) -> Int {
     return count
 }
 
-// 线性阶（遍历数组）
+/* 线性阶（遍历数组） */
 func arrayTraversal(nums: [Int]) -> Int {
     var count = 0
     // 循环次数与数组长度成正比
@@ -33,7 +33,7 @@ func arrayTraversal(nums: [Int]) -> Int {
     return count
 }
 
-// 平方阶
+/* 平方阶 */
 func quadratic(n: Int) -> Int {
     var count = 0
     // 循环次数与数组长度成平方关系
@@ -45,7 +45,7 @@ func quadratic(n: Int) -> Int {
     return count
 }
 
-// 平方阶（冒泡排序）
+/* 平方阶（冒泡排序） */
 func bubbleSort(nums: inout [Int]) -> Int {
     var count = 0 // 计数器
     // 外循环：待排序元素数量为 n-1, n-2, ..., 1
@@ -64,7 +64,7 @@ func bubbleSort(nums: inout [Int]) -> Int {
     return count
 }
 
-// 指数阶（循环实现）
+/* 指数阶（循环实现） */
 func exponential(n: Int) -> Int {
     var count = 0
     var base = 1
@@ -79,7 +79,7 @@ func exponential(n: Int) -> Int {
     return count
 }
 
-// 指数阶（递归实现）
+/* 指数阶（递归实现） */
 func expRecur(n: Int) -> Int {
     if n == 1 {
         return 1
@@ -87,7 +87,7 @@ func expRecur(n: Int) -> Int {
     return expRecur(n: n - 1) + expRecur(n: n - 1) + 1
 }
 
-// 对数阶（循环实现）
+/* 对数阶（循环实现） */
 func logarithmic(n: Int) -> Int {
     var count = 0
     var n = n
@@ -98,7 +98,7 @@ func logarithmic(n: Int) -> Int {
     return count
 }
 
-// 对数阶（递归实现）
+/* 对数阶（递归实现） */
 func logRecur(n: Int) -> Int {
     if n <= 1 {
         return 0
@@ -106,7 +106,7 @@ func logRecur(n: Int) -> Int {
     return logRecur(n: n / 2) + 1
 }
 
-// 线性对数阶
+/* 线性对数阶 */
 func linearLogRecur(n: Double) -> Int {
     if n <= 1 {
         return 1
@@ -118,7 +118,7 @@ func linearLogRecur(n: Double) -> Int {
     return count
 }
 
-// 阶乘阶（递归实现）
+/* 阶乘阶（递归实现） */
 func factorialRecur(n: Int) -> Int {
     if n == 0 {
         return 1
@@ -133,6 +133,7 @@ func factorialRecur(n: Int) -> Int {
 
 @main
 enum TimeComplexity {
+    /* Driver Code */
     static func main() {
         // 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
         let n = 8
diff --git a/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift b/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift
index 09d7de1f4..34f0518f1 100644
--- a/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift
+++ b/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift
@@ -4,7 +4,7 @@
  * Author: nuomi1 (nuomi1@qq.com)
  */
 
-// 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱
+/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
 func randomNumbers(n: Int) -> [Int] {
     // 生成数组 nums = { 1, 2, 3, ..., n }
     var nums = Array(1 ... n)
@@ -13,7 +13,7 @@ func randomNumbers(n: Int) -> [Int] {
     return nums
 }
 
-// 查找数组 nums 中数字 1 所在索引
+/* 查找数组 nums 中数字 1 所在索引 */
 func findOne(nums: [Int]) -> Int {
     for i in nums.indices {
         if nums[i] == 1 {
@@ -25,7 +25,7 @@ func findOne(nums: [Int]) -> Int {
 
 @main
 enum WorstBestTimeComplexity {
-    // Driver Code
+    /* Driver Code */
     static func main() {
         for _ in 0 ..< 10 {
             let n = 100
diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 461cdcf37..2cf096137 100644
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -84,7 +84,7 @@ comments: true
 === "Swift"
 
     ```swift title="array.swift"
-    // 初始化数组
+    /* 初始化数组 */
     let arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]
     let nums = [1, 3, 2, 5, 4]
     ```
@@ -204,7 +204,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Swift"
 
     ```swift title="array.swift"
-    // 随机返回一个数组元素
+    /* 随机返回一个数组元素 */
     func randomAccess(nums: [Int]) -> Int {
         // 在区间 [0, nums.count) 中随机抽取一个数字
         let randomIndex = nums.indices.randomElement()!
@@ -341,7 +341,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Swift"
 
     ```swift title="array.swift"
-    // 扩展数组长度
+    /* 扩展数组长度 */
     func extend(nums: [Int], enlarge: Int) -> [Int] {
         // 初始化一个扩展长度后的数组
         var res = Array(repeating: 0, count: nums.count + enlarge)
@@ -526,7 +526,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Swift"
 
     ```swift title="array.swift"
-    // 在数组的索引 index 处插入元素 num
+    /* 在数组的索引 index 处插入元素 num */
     func insert(nums: inout [Int], num: Int, index: Int) {
         // 把索引 index 以及之后的所有元素向后移动一位
         for i in sequence(first: nums.count - 1, next: { $0 > index + 1 ? $0 - 1 : nil }) {
@@ -536,7 +536,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
         nums[index] = num
     }
 
-    // 删除索引 index 处元素
+    /* 删除索引 index 处元素 */
     func remove(nums: inout [Int], index: Int) {
         let count = nums.count
         // 把索引 index 之后的所有元素向前移动一位
@@ -674,7 +674,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Swift"
 
     ```swift title="array.swift"
-    // 遍历数组
+    /* 遍历数组 */
     func traverse(nums: [Int]) {
         var count = 0
         // 通过索引遍历数组
@@ -793,7 +793,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Swift"
 
     ```swift title="array.swift"
-    // 在数组中查找指定元素
+    /* 在数组中查找指定元素 */
     func find(nums: [Int], target: Int) -> Int {
         for i in nums.indices {
             if nums[i] == target {
diff --git a/docs/chapter_computational_complexity/space_complexity.md b/docs/chapter_computational_complexity/space_complexity.md
index 1756f2e24..939b61ecf 100644
--- a/docs/chapter_computational_complexity/space_complexity.md
+++ b/docs/chapter_computational_complexity/space_complexity.md
@@ -177,7 +177,7 @@ comments: true
 === "Swift"
 
     ```swift title=""
-    // 类
+    /* 类 */
     class Node {
         var val: Int
         var next: Node?
@@ -187,7 +187,7 @@ comments: true
         }
     }
 
-    // 函数
+    /* 函数 */
     func function() -> Int {
         // do something...
         return 0
@@ -436,14 +436,14 @@ comments: true
         return 0
     }
 
-    // 循环 O(1)
+    /* 循环 O(1) */
     func loop(n: Int) {
         for _ in 0 ..< n {
             function()
         }
     }
 
-    // 递归 O(n)
+    /* 递归 O(n) */
     func recur(n: Int) {
         if n == 1 {
             return
@@ -604,7 +604,7 @@ $$
 === "Swift"
 
     ```swift title="space_complexity.swift"
-    // 常数阶
+    /* 常数阶 */
     func constant(n: Int) {
         // 常量、变量、对象占用 O(1) 空间
         let a = 0
@@ -743,7 +743,7 @@ $$
 === "Swift"
 
     ```swift title="space_complexity.swift"
-    // 线性阶
+    /* 线性阶 */
     func linear(n: Int) {
         // 长度为 n 的数组占用 O(n) 空间
         let nums = Array(repeating: 0, count: n)
@@ -834,7 +834,7 @@ $$
 === "Swift"
 
     ```swift title="space_complexity.swift"
-    // 线性阶（递归实现）
+    /* 线性阶（递归实现） */
     func linearRecur(n: Int) {
         print("递归 n = \(n)")
         if n == 1 {
@@ -954,7 +954,7 @@ $$
 === "Swift"
 
     ```swift title="space_complexity.swift"
-    // 平方阶
+    /* 平方阶 */
     func quadratic(n: Int) {
         // 二维列表占用 O(n^2) 空间
         let numList = Array(repeating: Array(repeating: 0, count: n), count: n)
@@ -1047,7 +1047,7 @@ $$
 === "Swift"
 
     ```swift title="space_complexity.swift"
-    // 平方阶（递归实现）
+    /* 平方阶（递归实现） */
     func quadraticRecur(n: Int) -> Int {
         if n <= 0 {
             return 0
@@ -1154,7 +1154,7 @@ $$
 === "Swift"
 
     ```swift title="space_complexity.swift"
-    // 指数阶（建立满二叉树）
+    /* 指数阶（建立满二叉树） */
     func buildTree(n: Int) -> TreeNode? {
         if n == 0 {
             return nil
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 7b0e66fbd..f6b6e9356 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -876,7 +876,7 @@ $$
 === "Swift"
 
     ```swift title="time_complexity.swift"
-    // 常数阶
+    /* 常数阶 */
     func constant(n: Int) -> Int {
         var count = 0
         let size = 100000
@@ -990,7 +990,7 @@ $$
 === "Swift"
 
     ```swift title="time_complexity.swift"
-    // 线性阶
+    /* 线性阶 */
     func linear(n: Int) -> Int {
         var count = 0
         for _ in 0 ..< n {
@@ -1121,7 +1121,7 @@ $$
 === "Swift"
 
     ```swift title="time_complexity.swift"
-    // 线性阶（遍历数组）
+    /* 线性阶（遍历数组） */
     func arrayTraversal(nums: [Int]) -> Int {
         var count = 0
         // 循环次数与数组长度成正比
@@ -1267,7 +1267,7 @@ $$
 === "Swift"
 
     ```swift title="time_complexity.swift"
-    // 平方阶
+    /* 平方阶 */
     func quadratic(n: Int) -> Int {
         var count = 0
         // 循环次数与数组长度成平方关系
@@ -1477,7 +1477,7 @@ $$
 === "Swift"
 
     ```swift title="time_complexity.swift"
-    // 平方阶（冒泡排序）
+    /* 平方阶（冒泡排序） */
     func bubbleSort(nums: inout [Int]) -> Int {
         var count = 0 // 计数器
         // 外循环：待排序元素数量为 n-1, n-2, ..., 1
@@ -1656,7 +1656,7 @@ $$
 === "Swift"
 
     ```swift title="time_complexity.swift"
-    // 指数阶（循环实现）
+    /* 指数阶（循环实现） */
     func exponential(n: Int) -> Int {
         var count = 0
         var base = 1
@@ -1764,7 +1764,7 @@ $$
 === "Swift"
 
     ```swift title="time_complexity.swift"
-    // 指数阶（递归实现）
+    /* 指数阶（递归实现） */
     func expRecur(n: Int) -> Int {
         if n == 1 {
             return 1
@@ -1896,7 +1896,7 @@ $$
 === "Swift"
 
     ```swift title="time_complexity.swift"
-    // 对数阶（循环实现）
+    /* 对数阶（循环实现） */
     func logarithmic(n: Int) -> Int {
         var count = 0
         var n = n
@@ -1999,7 +1999,7 @@ $$
 === "Swift"
 
     ```swift title="time_complexity.swift"
-    // 对数阶（递归实现）
+    /* 对数阶（递归实现） */
     func logRecur(n: Int) -> Int {
         if n <= 1 {
             return 0
@@ -2137,7 +2137,7 @@ $$
 === "Swift"
 
     ```swift title="time_complexity.swift"
-    // 线性对数阶
+    /* 线性对数阶 */
     func linearLogRecur(n: Double) -> Int {
         if n <= 1 {
             return 1
@@ -2288,7 +2288,7 @@ $$
 === "Swift"
 
     ```swift title="time_complexity.swift"
-    // 阶乘阶（递归实现）
+    /* 阶乘阶（递归实现） */
     func factorialRecur(n: Int) -> Int {
         if n == 0 {
             return 1
@@ -2658,7 +2658,7 @@ $$
 === "Swift"
 
     ```swift title="worst_best_time_complexity.swift"
-    // 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱
+    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
     func randomNumbers(n: Int) -> [Int] {
         // 生成数组 nums = { 1, 2, 3, ..., n }
         var nums = Array(1 ... n)
@@ -2667,7 +2667,7 @@ $$
         return nums
     }
 
-    // 查找数组 nums 中数字 1 所在索引
+    /* 查找数组 nums 中数字 1 所在索引 */
     func findOne(nums: [Int]) -> Int {
         for i in nums.indices {
             if nums[i] == 1 {
@@ -2677,7 +2677,7 @@ $$
         return -1
     }
 
-    // Driver Code
+    /* Driver Code */
     func main() {
         for _ in 0 ..< 10 {
             let n = 100
diff --git a/docs/chapter_data_structure/data_and_memory.md b/docs/chapter_data_structure/data_and_memory.md
index 3a11fdf36..59cb74e45 100644
--- a/docs/chapter_data_structure/data_and_memory.md
+++ b/docs/chapter_data_structure/data_and_memory.md
@@ -117,7 +117,7 @@ comments: true
 === "Swift"
 
     ```swift title=""
-    // 使用多种「基本数据类型」来初始化「数组」
+    /* 使用多种「基本数据类型」来初始化「数组」 */
     let numbers = Array(repeating: Int(), count: 5)
     let decimals = Array(repeating: Double(), count: 5)
     let characters = Array(repeating: Character("a"), count: 5)

From f3e9c2cf896fbfe5ab794a6b53e2351457f9f5bd Mon Sep 17 00:00:00 2001
From: nuomi1 <nuomi1@qq.com>
Date: Sun, 8 Jan 2023 20:54:40 +0800
Subject: [PATCH 132/158] style: use string interpolation in print

---
 .../time_complexity.swift                     | 24 +++++++++----------
 .../worst_best_time_complexity.swift          |  4 ++--
 .../time_complexity.md                        |  4 ++--
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/codes/swift/chapter_computational_complexity/time_complexity.swift b/codes/swift/chapter_computational_complexity/time_complexity.swift
index a0e0a9cff..41695cfd6 100644
--- a/codes/swift/chapter_computational_complexity/time_complexity.swift
+++ b/codes/swift/chapter_computational_complexity/time_complexity.swift
@@ -137,36 +137,36 @@ enum TimeComplexity {
     static func main() {
         // 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
         let n = 8
-        print("输入数据大小 n =", n)
+        print("输入数据大小 n = \(n)")
 
         var count = constant(n: n)
-        print("常数阶的计算操作数量 =", count)
+        print("常数阶的计算操作数量 = \(count)")
 
         count = linear(n: n)
-        print("线性阶的计算操作数量 =", count)
+        print("线性阶的计算操作数量 = \(count)")
         count = arrayTraversal(nums: Array(repeating: 0, count: n))
-        print("线性阶（遍历数组）的计算操作数量 =", count)
+        print("线性阶（遍历数组）的计算操作数量 = \(count)")
 
         count = quadratic(n: n)
-        print("平方阶的计算操作数量 =", count)
+        print("平方阶的计算操作数量 = \(count)")
         var nums = Array(sequence(first: n, next: { $0 > 0 ? $0 - 1 : nil })) // [n,n-1,...,2,1]
         count = bubbleSort(nums: &nums)
-        print("平方阶（冒泡排序）的计算操作数量 =", count)
+        print("平方阶（冒泡排序）的计算操作数量 = \(count)")
 
         count = exponential(n: n)
-        print("指数阶（循环实现）的计算操作数量 =", count)
+        print("指数阶（循环实现）的计算操作数量 = \(count)")
         count = expRecur(n: n)
-        print("指数阶（递归实现）的计算操作数量 =", count)
+        print("指数阶（递归实现）的计算操作数量 = \(count)")
 
         count = logarithmic(n: n)
-        print("对数阶（循环实现）的计算操作数量 =", count)
+        print("对数阶（循环实现）的计算操作数量 = \(count)")
         count = logRecur(n: n)
-        print("对数阶（递归实现）的计算操作数量 =", count)
+        print("对数阶（递归实现）的计算操作数量 = \(count)")
 
         count = linearLogRecur(n: Double(n))
-        print("线性对数阶（递归实现）的计算操作数量 =", count)
+        print("线性对数阶（递归实现）的计算操作数量 = \(count)")
 
         count = factorialRecur(n: n)
-        print("阶乘阶（递归实现）的计算操作数量 =", count)
+        print("阶乘阶（递归实现）的计算操作数量 = \(count)")
     }
 }
diff --git a/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift b/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift
index 34f0518f1..3dac661d2 100644
--- a/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift
+++ b/codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift
@@ -31,8 +31,8 @@ enum WorstBestTimeComplexity {
             let n = 100
             let nums = randomNumbers(n: n)
             let index = findOne(nums: nums)
-            print("数组 [ 1, 2, ..., n ] 被打乱后 =", nums)
-            print("数字 1 的索引为", index)
+            print("数组 [ 1, 2, ..., n ] 被打乱后 = \(nums)")
+            print("数字 1 的索引为 \(index)")
         }
     }
 }
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index f6b6e9356..25d9fce88 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -2683,8 +2683,8 @@ $$
             let n = 100
             let nums = randomNumbers(n: n)
             let index = findOne(nums: nums)
-            print("数组 [ 1, 2, ..., n ] 被打乱后 =", nums)
-            print("数字 1 的索引为", index)
+            print("数组 [ 1, 2, ..., n ] 被打乱后 = \(nums)")
+            print("数字 1 的索引为 \(index)")
         }
     }
     ```

From cb0071924e98bbf593d172d684acc54a492749c8 Mon Sep 17 00:00:00 2001
From: reanon <793584285@qq.com>
Date: Mon, 9 Jan 2023 01:05:21 +0800
Subject: [PATCH 133/158] feat(tree/avl_tree): add go code

---
 codes/go/chapter_tree/avl_tree.go      | 212 +++++++++++++++++++++++++
 codes/go/chapter_tree/avl_tree_test.go |  54 +++++++
 codes/go/pkg/tree_node.go              |  14 +-
 3 files changed, 274 insertions(+), 6 deletions(-)
 create mode 100644 codes/go/chapter_tree/avl_tree.go
 create mode 100644 codes/go/chapter_tree/avl_tree_test.go

diff --git a/codes/go/chapter_tree/avl_tree.go b/codes/go/chapter_tree/avl_tree.go
new file mode 100644
index 000000000..111abd722
--- /dev/null
+++ b/codes/go/chapter_tree/avl_tree.go
@@ -0,0 +1,212 @@
+// File: avl_tree.go
+// Created Time: 2023-01-08
+// Author: Reanon (793584285@qq.com)
+
+package chapter_tree
+
+import . "github.com/krahets/hello-algo/pkg"
+
+/* AVL Tree*/
+type avlTree struct {
+	// 根节点
+	root *TreeNode
+}
+
+func newAVLTree() *avlTree {
+	return &avlTree{root: nil}
+}
+
+/* 获取结点高度
+ */
+func height(node *TreeNode) int {
+	// 空结点高度为 -1 ，叶结点高度为 0
+	if node != nil {
+		return node.Height
+	}
+	return -1
+}
+
+/* 更新结点高度 */
+func updateHeight(node *TreeNode) {
+	lh := height(node.Left)
+	rh := height(node.Right)
+	// 结点高度等于最高子树高度 + 1
+	if lh > rh {
+		node.Height = lh + 1
+	} else {
+		node.Height = rh + 1
+	}
+}
+
+/* 获取平衡因子 */
+func balanceFactor(node *TreeNode) int {
+	// 空结点平衡因子为 0
+	if node == nil {
+		return 0
+	}
+	// 结点平衡因子 = 左子树高度 - 右子树高度
+	return height(node.Left) - height(node.Right)
+}
+
+/* 右旋操作 */
+func rightRotate(node *TreeNode) *TreeNode {
+	child := node.Left
+	grandChild := child.Right
+	// 以 child 为原点，将 node 向右旋转
+	child.Right = node
+	node.Left = grandChild
+	// 更新结点高度
+	updateHeight(node)
+	updateHeight(child)
+	// 返回旋转后子树的根节点
+	return child
+}
+
+/* 左旋操作 */
+func leftRotate(node *TreeNode) *TreeNode {
+	child := node.Right
+	grandChild := child.Left
+	// 以 child 为原点，将 node 向左旋转
+	child.Left = node
+	node.Right = grandChild
+	// 更新结点高度
+	updateHeight(node)
+	updateHeight(child)
+	// 返回旋转后子树的根节点
+	return child
+}
+
+/* 执行旋转操作，使该子树重新恢复平衡 */
+func rotate(node *TreeNode) *TreeNode {
+	// 获取结点 node 的平衡因子
+	// Go 推荐短变量，这里 bf 指代 balanceFactor
+	bf := balanceFactor(node)
+	// 左偏树
+	if bf > 1 {
+		if balanceFactor(node.Left) >= 0 {
+			// 右旋
+			return rightRotate(node)
+		} else {
+			// 先左旋后右旋
+			node.Left = leftRotate(node.Left)
+			return rightRotate(node)
+		}
+	}
+	// 右偏树
+	if bf < -1 {
+		if balanceFactor(node.Right) <= 0 {
+			// 左旋
+			return leftRotate(node)
+		} else {
+			// 先右旋后左旋
+			node.Right = rightRotate(node.Right)
+			return leftRotate(node)
+		}
+	}
+	// 平衡树，无需旋转，直接返回
+	return node
+}
+
+/* 插入结点 */
+func (t *avlTree) insert(val int) *TreeNode {
+	t.root = insertHelper(t.root, val)
+	return t.root
+}
+
+/* 递归插入结点（辅助函数） */
+func insertHelper(node *TreeNode, val int) *TreeNode {
+	if node == nil {
+		return NewTreeNode(val)
+	}
+	/* 1. 查找插入位置，并插入结点 */
+	if val < node.Val {
+		node.Left = insertHelper(node.Left, val)
+	} else if val > node.Val {
+		node.Right = insertHelper(node.Right, val)
+	} else {
+		// 重复结点不插入，直接返回
+		return node
+	}
+	// 更新结点高度
+	updateHeight(node)
+	/* 2. 执行旋转操作，使该子树重新恢复平衡 */
+	node = rotate(node)
+	// 返回子树的根节点
+	return node
+}
+
+/* 删除结点 */
+func (t *avlTree) remove(val int) *TreeNode {
+	root := removeHelper(t.root, val)
+	return root
+}
+
+/* 递归删除结点（辅助函数） */
+func removeHelper(node *TreeNode, val int) *TreeNode {
+	if node == nil {
+		return nil
+	}
+	/* 1. 查找结点，并删除之 */
+	if val < node.Val {
+		node.Left = removeHelper(node.Left, val)
+	} else if val > node.Val {
+		node.Right = removeHelper(node.Right, val)
+	} else {
+		if node.Left == nil || node.Right == nil {
+			child := node.Left
+			if node.Right != nil {
+				child = node.Right
+			}
+			// 子结点数量 = 0 ，直接删除 node 并返回
+			if child == nil {
+				return nil
+			} else {
+				// 子结点数量 = 1 ，直接删除 node
+				node = child
+			}
+		} else {
+			// 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+			temp := getInOrderNext(node.Right)
+			node.Right = removeHelper(node.Right, temp.Val)
+			node.Val = temp.Val
+		}
+	}
+	// 更新结点高度
+	updateHeight(node)
+	/* 2. 执行旋转操作，使该子树重新恢复平衡 */
+	node = rotate(node)
+	// 返回子树的根节点
+	return node
+}
+
+/* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+func getInOrderNext(node *TreeNode) *TreeNode {
+	if node == nil {
+		return node
+	}
+	// 循环访问左子结点，直到叶结点时为最小结点，跳出
+	for node.Left != nil {
+		node = node.Left
+	}
+	return node
+}
+
+/* 查找结点 */
+func (t *avlTree) search(val int) *TreeNode {
+	cur := t.root
+	// 循环查找，越过叶结点后跳出
+	for cur != nil {
+		// 目标结点在 root 的右子树中
+		if cur.Val < val {
+			cur = cur.Right
+		} else if cur.Val > val {
+			// 目标结点在 root 的左子树中
+			cur = cur.Left
+		} else {
+			// 找到目标结点，跳出循环
+			break
+		}
+	}
+	// 返回目标结点
+	return cur
+}
diff --git a/codes/go/chapter_tree/avl_tree_test.go b/codes/go/chapter_tree/avl_tree_test.go
new file mode 100644
index 000000000..c4fc6b719
--- /dev/null
+++ b/codes/go/chapter_tree/avl_tree_test.go
@@ -0,0 +1,54 @@
+// File: avl_tree_test.go
+// Created Time: 2023-01-08
+// Author: Reanon (793584285@qq.com)
+
+package chapter_tree
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestAVLTree(t *testing.T) {
+	/* 初始化空 AVL 树 */
+	tree := newAVLTree()
+	/* 插入结点 */
+	// 请关注插入结点后，AVL 树是如何保持平衡的
+	testInsert(tree, 1)
+	testInsert(tree, 2)
+	testInsert(tree, 3)
+	testInsert(tree, 4)
+	testInsert(tree, 5)
+	testInsert(tree, 8)
+	testInsert(tree, 7)
+	testInsert(tree, 9)
+	testInsert(tree, 10)
+	testInsert(tree, 6)
+
+	/* 插入重复结点 */
+	testInsert(tree, 7)
+
+	/* 删除结点 */
+	// 请关注删除结点后，AVL 树是如何保持平衡的
+	testRemove(tree, 8) // 删除度为 0 的结点
+	testRemove(tree, 5) // 删除度为 1 的结点
+	testRemove(tree, 4) // 删除度为 2 的结点
+
+	/* 查询结点 */
+	node := tree.search(7)
+	fmt.Printf("\n查找到的结点对象为 %#v ，结点值 = %d \n", node, node.Val)
+}
+
+func testInsert(tree *avlTree, val int) {
+	tree.insert(val)
+	fmt.Printf("\n插入结点 %d 后，AVL 树为 \n", val)
+	PrintTree(tree.root)
+}
+
+func testRemove(tree *avlTree, val int) {
+	tree.remove(val)
+	fmt.Printf("\n删除结点  %d 后，AVL 树为 \n", val)
+	PrintTree(tree.root)
+}
diff --git a/codes/go/pkg/tree_node.go b/codes/go/pkg/tree_node.go
index b1e630e67..2ac2e22d1 100644
--- a/codes/go/pkg/tree_node.go
+++ b/codes/go/pkg/tree_node.go
@@ -9,16 +9,18 @@ import (
 )
 
 type TreeNode struct {
-	Val   int
-	Left  *TreeNode
-	Right *TreeNode
+	Val    int       // 结点值
+	Height int       // 结点高度
+	Left   *TreeNode // 左子结点引用
+	Right  *TreeNode // 右子结点引用
 }
 
 func NewTreeNode(v int) *TreeNode {
 	return &TreeNode{
-		Left:  nil,
-		Right: nil,
-		Val:   v,
+		Val:    v,
+		Height: 0,
+		Left:   nil,
+		Right:  nil,
 	}
 }
 

From 388509a84261c5690a511df8888d251cd7f151a9 Mon Sep 17 00:00:00 2001
From: reanon <793584285@qq.com>
Date: Mon, 9 Jan 2023 01:12:19 +0800
Subject: [PATCH 134/158] docs(tree/avl_tree): add go code

---
 codes/go/chapter_tree/avl_tree.go |   3 +-
 docs/chapter_tree/avl_tree.md     | 167 ++++++++++++++++++++++++++++--
 2 files changed, 161 insertions(+), 9 deletions(-)

diff --git a/codes/go/chapter_tree/avl_tree.go b/codes/go/chapter_tree/avl_tree.go
index 111abd722..e83b2882b 100644
--- a/codes/go/chapter_tree/avl_tree.go
+++ b/codes/go/chapter_tree/avl_tree.go
@@ -16,8 +16,7 @@ func newAVLTree() *avlTree {
 	return &avlTree{root: nil}
 }
 
-/* 获取结点高度
- */
+/* 获取结点高度 */
 func height(node *TreeNode) int {
 	// 空结点高度为 -1 ，叶结点高度为 0
 	if node != nil {
diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md
index 43e0d9f45..8fc2313c7 100644
--- a/docs/chapter_tree/avl_tree.md
+++ b/docs/chapter_tree/avl_tree.md
@@ -60,7 +60,13 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "Go"
 
     ```go title="avl_tree.go"
-    
+    /* AVL 树结点类 */
+    type TreeNode struct {
+        Val    int       // 结点值
+        Height int       // 结点高度
+        Left   *TreeNode // 左子结点引用
+        Right  *TreeNode // 右子结点引用
+    }
     ```
 
 === "JavaScript"
@@ -143,7 +149,26 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "Go"
 
     ```go title="avl_tree.go"
-    
+    /* 获取结点高度 */
+    func height(node *TreeNode) int {
+        // 空结点高度为 -1 ，叶结点高度为 0
+        if node != nil {
+            return node.Height
+        }
+        return -1
+    }
+
+    /* 更新结点高度 */
+    func updateHeight(node *TreeNode) {
+        lh := height(node.Left)
+        rh := height(node.Right)
+        // 结点高度等于最高子树高度 + 1
+        if lh > rh {
+            node.Height = lh + 1
+        } else {
+            node.Height = rh + 1
+        }
+    }
     ```
 
 === "JavaScript"
@@ -225,7 +250,15 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "Go"
 
     ```go title="avl_tree.go"
-    
+    /* 获取平衡因子 */
+    func balanceFactor(node *TreeNode) int {
+        // 空结点平衡因子为 0
+        if node == nil {
+            return 0
+        }
+        // 结点平衡因子 = 左子树高度 - 右子树高度
+        return height(node.Left) - height(node.Right)
+    }
     ```
 
 === "JavaScript"
@@ -338,7 +371,19 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Go"
 
     ```go title="avl_tree.go"
-    
+    /* 右旋操作 */
+    func rightRotate(node *TreeNode) *TreeNode {
+        child := node.Left
+        grandChild := child.Right
+        // 以 child 为原点，将 node 向右旋转
+        child.Right = node
+        node.Left = grandChild
+        // 更新结点高度
+        updateHeight(node)
+        updateHeight(child)
+        // 返回旋转后子树的根节点
+        return child
+    }
     ```
 
 === "JavaScript"
@@ -441,7 +486,19 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Go"
 
     ```go title="avl_tree.go"
-    
+    /* 左旋操作 */
+    func leftRotate(node *TreeNode) *TreeNode {
+        child := node.Right
+        grandChild := child.Left
+        // 以 child 为原点，将 node 向左旋转
+        child.Left = node
+        node.Right = grandChild
+        // 更新结点高度
+        updateHeight(node)
+        updateHeight(child)
+        // 返回旋转后子树的根节点
+        return child
+    }
     ```
 
 === "JavaScript"
@@ -592,7 +649,36 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Go"
 
     ```go title="avl_tree.go"
-    
+    /* 执行旋转操作，使该子树重新恢复平衡 */
+    func rotate(node *TreeNode) *TreeNode {
+        // 获取结点 node 的平衡因子
+        // Go 推荐短变量，这里 bf 指代 balanceFactor
+        bf := balanceFactor(node)
+        // 左偏树
+        if bf > 1 {
+            if balanceFactor(node.Left) >= 0 {
+                // 右旋
+                return rightRotate(node)
+            } else {
+                // 先左旋后右旋
+                node.Left = leftRotate(node.Left)
+                return rightRotate(node)
+            }
+        }
+        // 右偏树
+        if bf < -1 {
+            if balanceFactor(node.Right) <= 0 {
+                // 左旋
+                return leftRotate(node)
+            } else {
+                // 先右旋后左旋
+                node.Right = rightRotate(node.Right)
+                return leftRotate(node)
+            }
+        }
+        // 平衡树，无需旋转，直接返回
+        return node
+    }
     ```
 
 === "JavaScript"
@@ -730,7 +816,32 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Go"
 
     ```go title="avl_tree.go"
-    
+    /* 插入结点 */
+    func (t *avlTree) insert(val int) *TreeNode {
+        t.root = insertHelper(t.root, val)
+        return t.root
+    }
+    /* 递归插入结点（辅助函数） */
+    func insertHelper(node *TreeNode, val int) *TreeNode {
+        if node == nil {
+            return NewTreeNode(val)
+        }
+        /* 1. 查找插入位置，并插入结点 */
+        if val < node.Val {
+            node.Left = insertHelper(node.Left, val)
+        } else if val > node.Val {
+            node.Right = insertHelper(node.Right, val)
+        } else {
+            // 重复结点不插入，直接返回
+            return node
+        }
+        // 更新结点高度
+        updateHeight(node)
+        /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+        node = rotate(node)
+        // 返回子树的根节点
+        return node
+    }
     ```
 
 === "JavaScript"
@@ -876,7 +987,49 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "Go"
 
     ```go title="avl_tree.go"
+    /* 删除结点 */
+    func (t *avlTree) remove(val int) *TreeNode {
+        root := removeHelper(t.root, val)
+        return root
+    }
     
+    /* 递归删除结点（辅助函数） */
+    func removeHelper(node *TreeNode, val int) *TreeNode {
+        if node == nil {
+            return nil
+        }
+        /* 1. 查找结点，并删除之 */
+        if val < node.Val {
+            node.Left = removeHelper(node.Left, val)
+        } else if val > node.Val {
+            node.Right = removeHelper(node.Right, val)
+        } else {
+            if node.Left == nil || node.Right == nil {
+                child := node.Left
+                if node.Right != nil {
+                    child = node.Right
+                }
+                // 子结点数量 = 0 ，直接删除 node 并返回
+                if child == nil {
+                    return nil
+                } else {
+                    // 子结点数量 = 1 ，直接删除 node
+                    node = child
+                }
+            } else {
+                // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+                temp := getInOrderNext(node.Right)
+                node.Right = removeHelper(node.Right, temp.Val)
+                node.Val = temp.Val
+            }
+        }
+        // 更新结点高度
+        updateHeight(node)
+        /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+        node = rotate(node)
+        // 返回子树的根节点
+        return node
+    }
     ```
 
 === "JavaScript"

From 4d0143613827ec426b058aaa21648de023ce7641 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Mon, 9 Jan 2023 02:30:10 +0800
Subject: [PATCH 135/158] Remove avl_tree.cpp to match the latest docs.

---
 codes/cpp/chapter_tree/avl_tree.cpp | 228 ----------------------------
 1 file changed, 228 deletions(-)
 delete mode 100644 codes/cpp/chapter_tree/avl_tree.cpp

diff --git a/codes/cpp/chapter_tree/avl_tree.cpp b/codes/cpp/chapter_tree/avl_tree.cpp
deleted file mode 100644
index 8bc0741dc..000000000
--- a/codes/cpp/chapter_tree/avl_tree.cpp
+++ /dev/null
@@ -1,228 +0,0 @@
-/**
- * File: avl_tree.cpp
- * Created Time: 2022-12-2
- * Author: mgisr (maguagua0706@gmail.com)
- */
-
-#include "../include/include.hpp"
-
-class AvlTree {
-private:
-    TreeNode *root{};
-    static bool isBalance(const TreeNode *p);
-    static int getBalanceFactor(const TreeNode *p);
-    static void updateHeight(TreeNode *p);
-    void fixBalance(TreeNode *p);
-    static bool isLeftChild(const TreeNode *p);
-    static TreeNode *&fromParentTo(TreeNode *node);
-public:
-    AvlTree() = default;
-    AvlTree(const AvlTree &p) = default;
-    const TreeNode *search(int val);
-    bool insert(int val);
-    bool remove(int val);
-    void printTree();
-};
-
-// 判断该结点是否平衡
-bool AvlTree::isBalance(const TreeNode *p) {
-    int balance_factor = getBalanceFactor(p);
-    if (-1 <= balance_factor && balance_factor <= 1) { return true; }
-    else { return false; }
-}
-
-// 获取当前结点的平衡因子
-int AvlTree::getBalanceFactor(const TreeNode *p) {
-    if (p->left == nullptr && p->right == nullptr) { return 0; }
-    else if (p->left == nullptr) { return (-1 - p->right->height); }
-    else if (p->right == nullptr) { return p->left->height + 1; }
-    else { return p->left->height - p->right->height; }
-}
-
-// 更新结点高度
-void AvlTree::updateHeight(TreeNode *p) {
-    if (p->left == nullptr && p->right == nullptr) { p->height = 0; }
-    else if (p->left == nullptr) { p->height = p->right->height + 1; }
-    else if (p->right == nullptr) { p->height = p->left->height + 1; }
-    else { p->height = std::max(p->left->height, p->right->height) + 1; }
-}
-
-void AvlTree::fixBalance(TreeNode *p) {
-    // 左旋操作
-    auto rotate_left = [&](TreeNode *node) -> TreeNode * {
-        TreeNode *temp = node->right;
-        temp->parent = p->parent;
-        node->right = temp->left;
-        if (temp->left != nullptr) {
-            temp->left->parent = node;
-        }
-        temp->left = node;
-        node->parent = temp;
-        updateHeight(node);
-        updateHeight(temp);
-        return temp;
-    };
-    // 右旋操作
-    auto rotate_right = [&](TreeNode *node) -> TreeNode * {
-        TreeNode *temp = node->left;
-        temp->parent = p->parent;
-        node->left = temp->right;
-        if (temp->right != nullptr) {
-            temp->right->parent = node;
-        }
-        temp->right = node;
-        node->parent = temp;
-        updateHeight(node);
-        updateHeight(temp);
-        return temp;
-    };
-    // 根据规则选取旋转方式
-    if (getBalanceFactor(p) > 1) {
-        if (getBalanceFactor(p->left) > 0) {
-            if (p->parent == nullptr) { root = rotate_right(p); }
-            else { fromParentTo(p) = rotate_right(p); }
-        } else {
-            p->left = rotate_left(p->left);
-            if (p->parent == nullptr) { root = rotate_right(p); }
-            else { fromParentTo(p) = rotate_right(p); }
-        }
-    } else {
-        if (getBalanceFactor(p->right) < 0) {
-            if (p->parent == nullptr) { root = rotate_left(p); }
-            else { fromParentTo(p) = rotate_left(p); }
-        } else {
-            p->right = rotate_right(p->right);
-            if (p->parent == nullptr) { root = rotate_left(p); }
-            else { fromParentTo(p) = rotate_left(p); }
-        }
-    }
-}
-
-// 判断当前结点是否为其父节点的左孩子
-bool AvlTree::isLeftChild(const TreeNode *p) {
-    if (p->parent == nullptr) { return false; }
-    return (p->parent->left == p);
-}
-
-// 返回父节点指向当前结点指针的引用
-TreeNode *&AvlTree::fromParentTo(TreeNode *node) {
-    if (isLeftChild(node)) { return node->parent->left; }
-    else { return node->parent->right; }
-}
-
-const TreeNode *AvlTree::search(int val) {
-    TreeNode *p = root;
-    while (p != nullptr) {
-        if (p->val == val) { return p; }
-        else if (p->val > val) { p = p->left; }
-        else { p = p->right; }
-    }
-    return nullptr;
-}
-
-bool AvlTree::insert(int val) {
-    TreeNode *p = root;
-    if (p == nullptr) {
-        root = new TreeNode(val);
-        return true;
-    }
-    for (;;) {
-        if (p->val == val) { return false; }
-        else if (p->val > val) {
-            if (p->left == nullptr) {
-                p->left = new TreeNode(val, p);
-                break;
-            } else {
-                p = p->left;
-            }
-        } else {
-            if (p->right == nullptr) {
-                p->right = new TreeNode(val, p);
-                break;
-            } else {
-                p = p->right;
-            }
-        }
-    }
-    for (; p != nullptr; p = p->parent) {
-        if (!isBalance(p)) {
-            fixBalance(p);
-            break;
-        } else { updateHeight(p); }
-    }
-    return true;
-}
-
-bool AvlTree::remove(int val) {
-    TreeNode *p = root;
-    if (p == nullptr) { return false; }
-    while (p != nullptr) {
-        if (p->val == val) {
-            TreeNode *real_delete_node = p;
-            TreeNode *next_node;
-            if (p->left == nullptr) {
-                next_node = p->right;
-                if (p->parent == nullptr) { root = next_node; }
-                else { fromParentTo(p) = next_node; }
-            } else if (p->right == nullptr) {
-                next_node = p->left;
-                if (p->parent == nullptr) { root = next_node; }
-                else { fromParentTo(p) = next_node; }
-            } else {
-                while (real_delete_node->left != nullptr) {
-                    real_delete_node = real_delete_node->left;
-                }
-                std::swap(p->val, real_delete_node->val);
-                next_node = real_delete_node->right;
-                if (real_delete_node->parent == p) { p->right = next_node; }
-                else { real_delete_node->parent->left = next_node; }
-            }
-            if (next_node != nullptr) {
-                next_node->parent = real_delete_node->parent;
-            }
-            for (p = real_delete_node; p != nullptr; p = p->parent) {
-                if (!isBalance(p)) { fixBalance(p); }
-                updateHeight(p);
-            }
-            delete real_delete_node;
-            return true;
-        } else if (p->val > val) {
-            p = p->left;
-        } else {
-            p = p->right;
-        }
-    }
-    return false;
-}
-
-void inOrder(const TreeNode *root) {
-    if (root == nullptr) return;
-    inOrder(root->left);
-    cout << root->val << ' ';
-    inOrder(root->right);
-}
-
-void AvlTree::printTree() {
-    inOrder(root);
-    cout << endl;
-}
-
-int main() {
-    AvlTree tree = AvlTree();
-    // tree.insert(13);
-    // tree.insert(24);
-    // tree.insert(37);
-    // tree.insert(90);
-    // tree.insert(53);
-
-    tree.insert(53);
-    tree.insert(90);
-    tree.insert(37);
-    tree.insert(24);
-    tree.insert(13);
-    tree.remove(90);
-    tree.printTree();
-    const TreeNode *p = tree.search(37);
-    cout << p->val;
-    return 0;
-}
\ No newline at end of file

From 97ee638d31a0f88b13644ff0c81352094d18496f Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Mon, 9 Jan 2023 02:49:34 +0800
Subject: [PATCH 136/158] Update the Optional alias of Python codes.

---
 codes/python/chapter_tree/avl_tree.py         | 22 +++++++++----------
 .../python/chapter_tree/binary_search_tree.py | 16 ++++++--------
 codes/python/chapter_tree/binary_tree_bfs.py  |  4 +---
 codes/python/chapter_tree/binary_tree_dfs.py  |  8 +++----
 codes/python/include/__init__.py              |  2 +-
 docs/chapter_tree/avl_tree.md                 | 16 +++++++-------
 docs/chapter_tree/binary_search_tree.md       |  6 ++---
 docs/chapter_tree/binary_tree_traversal.md    |  8 +++----
 8 files changed, 37 insertions(+), 45 deletions(-)

diff --git a/codes/python/chapter_tree/avl_tree.py b/codes/python/chapter_tree/avl_tree.py
index 04218e46a..83929981d 100644
--- a/codes/python/chapter_tree/avl_tree.py
+++ b/codes/python/chapter_tree/avl_tree.py
@@ -5,30 +5,28 @@ Author: a16su (lpluls001@gmail.com)
 """
 
 import sys, os.path as osp
-import typing
-
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
 
 class AVLTree:
-    def __init__(self, root: typing.Optional[TreeNode] = None):
+    def __init__(self, root: Optional[TreeNode] = None):
         self.root = root
 
     """ 获取结点高度 """
-    def height(self, node: typing.Optional[TreeNode]) -> int:
+    def height(self, node: Optional[TreeNode]) -> int:
         # 空结点高度为 -1 ，叶结点高度为 0
         if node is not None:
             return node.height
         return -1
 
     """ 更新结点高度 """
-    def __update_height(self, node: TreeNode):
+    def __update_height(self, node: Optional[TreeNode]):
         # 结点高度等于最高子树高度 + 1
         node.height = max([self.height(node.left), self.height(node.right)]) + 1
 
     """ 获取平衡因子 """
-    def balance_factor(self, node: TreeNode) -> int:
+    def balance_factor(self, node: Optional[TreeNode]) -> int:
         # 空结点平衡因子为 0
         if node is None:
             return 0
@@ -36,7 +34,7 @@ class AVLTree:
         return self.height(node.left) - self.height(node.right)
 
     """ 右旋操作 """
-    def __right_rotate(self, node: TreeNode) -> TreeNode:
+    def __right_rotate(self, node: Optional[TreeNode]) -> TreeNode:
         child = node.left
         grand_child = child.right
         # 以 child 为原点，将 node 向右旋转
@@ -49,7 +47,7 @@ class AVLTree:
         return child
 
     """ 左旋操作 """
-    def __left_rotate(self, node: TreeNode) -> TreeNode:
+    def __left_rotate(self, node: Optional[TreeNode]) -> TreeNode:
         child = node.right
         grand_child = child.left
         # 以 child 为原点，将 node 向左旋转
@@ -62,7 +60,7 @@ class AVLTree:
         return child
 
     """ 执行旋转操作，使该子树重新恢复平衡 """
-    def __rotate(self, node: TreeNode) -> TreeNode:
+    def __rotate(self, node: Optional[TreeNode]) -> TreeNode:
         # 获取结点 node 的平衡因子
         balance_factor = self.balance_factor(node)
         # 左偏树
@@ -92,7 +90,7 @@ class AVLTree:
         return self.root
 
     """ 递归插入结点（辅助函数）"""
-    def __insert_helper(self, node: typing.Optional[TreeNode], val: int) -> TreeNode:
+    def __insert_helper(self, node: Optional[TreeNode], val: int) -> TreeNode:
         if node is None:
             return TreeNode(val)
         # 1. 查找插入位置，并插入结点
@@ -114,7 +112,7 @@ class AVLTree:
         return root
 
     """ 递归删除结点（辅助函数） """
-    def __remove_helper(self, node: typing.Optional[TreeNode], val: int) -> typing.Optional[TreeNode]:
+    def __remove_helper(self, node: Optional[TreeNode], val: int) -> Optional[TreeNode]:
         if node is None:
             return None
         # 1. 查找结点，并删除之
@@ -141,7 +139,7 @@ class AVLTree:
         return self.__rotate(node)
 
     """ 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） """
-    def __get_inorder_next(self, node: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
+    def __get_inorder_next(self, node: Optional[TreeNode]) -> Optional[TreeNode]:
         if node is None:
             return None
         # 循环访问左子结点，直到叶结点时为最小结点，跳出
diff --git a/codes/python/chapter_tree/binary_search_tree.py b/codes/python/chapter_tree/binary_search_tree.py
index 7633b6288..2a8272761 100644
--- a/codes/python/chapter_tree/binary_search_tree.py
+++ b/codes/python/chapter_tree/binary_search_tree.py
@@ -5,20 +5,18 @@ Author: a16su (lpluls001@gmail.com)
 """
 
 import sys, os.path as osp
-import typing
-
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
 
 """ 二叉搜索树 """
 class BinarySearchTree:
-    def __init__(self, nums: typing.List[int]) -> None:
+    def __init__(self, nums: List[int]) -> None:
         nums.sort()
         self.__root = self.build_tree(nums, 0, len(nums) - 1)
 
     """ 构建二叉搜索树 """
-    def build_tree(self, nums: typing.List[int], start_index: int, end_index: int) -> typing.Optional[TreeNode]:
+    def build_tree(self, nums: List[int], start_index: int, end_index: int) -> Optional[TreeNode]:
         if start_index > end_index:
             return None
 
@@ -31,11 +29,11 @@ class BinarySearchTree:
         return root
 
     @property
-    def root(self) -> typing.Optional[TreeNode]:
+    def root(self) -> Optional[TreeNode]:
         return self.__root
 
     """ 查找结点 """
-    def search(self, num: int) -> typing.Optional[TreeNode]:
+    def search(self, num: int) -> Optional[TreeNode]:
         cur = self.root
         # 循环查找，越过叶结点后跳出
         while cur is not None:
@@ -51,7 +49,7 @@ class BinarySearchTree:
         return cur
 
     """ 插入结点 """
-    def insert(self, num: int) -> typing.Optional[TreeNode]:
+    def insert(self, num: int) -> Optional[TreeNode]:
         root = self.root
         # 若树为空，直接提前返回
         if root is None:
@@ -81,7 +79,7 @@ class BinarySearchTree:
         return node
 
     """ 删除结点 """
-    def remove(self, num: int) -> typing.Optional[TreeNode]:
+    def remove(self, num: int) -> Optional[TreeNode]:
         root = self.root
         # 若树为空，直接提前返回
         if root is None:
@@ -126,7 +124,7 @@ class BinarySearchTree:
         return cur
 
     """ 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） """
-    def get_inorder_next(self, root: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
+    def get_inorder_next(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
         if root is None:
             return root
         # 循环访问左子结点，直到叶结点时为最小结点，跳出
diff --git a/codes/python/chapter_tree/binary_tree_bfs.py b/codes/python/chapter_tree/binary_tree_bfs.py
index 225a8bd6e..fb3e93059 100644
--- a/codes/python/chapter_tree/binary_tree_bfs.py
+++ b/codes/python/chapter_tree/binary_tree_bfs.py
@@ -5,14 +5,12 @@ Author: a16su (lpluls001@gmail.com)
 """
 
 import sys, os.path as osp
-import typing
-
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
 
 """ 层序遍历 """
-def hier_order(root: TreeNode):
+def hier_order(root: Optional[TreeNode]):
     # 初始化队列，加入根结点
     queue = collections.deque()
     queue.append(root)
diff --git a/codes/python/chapter_tree/binary_tree_dfs.py b/codes/python/chapter_tree/binary_tree_dfs.py
index a1d46e697..b0efb14c8 100644
--- a/codes/python/chapter_tree/binary_tree_dfs.py
+++ b/codes/python/chapter_tree/binary_tree_dfs.py
@@ -5,8 +5,6 @@ Author: a16su (lpluls001@gmail.com)
 """
 
 import sys, os.path as osp
-import typing
-
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
@@ -14,7 +12,7 @@ from include import *
 res = []
 
 """ 前序遍历 """
-def pre_order(root: typing.Optional[TreeNode]):
+def pre_order(root: Optional[TreeNode]):
     if root is None:
         return
     # 访问优先级：根结点 -> 左子树 -> 右子树
@@ -23,7 +21,7 @@ def pre_order(root: typing.Optional[TreeNode]):
     pre_order(root=root.right)
 
 """ 中序遍历 """
-def in_order(root: typing.Optional[TreeNode]):
+def in_order(root: Optional[TreeNode]):
     if root is None:
         return
     # 访问优先级：左子树 -> 根结点 -> 右子树
@@ -32,7 +30,7 @@ def in_order(root: typing.Optional[TreeNode]):
     in_order(root=root.right)
 
 """ 后序遍历 """
-def post_order(root: typing.Optional[TreeNode]):
+def post_order(root: Optional[TreeNode]):
     if root is None:
         return
     # 访问优先级：左子树 -> 右子树 -> 根结点
diff --git a/codes/python/include/__init__.py b/codes/python/include/__init__.py
index 31ed69ace..9d4e90bee 100644
--- a/codes/python/include/__init__.py
+++ b/codes/python/include/__init__.py
@@ -4,7 +4,7 @@ import queue
 import random
 import functools
 import collections
-from typing import List
+from typing import Optional, List, Dict, DefaultDict, OrderedDict, Set, Deque
 from .linked_list import ListNode, list_to_linked_list, linked_list_to_list, get_list_node
 from .binary_tree import TreeNode, list_to_tree, tree_to_list, get_tree_node
 from .print_util import print_matrix, print_linked_list, print_tree, print_dict
\ No newline at end of file
diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md
index 8fc2313c7..9944f29e8 100644
--- a/docs/chapter_tree/avl_tree.md
+++ b/docs/chapter_tree/avl_tree.md
@@ -134,14 +134,14 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 
     ```python title="avl_tree.py"
     """ 获取结点高度 """
-    def height(self, node: typing.Optional[TreeNode]) -> int:
+    def height(self, node: Optional[TreeNode]) -> int:
         # 空结点高度为 -1 ，叶结点高度为 0
         if node is not None:
             return node.height
         return -1
     
     """ 更新结点高度 """
-    def __update_height(self, node: TreeNode):
+    def __update_height(self, node: Optional[TreeNode]):
         # 结点高度等于最高子树高度 + 1
         node.height = max([self.height(node.left), self.height(node.right)]) + 1
     ```
@@ -239,7 +239,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 
     ```python title="avl_tree.py"
     """ 获取平衡因子 """
-    def balance_factor(self, node: TreeNode) -> int:
+    def balance_factor(self, node: Optional[TreeNode]) -> int:
         # 空结点平衡因子为 0
         if node is None:
             return 0
@@ -355,7 +355,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 
     ```python title="avl_tree.py"
     """ 右旋操作 """
-    def __right_rotate(self, node: TreeNode) -> TreeNode:
+    def __right_rotate(self, node: Optional[TreeNode]) -> TreeNode:
         child = node.left
         grand_child = child.right
         # 以 child 为原点，将 node 向右旋转
@@ -470,7 +470,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 
     ```python title="avl_tree.py"
     """ 左旋操作 """
-    def __left_rotate(self, node: TreeNode) -> TreeNode:
+    def __left_rotate(self, node: Optional[TreeNode]) -> TreeNode:
         child = node.right
         grand_child = child.left
         # 以 child 为原点，将 node 向左旋转
@@ -621,7 +621,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 
     ```python title="avl_tree.py"
     """ 执行旋转操作，使该子树重新恢复平衡 """
-    def __rotate(self, node: TreeNode) -> TreeNode:
+    def __rotate(self, node: Optional[TreeNode]) -> TreeNode:
         # 获取结点 node 的平衡因子
         balance_factor = self.balance_factor(node)
         # 左偏树
@@ -796,7 +796,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         return self.root
     
     """ 递归插入结点（辅助函数）"""
-    def __insert_helper(self, node: typing.Optional[TreeNode], val: int) -> TreeNode:
+    def __insert_helper(self, node: Optional[TreeNode], val: int) -> TreeNode:
         if node is None:
             return TreeNode(val)
         # 1. 查找插入位置，并插入结点
@@ -957,7 +957,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         return root
     
     """ 递归删除结点（辅助函数） """
-    def __remove_helper(self, node: typing.Optional[TreeNode], val: int) -> typing.Optional[TreeNode]:
+    def __remove_helper(self, node: Optional[TreeNode], val: int) -> Optional[TreeNode]:
         if node is None:
             return None
         # 1. 查找结点，并删除之
diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md
index e3ddfaaac..a4c5a5d2a 100644
--- a/docs/chapter_tree/binary_search_tree.md
+++ b/docs/chapter_tree/binary_search_tree.md
@@ -83,7 +83,7 @@ comments: true
 
     ```python title="binary_search_tree.py"
     """ 查找结点 """
-    def search(self, num: int) -> typing.Optional[TreeNode]:
+    def search(self, num: int) -> Optional[TreeNode]:
         cur = self.root
         # 循环查找，越过叶结点后跳出
         while cur is not None:
@@ -265,7 +265,7 @@ comments: true
 
     ```python title="binary_search_tree.py"
     """ 插入结点 """
-    def insert(self, num: int) -> typing.Optional[TreeNode]:
+    def insert(self, num: int) -> Optional[TreeNode]:
         root = self.root
         # 若树为空，直接提前返回
         if root is None:
@@ -560,7 +560,7 @@ comments: true
 
     ```python title="binary_search_tree.py"
     """ 删除结点 """
-    def remove(self, num: int) -> typing.Optional[TreeNode]:
+    def remove(self, num: int) -> Optional[TreeNode]:
         root = self.root
         # 若树为空，直接提前返回
         if root is None:
diff --git a/docs/chapter_tree/binary_tree_traversal.md b/docs/chapter_tree/binary_tree_traversal.md
index c64077072..650a15297 100644
--- a/docs/chapter_tree/binary_tree_traversal.md
+++ b/docs/chapter_tree/binary_tree_traversal.md
@@ -66,7 +66,7 @@ comments: true
 
     ```python title="binary_tree_bfs.py"
     """ 层序遍历 """
-    def hier_order(root: TreeNode):
+    def hier_order(root: Optional[TreeNode]):
         # 初始化队列，加入根结点
         queue = collections.deque()
         queue.append(root)
@@ -277,7 +277,7 @@ comments: true
 
     ```python title="binary_tree_dfs.py"
     """ 前序遍历 """
-    def pre_order(root: typing.Optional[TreeNode]):
+    def pre_order(root: Optional[TreeNode]):
         if root is None:
             return
         # 访问优先级：根结点 -> 左子树 -> 右子树
@@ -286,7 +286,7 @@ comments: true
         pre_order(root=root.right)
 
     """ 中序遍历 """
-    def in_order(root: typing.Optional[TreeNode]):
+    def in_order(root: Optional[TreeNode]):
         if root is None:
             return
         # 访问优先级：左子树 -> 根结点 -> 右子树
@@ -295,7 +295,7 @@ comments: true
         in_order(root=root.right)
 
     """ 后序遍历 """
-    def post_order(root: typing.Optional[TreeNode]):
+    def post_order(root: Optional[TreeNode]):
         if root is None:
             return
         # 访问优先级：左子树 -> 右子树 -> 根结点

From 5e23c75870df5928e72fbd35e173a39910d304ba Mon Sep 17 00:00:00 2001
From: nuomi1 <nuomi1@qq.com>
Date: Sun, 8 Jan 2023 23:44:13 +0800
Subject: [PATCH 137/158] feat: add Swift codes for list article

---
 codes/swift/Package.swift                     |   4 +
 .../chapter_array_and_linkedlist/list.swift   |  64 ++++++++
 .../my_list.swift                             | 147 ++++++++++++++++++
 docs/chapter_array_and_linkedlist/list.md     | 143 ++++++++++++++++-
 4 files changed, 354 insertions(+), 4 deletions(-)
 create mode 100644 codes/swift/chapter_array_and_linkedlist/list.swift
 create mode 100644 codes/swift/chapter_array_and_linkedlist/my_list.swift

diff --git a/codes/swift/Package.swift b/codes/swift/Package.swift
index 4cf3601c7..3a5a18ed3 100644
--- a/codes/swift/Package.swift
+++ b/codes/swift/Package.swift
@@ -11,6 +11,8 @@ let package = Package(
         .executable(name: "leetcode_two_sum", targets: ["leetcode_two_sum"]),
         .executable(name: "array", targets: ["array"]),
         .executable(name: "linked_list", targets: ["linked_list"]),
+        .executable(name: "list", targets: ["list"]),
+        .executable(name: "my_list", targets: ["my_list"]),
     ],
     targets: [
         .target(name: "utils", path: "utils"),
@@ -20,5 +22,7 @@ let package = Package(
         .executableTarget(name: "leetcode_two_sum", path: "chapter_computational_complexity", sources: ["leetcode_two_sum.swift"]),
         .executableTarget(name: "array", path: "chapter_array_and_linkedlist", sources: ["array.swift"]),
         .executableTarget(name: "linked_list", dependencies: ["utils"], path: "chapter_array_and_linkedlist", sources: ["linked_list.swift"]),
+        .executableTarget(name: "list", path: "chapter_array_and_linkedlist", sources: ["list.swift"]),
+        .executableTarget(name: "my_list", path: "chapter_array_and_linkedlist", sources: ["my_list.swift"]),
     ]
 )
diff --git a/codes/swift/chapter_array_and_linkedlist/list.swift b/codes/swift/chapter_array_and_linkedlist/list.swift
new file mode 100644
index 000000000..27801d13f
--- /dev/null
+++ b/codes/swift/chapter_array_and_linkedlist/list.swift
@@ -0,0 +1,64 @@
+/**
+ * File: list.swift
+ * Created Time: 2023-01-08
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+@main
+enum List {
+    /* Driver Code */
+    static func main() {
+        /* 初始化列表 */
+        var list = [1, 3, 2, 5, 4]
+        print("列表 list = \(list)")
+
+        /* 访问元素 */
+        let num = list[1]
+        print("访问索引 1 处的元素，得到 num = \(num)")
+
+        /* 更新元素 */
+        list[1] = 0
+        print("将索引 1 处的元素更新为 0 ，得到 list = \(list)")
+
+        /* 清空列表 */
+        list.removeAll()
+        print("清空列表后 list = \(list)")
+
+        /* 尾部添加元素 */
+        list.append(1)
+        list.append(3)
+        list.append(2)
+        list.append(5)
+        list.append(4)
+        print("添加元素后 list = \(list)")
+
+        /* 中间插入元素 */
+        list.insert(6, at: 3)
+        print("在索引 3 处插入数字 6 ，得到 list = \(list)")
+
+        /* 删除元素 */
+        list.remove(at: 3)
+        print("删除索引 3 处的元素，得到 list = \(list)")
+
+        /* 通过索引遍历列表 */
+        var count = 0
+        for _ in list.indices {
+            count += 1
+        }
+
+        /* 直接遍历列表元素 */
+        count = 0
+        for _ in list {
+            count += 1
+        }
+
+        /* 拼接两个列表 */
+        let list1 = [6, 8, 7, 10, 9]
+        list.append(contentsOf: list1)
+        print("将列表 list1 拼接到 list 之后，得到 list = \(list)")
+
+        /* 排序列表 */
+        list.sort()
+        print("排序列表后 list = \(list)")
+    }
+}
diff --git a/codes/swift/chapter_array_and_linkedlist/my_list.swift b/codes/swift/chapter_array_and_linkedlist/my_list.swift
new file mode 100644
index 000000000..423b02027
--- /dev/null
+++ b/codes/swift/chapter_array_and_linkedlist/my_list.swift
@@ -0,0 +1,147 @@
+/**
+ * File: my_list.swift
+ * Created Time: 2023-01-08
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* 列表类简易实现 */
+class MyList {
+    private var nums: [Int] // 数组（存储列表元素）
+    private var _capacity = 10 // 列表容量
+    private var _size = 0 // 列表长度（即当前元素数量）
+    private let extendRatio = 2 // 每次列表扩容的倍数
+
+    /* 构造函数 */
+    init() {
+        nums = Array(repeating: 0, count: _capacity)
+    }
+
+    /* 获取列表长度（即当前元素数量）*/
+    func size() -> Int {
+        _size
+    }
+
+    /* 获取列表容量 */
+    func capacity() -> Int {
+        _capacity
+    }
+
+    /* 访问元素 */
+    func get(index: Int) -> Int {
+        // 索引如果越界则抛出错误，下同
+        if index >= _size {
+            fatalError("索引越界")
+        }
+        return nums[index]
+    }
+
+    /* 更新元素 */
+    func set(index: Int, num: Int) {
+        if index >= _size {
+            fatalError("索引越界")
+        }
+        nums[index] = num
+    }
+
+    /* 尾部添加元素 */
+    func add(num: Int) {
+        // 元素数量超出容量时，触发扩容机制
+        if _size == _capacity {
+            extendCapacity()
+        }
+        nums[_size] = num
+        // 更新元素数量
+        _size += 1
+    }
+
+    /* 中间插入元素 */
+    func insert(index: Int, num: Int) {
+        if index >= _size {
+            fatalError("索引越界")
+        }
+        // 元素数量超出容量时，触发扩容机制
+        if _size == _capacity {
+            extendCapacity()
+        }
+        // 将索引 index 以及之后的元素都向后移动一位
+        for j in sequence(first: _size - 1, next: { $0 >= index + 1 ? $0 - 1 : nil }) {
+            nums[j + 1] = nums[j]
+        }
+        nums[index] = num
+        // 更新元素数量
+        _size += 1
+    }
+
+    /* 删除元素 */
+    @discardableResult
+    func remove(index: Int) -> Int {
+        if index >= _size {
+            fatalError("索引越界")
+        }
+        let num = nums[index]
+        // 将索引 index 之后的元素都向前移动一位
+        for j in index ..< (_size - 1) {
+            nums[j] = nums[j + 1]
+        }
+        // 更新元素数量
+        _size -= 1
+        // 返回被删除元素
+        return num
+    }
+
+    /* 列表扩容 */
+    func extendCapacity() {
+        // 新建一个长度为 size 的数组，并将原数组拷贝到新数组
+        nums = nums + Array(repeating: 0, count: _capacity * (extendRatio - 1))
+        // 更新列表容量
+        _capacity = nums.count
+    }
+
+    /* 将列表转换为数组 */
+    func toArray() -> [Int] {
+        var nums = Array(repeating: 0, count: _size)
+        for i in 0 ..< _size {
+            nums[i] = get(index: i)
+        }
+        return nums
+    }
+}
+
+@main
+enum _MyList {
+    /* Driver Code */
+    static func main() {
+        /* 初始化列表 */
+        let list = MyList()
+        /* 尾部添加元素 */
+        list.add(num: 1)
+        list.add(num: 3)
+        list.add(num: 2)
+        list.add(num: 5)
+        list.add(num: 4)
+        print("列表 list = \(list.toArray()) ，容量 = \(list.capacity()) ，长度 = \(list.size())")
+
+        /* 中间插入元素 */
+        list.insert(index: 3, num: 6)
+        print("在索引 3 处插入数字 6 ，得到 list = \(list.toArray())")
+
+        /* 删除元素 */
+        list.remove(index: 3)
+        print("删除索引 3 处的元素，得到 list = \(list.toArray())")
+
+        /* 访问元素 */
+        let num = list.get(index: 1)
+        print("访问索引 1 处的元素，得到 num = \(num)")
+
+        /* 更新元素 */
+        list.set(index: 1, num: 0)
+        print("将索引 1 处的元素更新为 0 ，得到 list = \(list.toArray())")
+
+        /* 测试扩容机制 */
+        for i in 0 ..< 10 {
+            // 在 i = 5 时，列表长度将超出列表容量，此时触发扩容机制
+            list.add(num: i)
+        }
+        print("扩容后的列表 list = \(list.toArray()) ，容量 = \(list.capacity()) ，长度 = \(list.size())")
+    }
+}
diff --git a/docs/chapter_array_and_linkedlist/list.md b/docs/chapter_array_and_linkedlist/list.md
index ca4774a04..ce8bb8870 100644
--- a/docs/chapter_array_and_linkedlist/list.md
+++ b/docs/chapter_array_and_linkedlist/list.md
@@ -94,7 +94,11 @@ comments: true
 === "Swift"
 
     ```swift title="list.swift"
-
+    /* 初始化列表 */
+    // 无初始值
+    let list1: [Int] = []
+    // 有初始值
+    var list = [1, 3, 2, 5, 4]
     ```
 
 **访问与更新元素**。列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。
@@ -178,7 +182,11 @@ comments: true
 === "Swift"
 
     ```swift title="list.swift"
+    /* 访问元素 */
+    let num = list[1] // 访问索引 1 处的元素
 
+    /* 更新元素 */
+    list[1] = 0 // 将索引 1 处的元素更新为 0
     ```
 
 **在列表中添加、插入、删除元素**。相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
@@ -332,7 +340,21 @@ comments: true
 === "Swift"
 
     ```swift title="list.swift"
+    /* 清空列表 */
+    list.removeAll()
 
+    /* 尾部添加元素 */
+    list.append(1)
+    list.append(3)
+    list.append(2)
+    list.append(5)
+    list.append(4)
+
+    /* 中间插入元素 */
+    list.insert(6, at: 3) // 在索引 3 处插入数字 6
+
+    /* 删除元素 */
+    list.remove(at: 3) // 删除索引 3 处的元素
     ```
 
 **遍历列表**。与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
@@ -458,7 +480,17 @@ comments: true
 === "Swift"
 
     ```swift title="list.swift"
+    /* 通过索引遍历列表 */
+    var count = 0
+    for _ in list.indices {
+        count += 1
+    }
 
+    /* 直接遍历列表元素 */
+    count = 0
+    for _ in list {
+        count += 1
+    }
     ```
 
 **拼接两个列表**。再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。
@@ -529,7 +561,9 @@ comments: true
 === "Swift"
 
     ```swift title="list.swift"
-
+    /* 拼接两个列表 */
+    let list1 = [6, 8, 7, 10, 9]
+    list.append(contentsOf: list1) // 将列表 list1 拼接到 list 之后
     ```
 
 **排序列表**。排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
@@ -592,7 +626,8 @@ comments: true
 === "Swift"
 
     ```swift title="list.swift"
-
+    /* 排序列表 */
+    list.sort() // 排序后，列表元素从小到大排列
     ```
 
 ## 列表简易实现 *
@@ -1263,6 +1298,106 @@ comments: true
 === "Swift"
 
     ```swift title="my_list.swift"
+    /* 列表类简易实现 */
+    class MyList {
+        private var nums: [Int] // 数组（存储列表元素）
+        private var _capacity = 10 // 列表容量
+        private var _size = 0 // 列表长度（即当前元素数量）
+        private let extendRatio = 2 // 每次列表扩容的倍数
 
+        /* 构造函数 */
+        init() {
+            nums = Array(repeating: 0, count: _capacity)
+        }
+
+        /* 获取列表长度（即当前元素数量）*/
+        func size() -> Int {
+            _size
+        }
+
+        /* 获取列表容量 */
+        func capacity() -> Int {
+            _capacity
+        }
+
+        /* 访问元素 */
+        func get(index: Int) -> Int {
+            // 索引如果越界则抛出错误，下同
+            if index >= _size {
+                fatalError("索引越界")
+            }
+            return nums[index]
+        }
+
+        /* 更新元素 */
+        func set(index: Int, num: Int) {
+            if index >= _size {
+                fatalError("索引越界")
+            }
+            nums[index] = num
+        }
+
+        /* 尾部添加元素 */
+        func add(num: Int) {
+            // 元素数量超出容量时，触发扩容机制
+            if _size == _capacity {
+                extendCapacity()
+            }
+            nums[_size] = num
+            // 更新元素数量
+            _size += 1
+        }
+
+        /* 中间插入元素 */
+        func insert(index: Int, num: Int) {
+            if index >= _size {
+                fatalError("索引越界")
+            }
+            // 元素数量超出容量时，触发扩容机制
+            if _size == _capacity {
+                extendCapacity()
+            }
+            // 将索引 index 以及之后的元素都向后移动一位
+            for j in sequence(first: _size - 1, next: { $0 >= index + 1 ? $0 - 1 : nil }) {
+                nums[j + 1] = nums[j]
+            }
+            nums[index] = num
+            // 更新元素数量
+            _size += 1
+        }
+
+        /* 删除元素 */
+        @discardableResult
+        func remove(index: Int) -> Int {
+            if index >= _size {
+                fatalError("索引越界")
+            }
+            let num = nums[index]
+            // 将索引 index 之后的元素都向前移动一位
+            for j in index ..< (_size - 1) {
+                nums[j] = nums[j + 1]
+            }
+            // 更新元素数量
+            _size -= 1
+            // 返回被删除元素
+            return num
+        }
+
+        /* 列表扩容 */
+        func extendCapacity() {
+            // 新建一个长度为 size 的数组，并将原数组拷贝到新数组
+            nums = nums + Array(repeating: 0, count: _capacity * (extendRatio - 1))
+            // 更新列表容量
+            _capacity = nums.count
+        }
+
+        /* 将列表转换为数组 */
+        func toArray() -> [Int] {
+            var nums = Array(repeating: 0, count: _size)
+            for i in 0 ..< _size {
+                nums[i] = get(index: i)
+            }
+            return nums
+        }
+    }
     ```
-

From e6021ff59e66fea7d5189135ccdf214697d647ab Mon Sep 17 00:00:00 2001
From: nuomi1 <nuomi1@qq.com>
Date: Sun, 8 Jan 2023 23:48:35 +0800
Subject: [PATCH 138/158] fix: predicate

---
 .../chapter_computational_complexity/time_complexity.swift    | 4 ++--
 docs/chapter_computational_complexity/time_complexity.md      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/codes/swift/chapter_computational_complexity/time_complexity.swift b/codes/swift/chapter_computational_complexity/time_complexity.swift
index 41695cfd6..1b1027ef2 100644
--- a/codes/swift/chapter_computational_complexity/time_complexity.swift
+++ b/codes/swift/chapter_computational_complexity/time_complexity.swift
@@ -49,7 +49,7 @@ func quadratic(n: Int) -> Int {
 func bubbleSort(nums: inout [Int]) -> Int {
     var count = 0 // 计数器
     // 外循环：待排序元素数量为 n-1, n-2, ..., 1
-    for i in sequence(first: nums.count - 1, next: { $0 > 0 ? $0 - 1 : nil }) {
+    for i in sequence(first: nums.count - 1, next: { $0 > 0 + 1 ? $0 - 1 : nil }) {
         // 内循环：冒泡操作
         for j in 0 ..< i {
             if nums[j] > nums[j + 1] {
@@ -149,7 +149,7 @@ enum TimeComplexity {
 
         count = quadratic(n: n)
         print("平方阶的计算操作数量 = \(count)")
-        var nums = Array(sequence(first: n, next: { $0 > 0 ? $0 - 1 : nil })) // [n,n-1,...,2,1]
+        var nums = Array(sequence(first: n, next: { $0 > 0 + 1 ? $0 - 1 : nil })) // [n,n-1,...,2,1]
         count = bubbleSort(nums: &nums)
         print("平方阶（冒泡排序）的计算操作数量 = \(count)")
 
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 25d9fce88..09aee7b79 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -1481,7 +1481,7 @@ $$
     func bubbleSort(nums: inout [Int]) -> Int {
         var count = 0 // 计数器
         // 外循环：待排序元素数量为 n-1, n-2, ..., 1
-        for i in sequence(first: nums.count - 1, next: { $0 > 0 ? $0 - 1 : nil }) {
+        for i in sequence(first: nums.count - 1, next: { $0 > 0 + 1 ? $0 - 1 : nil }) {
             // 内循环：冒泡操作
             for j in 0 ..< i {
                 if nums[j] > nums[j + 1] {

From 0b965a5e32e9c4adeee9b869c35b355549c9d4bb Mon Sep 17 00:00:00 2001
From: iStig <smartzjm@gmail.com>
Date: Mon, 9 Jan 2023 11:15:26 +0800
Subject: [PATCH 139/158] Update stack.md

---
 docs/chapter_stack_and_queue/stack.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index 8bb343c4f..d5a3f9164 100644
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -906,5 +906,5 @@ comments: true
 
 ## 栈典型应用
 
-- **浏览器中的后退与前进、软件中的撤销与反撤销**。每当我们打开新的网页，浏览器就讲上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。
+- **浏览器中的后退与前进、软件中的撤销与反撤销**。每当我们打开新的网页，浏览器就将上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。
 - **程序内存管理**。每当调用函数时，系统就会在栈顶添加一个栈帧，用来记录函数的上下文信息。在递归函数中，向下递推会不断执行入栈，向上回溯阶段时出栈。

From 2d461b03a4bdc51b0e7185ae9446fb6442d0fe4d Mon Sep 17 00:00:00 2001
From: sjinzh <99076655+sjinzh@users.noreply.github.com>
Date: Mon, 9 Jan 2023 19:31:45 +0800
Subject: [PATCH 140/158] add zig codes for Section 'Space Complexity' and
 'Space Time Tradeoff'

---
 codes/zig/build.zig                           |  95 +++++++------
 .../space_complexity.zig                      | 125 ++++++++++++++++++
 codes/zig/include/ListNode.zig                |  20 +++
 codes/zig/include/PrintUtil.zig               |  69 +++++++++-
 codes/zig/include/TreeNode.zig                |  21 +++
 codes/zig/include/include.zig                 |   6 +-
 6 files changed, 292 insertions(+), 44 deletions(-)
 create mode 100644 codes/zig/chapter_computational_complexity/space_complexity.zig
 create mode 100644 codes/zig/include/ListNode.zig
 create mode 100644 codes/zig/include/TreeNode.zig

diff --git a/codes/zig/build.zig b/codes/zig/build.zig
index b04b3fd18..e72ca4a53 100644
--- a/codes/zig/build.zig
+++ b/codes/zig/build.zig
@@ -1,46 +1,67 @@
+// File: build.zig
+// Created Time: 2023-01-07
+// Author: sjinzh (sjinzh@gmail.com)
+
 const std = @import("std");
 
-// zig version 0.10.0
+// Zig Version: 0.10.0
+// Zig Codes Build Command: zig build
 pub fn build(b: *std.build.Builder) void {
     const target = b.standardTargetOptions(.{});
     const mode = b.standardReleaseOptions();
 
-    // "chapter_computational_complexity/time_complexity.zig"
-    // Run Command: zig build run_time_complexity
-    const exe_time_complexity = b.addExecutable("time_complexity", "chapter_computational_complexity/time_complexity.zig");
-    exe_time_complexity.addPackagePath("include", "include/include.zig");
-    exe_time_complexity.setTarget(target);
-    exe_time_complexity.setBuildMode(mode);
-    exe_time_complexity.install();
-    const run_cmd_time_complexity = exe_time_complexity.run();
-    run_cmd_time_complexity.step.dependOn(b.getInstallStep());
-    if (b.args) |args| run_cmd_time_complexity.addArgs(args);
-    const run_step_time_complexity = b.step("run_time_complexity", "Run time_complexity");
-    run_step_time_complexity.dependOn(&run_cmd_time_complexity.step);
+    // Section: "Time Complexity"
+        // File: "chapter_computational_complexity/time_complexity.zig"
+        // Run Command: zig build run_time_complexity
+        const exe_time_complexity = b.addExecutable("time_complexity", "chapter_computational_complexity/time_complexity.zig");
+        exe_time_complexity.addPackagePath("include", "include/include.zig");
+        exe_time_complexity.setTarget(target);
+        exe_time_complexity.setBuildMode(mode);
+        exe_time_complexity.install();
+        const run_cmd_time_complexity = exe_time_complexity.run();
+        run_cmd_time_complexity.step.dependOn(b.getInstallStep());
+        if (b.args) |args| run_cmd_time_complexity.addArgs(args);
+        const run_step_time_complexity = b.step("run_time_complexity", "Run time_complexity");
+        run_step_time_complexity.dependOn(&run_cmd_time_complexity.step);
 
-    // "chapter_computational_complexity/worst_best_time_complexity.zig"
-    // Run Command: zig build run_worst_best_time_complexity
-    const exe_worst_best_time_complexity = b.addExecutable("worst_best_time_complexity", "chapter_computational_complexity/worst_best_time_complexity.zig");
-    exe_worst_best_time_complexity.addPackagePath("include", "include/include.zig");
-    exe_worst_best_time_complexity.setTarget(target);
-    exe_worst_best_time_complexity.setBuildMode(mode);
-    exe_worst_best_time_complexity.install();
-    const run_cmd_worst_best_time_complexity = exe_worst_best_time_complexity.run();
-    run_cmd_worst_best_time_complexity.step.dependOn(b.getInstallStep());
-    if (b.args) |args| run_cmd_worst_best_time_complexity.addArgs(args);
-    const run_step_worst_best_time_complexity = b.step("run_worst_best_time_complexity", "Run worst_best_time_complexity");
-    run_step_worst_best_time_complexity.dependOn(&run_cmd_worst_best_time_complexity.step);
+        // File: "chapter_computational_complexity/worst_best_time_complexity.zig"
+        // Run Command: zig build run_worst_best_time_complexity
+        const exe_worst_best_time_complexity = b.addExecutable("worst_best_time_complexity", "chapter_computational_complexity/worst_best_time_complexity.zig");
+        exe_worst_best_time_complexity.addPackagePath("include", "include/include.zig");
+        exe_worst_best_time_complexity.setTarget(target);
+        exe_worst_best_time_complexity.setBuildMode(mode);
+        exe_worst_best_time_complexity.install();
+        const run_cmd_worst_best_time_complexity = exe_worst_best_time_complexity.run();
+        run_cmd_worst_best_time_complexity.step.dependOn(b.getInstallStep());
+        if (b.args) |args| run_cmd_worst_best_time_complexity.addArgs(args);
+        const run_step_worst_best_time_complexity = b.step("run_worst_best_time_complexity", "Run worst_best_time_complexity");
+        run_step_worst_best_time_complexity.dependOn(&run_cmd_worst_best_time_complexity.step);
 
-    // "chapter_computational_complexity/leetcode_two_sum.zig"
-    // Run Command: zig build run_leetcode_two_sum
-    const exe_leetcode_two_sum = b.addExecutable("leetcode_two_sum", "chapter_computational_complexity/leetcode_two_sum.zig");
-    exe_leetcode_two_sum.addPackagePath("include", "include/include.zig");
-    exe_leetcode_two_sum.setTarget(target);
-    exe_leetcode_two_sum.setBuildMode(mode);
-    exe_leetcode_two_sum.install();
-    const run_cmd_leetcode_two_sum = exe_leetcode_two_sum.run();
-    run_cmd_leetcode_two_sum.step.dependOn(b.getInstallStep());
-    if (b.args) |args| run_cmd_leetcode_two_sum.addArgs(args);
-    const run_step_leetcode_two_sum = b.step("run_leetcode_two_sum", "Run leetcode_two_sum");
-    run_step_leetcode_two_sum.dependOn(&run_cmd_leetcode_two_sum.step);
+    // Section: "Space Complexity"
+        // File: "chapter_computational_complexity/space_complexity.zig"
+        // Run Command: zig build run_space_complexity
+        const exe_space_complexity = b.addExecutable("space_complexity", "chapter_computational_complexity/space_complexity.zig");
+        exe_space_complexity.addPackagePath("include", "include/include.zig");
+        exe_space_complexity.setTarget(target);
+        exe_space_complexity.setBuildMode(mode);
+        exe_space_complexity.install();
+        const run_cmd_space_complexity = exe_space_complexity.run();
+        run_cmd_space_complexity.step.dependOn(b.getInstallStep());
+        if (b.args) |args| run_cmd_space_complexity.addArgs(args);
+        const run_step_space_complexity = b.step("run_space_complexity", "Run space_complexity");
+        run_step_space_complexity.dependOn(&run_cmd_space_complexity.step);
+
+    // Section: "Space Time Tradeoff"
+        // File: "chapter_computational_complexity/leetcode_two_sum.zig"
+        // Run Command: zig build run_leetcode_two_sum
+        const exe_leetcode_two_sum = b.addExecutable("leetcode_two_sum", "chapter_computational_complexity/leetcode_two_sum.zig");
+        exe_leetcode_two_sum.addPackagePath("include", "include/include.zig");
+        exe_leetcode_two_sum.setTarget(target);
+        exe_leetcode_two_sum.setBuildMode(mode);
+        exe_leetcode_two_sum.install();
+        const run_cmd_leetcode_two_sum = exe_leetcode_two_sum.run();
+        run_cmd_leetcode_two_sum.step.dependOn(b.getInstallStep());
+        if (b.args) |args| run_cmd_leetcode_two_sum.addArgs(args);
+        const run_step_leetcode_two_sum = b.step("run_leetcode_two_sum", "Run leetcode_two_sum");
+        run_step_leetcode_two_sum.dependOn(&run_cmd_leetcode_two_sum.step);
 }
diff --git a/codes/zig/chapter_computational_complexity/space_complexity.zig b/codes/zig/chapter_computational_complexity/space_complexity.zig
new file mode 100644
index 000000000..9798821a5
--- /dev/null
+++ b/codes/zig/chapter_computational_complexity/space_complexity.zig
@@ -0,0 +1,125 @@
+// File: space_complexity.zig
+// Created Time: 2023-01-07
+// Author: sjinzh (sjinzh@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// 函数
+fn function() i32 {
+    // do something
+    return 0;
+}
+
+// 常数阶
+fn constant(n: i32) void {
+    // 常量、变量、对象占用 O(1) 空间
+    const a: i32 = 0;
+    var b: i32 = 0;
+    var nums = [_]i32{0}**10000;
+    var node = inc.ListNode(i32){.val = 0};
+    var i: i32 = 0;
+    // 循环中的变量占用 O(1) 空间
+    while (i < n) : (i += 1) {
+        var c: i32 = 0;
+        _ = c;
+    }
+    // 循环中的函数占用 O(1) 空间
+    i = 0;
+    while (i < n) : (i += 1) {
+        _ = function();
+    }
+    _ = a;
+    _ = b;
+    _ = nums;
+    _ = node;
+}
+
+// 线性阶
+fn linear(comptime n: i32) !void {
+    // 长度为 n 的数组占用 O(n) 空间
+    var nums = [_]i32{0}**n;
+    // 长度为 n 的列表占用 O(n) 空间
+    var nodes = std.ArrayList(i32).init(std.heap.page_allocator);
+    defer nodes.deinit();
+    var i: i32 = 0;
+    while (i < n) : (i += 1) {
+        try nodes.append(i);
+    }
+    // 长度为 n 的哈希表占用 O(n) 空间
+    var map = std.AutoArrayHashMap(i32, []const u8).init(std.heap.page_allocator);
+    defer map.deinit();
+    var j: i32 = 0;
+    while (j < n) : (j += 1) {
+        const string = try std.fmt.allocPrint(std.heap.page_allocator, "{d}", .{j});
+        defer std.heap.page_allocator.free(string);
+        try map.put(i, string);
+    }
+    _ = nums;
+}
+
+// 线性阶（递归实现）
+fn linearRecur(comptime n: i32) void {
+    std.debug.print("递归 n = {}\n", .{n});
+    if (n == 1) return;
+    linearRecur(n - 1);
+}
+
+// 平方阶
+fn quadratic(n: i32) !void {
+    // 二维列表占用 O(n^2) 空间
+    var nodes = std.ArrayList(std.ArrayList(i32)).init(std.heap.page_allocator);
+    defer nodes.deinit();
+    var i: i32 = 0;
+    while (i < n) : (i += 1) {
+        var tmp = std.ArrayList(i32).init(std.heap.page_allocator);
+        defer tmp.deinit();
+        var j: i32 = 0;
+        while (j < n) : (j += 1) {
+            try tmp.append(0);
+        }
+        try nodes.append(tmp);
+    }
+}
+
+// 平方阶（递归实现）
+fn quadraticRecur(comptime n: i32) i32 {
+    if (n <= 0) return 0;
+    var nums = [_]i32{0}**n;
+    std.debug.print("递归 n = {} 中的 nums 长度 = {}\n", .{n, nums.len});
+    return quadraticRecur(n - 1);
+}
+
+// 指数阶（建立满二叉树）
+fn buildTree(mem_allocator: std.mem.Allocator, n: i32) !?*inc.TreeNode(i32) {
+    if (n == 0) return null;
+    const root = try mem_allocator.create(inc.TreeNode(i32));
+    root.init(0);
+    root.left = try buildTree(mem_allocator, n - 1);
+    root.right = try buildTree(mem_allocator, n - 1);
+    return root;
+}
+
+// Driver Code
+pub fn main() !void {
+    const n: i32 = 5;
+    // 常数阶
+    constant(n);
+    // 线性阶
+    try linear(n);
+    linearRecur(n);
+    // 平方阶
+    try quadratic(n);
+    _ = quadraticRecur(n);
+    // 指数阶
+    var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer mem_arena.deinit();
+    var root = blk_root: {
+        const mem_allocator = mem_arena.allocator();
+        break :blk_root try buildTree(mem_allocator, n);
+    };
+    try inc.PrintUtil.printTree(root, null, false);
+
+    const getchar = try std.io.getStdIn().reader().readByte();
+    _ = getchar;
+}
\ No newline at end of file
diff --git a/codes/zig/include/ListNode.zig b/codes/zig/include/ListNode.zig
new file mode 100644
index 000000000..8ce01d3ed
--- /dev/null
+++ b/codes/zig/include/ListNode.zig
@@ -0,0 +1,20 @@
+// File: ListNode.zig
+// Created Time: 2023-01-07
+// Author: sjinzh (sjinzh@gmail.com)
+
+const std = @import("std");
+
+// Definition for a singly-linked list node
+pub fn ListNode(comptime T: type) type {
+    return struct {
+        const Self = @This();
+        
+        val: T = 0,
+        next: ?*Self = null,
+
+        // Initialize a list node with specific value
+        pub fn init(self: *Self, x: i32) void {
+            self.val = x;
+        }
+    };
+}
\ No newline at end of file
diff --git a/codes/zig/include/PrintUtil.zig b/codes/zig/include/PrintUtil.zig
index 5adac2a6e..8a7dca7af 100644
--- a/codes/zig/include/PrintUtil.zig
+++ b/codes/zig/include/PrintUtil.zig
@@ -1,13 +1,72 @@
-// File: TreeNode.zig
+// File: PrintUtil.zig
 // Created Time: 2023-01-07
 // Author: sjinzh (sjinzh@gmail.com)
 
 const std = @import("std");
+const ListNode = @import("ListNode.zig").ListNode;
+const TreeNode = @import("TreeNode.zig").TreeNode;
 
-// Print an Array
+// Print an array
 pub fn printArray(comptime T: type, nums: []T) void {
     std.debug.print("[", .{});
-    for (nums) |num, j| {
-        std.debug.print("{}{s}", .{num, if (j == nums.len-1) "]\n" else ", " });
-     }
+    if (nums.len > 0) {
+        for (nums) |num, j| {
+            std.debug.print("{}{s}", .{num, if (j == nums.len-1) "]\n" else ", " });
+        }
+    } else {
+        std.debug.print("]", .{});
+        std.debug.print("\n", .{});
+    }
 }
+
+// This tree printer is borrowed from TECHIE DELIGHT
+// https://www.techiedelight.com/c-program-print-binary-tree/
+const Trunk = struct {
+    prev: ?*Trunk = null,
+    str: []const u8 = undefined,
+    
+    pub fn init(self: *Trunk, prev: ?*Trunk, str: []const u8) void {
+        self.prev = prev;
+        self.str = str;
+    }
+};
+
+// Helper function to print branches of the binary tree
+pub fn showTrunks(p: ?*Trunk) void {
+    if (p == null) return;
+    showTrunks(p.?.prev);
+    std.debug.print("{s}", .{p.?.str});
+}
+
+// The interface of the tree printer
+// Print a binary tree
+pub fn printTree(root: ?*TreeNode(i32), prev: ?*Trunk, isLeft: bool) !void {
+    if (root == null) {
+        return;
+    }
+
+    var prev_str = "    ";
+    var trunk = Trunk{.prev = prev, .str = prev_str};
+
+    try printTree(root.?.right, &trunk, true);
+   
+    if (prev == null) {
+        trunk.str = "———";
+    } else if (isLeft) {
+        trunk.str = "/———";
+        prev_str = "   |";
+    } else {
+        trunk.str = "\\———";
+        prev.?.str = prev_str;
+    }
+
+    showTrunks(&trunk);
+    std.debug.print(" {}\n", .{root.?.val});
+
+    if (prev) |_| {
+        prev.?.str = prev_str;
+    }
+    trunk.str = "   |";
+
+    try printTree(root.?.left, &trunk, false);
+}
\ No newline at end of file
diff --git a/codes/zig/include/TreeNode.zig b/codes/zig/include/TreeNode.zig
new file mode 100644
index 000000000..9bd51ba3d
--- /dev/null
+++ b/codes/zig/include/TreeNode.zig
@@ -0,0 +1,21 @@
+// File: TreeNode.zig
+// Created Time: 2023-01-07
+// Author: sjinzh (sjinzh@gmail.com)
+
+const std = @import("std");
+
+// Definition for a binary tree node
+pub fn TreeNode(comptime T: type) type {
+    return struct {
+        const Self = @This();
+
+        val: T = undefined,
+        left: ?*Self = null,
+        right: ?*Self = null,
+
+        // Initialize a tree node with specific value
+        pub fn init(self: *Self, x: i32) void {
+            self.val = x;
+        }
+    };   
+}
\ No newline at end of file
diff --git a/codes/zig/include/include.zig b/codes/zig/include/include.zig
index b4f347821..20dfca90f 100644
--- a/codes/zig/include/include.zig
+++ b/codes/zig/include/include.zig
@@ -1,5 +1,7 @@
 // File: include.zig
-// Created Time: 2023-01-04
+// Created Time: 2023-01-07
 // Author: sjinzh (sjinzh@gmail.com)
 
-pub const PrintUtil = @import("PrintUtil.zig");
\ No newline at end of file
+pub const PrintUtil = @import("PrintUtil.zig");
+pub const ListNode = @import("ListNode.zig").ListNode;
+pub const TreeNode = @import("TreeNode.zig").TreeNode;
\ No newline at end of file

From aaa2ff29f93f6ea1cae4021241344276f006e854 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Mon, 9 Jan 2023 22:39:30 +0800
Subject: [PATCH 141/158] Fix all the ** (bolded symbols).

---
 docs/chapter_array_and_linkedlist/array.md    |  6 ++--
 docs/chapter_array_and_linkedlist/list.md     |  6 ++--
 .../performance_evaluation.md                 |  6 ++--
 .../space_complexity.md                       |  2 +-
 .../classification_of_data_structure.md       | 10 +++---
 .../chapter_data_structure/data_and_memory.md |  2 +-
 docs/chapter_hashing/hash_collision.md        | 14 ++++----
 docs/chapter_hashing/hash_map.md              |  8 ++---
 docs/chapter_preface/about_the_book.md        |  6 ++--
 docs/chapter_preface/suggestions.md           |  2 +-
 docs/chapter_searching/binary_search.md       |  6 ++--
 docs/chapter_searching/hashing_search.md      |  4 +--
 docs/chapter_searching/linear_search.md       |  4 +--
 docs/chapter_sorting/bubble_sort.md           | 10 +++---
 docs/chapter_sorting/insertion_sort.md        | 12 +++----
 docs/chapter_sorting/intro_to_sort.md         |  4 +--
 docs/chapter_sorting/merge_sort.md            | 22 ++++++-------
 docs/chapter_sorting/quick_sort.md            | 32 +++++++++----------
 docs/chapter_tree/avl_tree.md                 |  4 +--
 docs/chapter_tree/binary_search_tree.md       | 26 +++++++--------
 20 files changed, 93 insertions(+), 93 deletions(-)

diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 2cf096137..2251362d0 100644
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -356,9 +356,9 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 **数组中插入或删除元素效率低下**。假设我们想要在数组中间某位置插入一个元素，由于数组元素在内存中是“紧挨着的”，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。删除元素也是类似，需要把此索引之后的元素都向前移动一位。总体看有以下缺点：
 
-- **时间复杂度高：** 数组的插入和删除的平均时间复杂度均为 $O(N)$ ，其中 $N$ 为数组长度。
-- **丢失元素：** 由于数组的长度不可变，因此在插入元素后，超出数组长度范围的元素会被丢失。
-- **内存浪费：** 我们一般会初始化一个比较长的数组，只用前面一部分，这样在插入数据时，丢失的末尾元素都是我们不关心的，但这样做同时也会造成内存空间的浪费。
+- **时间复杂度高**：数组的插入和删除的平均时间复杂度均为 $O(N)$ ，其中 $N$ 为数组长度。
+- **丢失元素**：由于数组的长度不可变，因此在插入元素后，超出数组长度范围的元素会被丢失。
+- **内存浪费**：我们一般会初始化一个比较长的数组，只用前面一部分，这样在插入数据时，丢失的末尾元素都是我们不关心的，但这样做同时也会造成内存空间的浪费。
 
 ![array_insert_remove_element](array.assets/array_insert_remove_element.png)
 
diff --git a/docs/chapter_array_and_linkedlist/list.md b/docs/chapter_array_and_linkedlist/list.md
index ca4774a04..a02ede876 100644
--- a/docs/chapter_array_and_linkedlist/list.md
+++ b/docs/chapter_array_and_linkedlist/list.md
@@ -599,9 +599,9 @@ comments: true
 
 为了帮助加深对列表的理解，我们在此提供一个列表的简易版本的实现。需要关注三个核心点：
 
-- **初始容量：** 选取一个合理的数组的初始容量 `initialCapacity` 。在本示例中，我们选择 10 作为初始容量。
-- **数量记录：** 需要声明一个变量 `size` ，用来记录列表当前有多少个元素，并随着元素插入与删除实时更新。根据此变量，可以定位列表的尾部，以及判断是否需要扩容。
-- **扩容机制：** 插入元素有可能导致超出列表容量，此时需要扩容列表，方法是建立一个更大的数组来替换当前数组。需要给定一个扩容倍数 `extendRatio` ，在本示例中，我们规定每次将数组扩容至之前的 2 倍。
+- **初始容量**：选取一个合理的数组的初始容量 `initialCapacity` 。在本示例中，我们选择 10 作为初始容量。
+- **数量记录**：需要声明一个变量 `size` ，用来记录列表当前有多少个元素，并随着元素插入与删除实时更新。根据此变量，可以定位列表的尾部，以及判断是否需要扩容。
+- **扩容机制**：插入元素有可能导致超出列表容量，此时需要扩容列表，方法是建立一个更大的数组来替换当前数组。需要给定一个扩容倍数 `extendRatio` ，在本示例中，我们规定每次将数组扩容至之前的 2 倍。
 
 本示例是为了帮助读者对如何实现列表产生直观的认识。实际编程语言中，列表的实现远比以下代码复杂且标准，感兴趣的读者可以查阅源码学习。
 
diff --git a/docs/chapter_computational_complexity/performance_evaluation.md b/docs/chapter_computational_complexity/performance_evaluation.md
index f75b4d8d4..9d6fd6628 100644
--- a/docs/chapter_computational_complexity/performance_evaluation.md
+++ b/docs/chapter_computational_complexity/performance_evaluation.md
@@ -13,8 +13,8 @@ comments: true
 
 换言之，在可以解决问题的前提下，算法效率则是主要评价维度，包括：
 
-- **时间效率** ，即算法的运行速度的快慢。
-- **空间效率** ，即算法占用的内存空间大小。
+- **时间效率**，即算法的运行速度的快慢。
+- **空间效率**，即算法占用的内存空间大小。
 
 数据结构与算法追求“运行速度快、占用内存少”，而如何去评价算法效率则是非常重要的问题，因为只有知道如何评价算法，才能去做算法之间的对比分析，以及优化算法设计。
 
@@ -32,7 +32,7 @@ comments: true
 
 既然实际测试具有很大的局限性，那么我们是否可以仅通过一些计算，就获知算法的效率水平呢？答案是肯定的，我们将此估算方法称为「复杂度分析 Complexity Analysis」或「渐近复杂度分析 Asymptotic Complexity Analysis」。
 
-**复杂度分析评估随着输入数据量的增长，算法的运行时间和占用空间的增长趋势** 。根据时间和空间两方面，复杂度可分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。
+**复杂度分析评估随着输入数据量的增长，算法的运行时间和占用空间的增长趋势**。根据时间和空间两方面，复杂度可分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。
 
 **复杂度分析克服了实际测试方法的弊端**。一是独立于测试环境，分析结果适用于所有运行平台。二是可以体现不同数据量下的算法效率，尤其是可以反映大数据量下的算法性能。
 
diff --git a/docs/chapter_computational_complexity/space_complexity.md b/docs/chapter_computational_complexity/space_complexity.md
index 6686aac50..e594bec8d 100644
--- a/docs/chapter_computational_complexity/space_complexity.md
+++ b/docs/chapter_computational_complexity/space_complexity.md
@@ -4,7 +4,7 @@ comments: true
 
 # 空间复杂度
 
-「空间复杂度 Space Complexity」统计 **算法使用内存空间随着数据量变大时的增长趋势** 。这个概念与时间复杂度很类似。
+「空间复杂度 Space Complexity」统计 **算法使用内存空间随着数据量变大时的增长趋势**。这个概念与时间复杂度很类似。
 
 ## 算法相关空间
 
diff --git a/docs/chapter_data_structure/classification_of_data_structure.md b/docs/chapter_data_structure/classification_of_data_structure.md
index 749542eb9..202af50a2 100644
--- a/docs/chapter_data_structure/classification_of_data_structure.md
+++ b/docs/chapter_data_structure/classification_of_data_structure.md
@@ -12,8 +12,8 @@ comments: true
 
 我们一般将逻辑结构分为「线性」和「非线性」两种。“线性”这个概念很直观，即表明数据在逻辑关系上是排成一条线的；而如果数据之间的逻辑关系是非线形的（例如是网状或树状的），那么就是非线性数据结构。
 
-- **线性数据结构：** 数组、链表、栈、队列、哈希表；
-- **非线性数据结构：** 树、图、堆、哈希表；
+- **线性数据结构**：数组、链表、栈、队列、哈希表；
+- **非线性数据结构**：树、图、堆、哈希表；
 
 ![classification_logic_structure](classification_of_data_structure.assets/classification_logic_structure.png)
 
@@ -25,7 +25,7 @@ comments: true
 
     若感到阅读困难，建议先看完下个章节「数组与链表」，再回过头来理解物理结构的含义。
 
-**「物理结构」反映了数据在计算机内存中的存储方式**。从本质上看，分别是 **数组的连续空间存储** 和 **链表的离散空间存储** 。物理结构从底层上决定了数据的访问、更新、增删等操作方法，在时间效率和空间效率方面呈现出此消彼长的特性。
+**「物理结构」反映了数据在计算机内存中的存储方式**。从本质上看，分别是 **数组的连续空间存储** 和 **链表的离散空间存储**。物理结构从底层上决定了数据的访问、更新、增删等操作方法，在时间效率和空间效率方面呈现出此消彼长的特性。
 
 ![classification_phisical_structure](classification_of_data_structure.assets/classification_phisical_structure.png)
 
@@ -33,8 +33,8 @@ comments: true
 
 **所有数据结构都是基于数组、或链表、或两者组合实现的**。例如栈和队列，既可以使用数组实现、也可以使用链表实现，而例如哈希表，其实现同时包含了数组和链表。
 
-- **基于数组可实现：** 栈、队列、堆、哈希表、矩阵、张量（维度 $\geq 3$ 的数组）等；
-- **基于链表可实现：** 栈、队列、堆、哈希表、树、图等；
+- **基于数组可实现**：栈、队列、堆、哈希表、矩阵、张量（维度 $\geq 3$ 的数组）等；
+- **基于链表可实现**：栈、队列、堆、哈希表、树、图等；
 
 基于数组实现的数据结构也被称为「静态数据结构」，这意味着该数据结构在在被初始化后，长度不可变。相反地，基于链表实现的数据结构被称为「动态数据结构」，该数据结构在被初始化后，我们也可以在程序运行中修改其长度。
 
diff --git a/docs/chapter_data_structure/data_and_memory.md b/docs/chapter_data_structure/data_and_memory.md
index 59cb74e45..93147fb65 100644
--- a/docs/chapter_data_structure/data_and_memory.md
+++ b/docs/chapter_data_structure/data_and_memory.md
@@ -42,7 +42,7 @@ comments: true
 
 **「基本数据类型」与「数据结构」之间的联系与区别**
 
-我们知道，数据结构是在计算机中 **组织与存储数据的方式** ，它的主语是“结构”，而不是“数据”。比如，我们想要表示“一排数字”，自然应该使用「数组」这个数据结构。数组的存储方式使之可以表示数字的相邻关系、先后关系等一系列我们需要的信息，但至于其中存储的是整数 int ，还是小数 float ，或是字符 char ，**则与所谓的数据的结构无关了**。
+我们知道，数据结构是在计算机中 **组织与存储数据的方式**，它的主语是“结构”，而不是“数据”。比如，我们想要表示“一排数字”，自然应该使用「数组」这个数据结构。数组的存储方式使之可以表示数字的相邻关系、先后关系等一系列我们需要的信息，但至于其中存储的是整数 int ，还是小数 float ，或是字符 char ，**则与所谓的数据的结构无关了**。
 
 === "Java"
 
diff --git a/docs/chapter_hashing/hash_collision.md b/docs/chapter_hashing/hash_collision.md
index 05dc20881..45a529970 100644
--- a/docs/chapter_hashing/hash_collision.md
+++ b/docs/chapter_hashing/hash_collision.md
@@ -24,9 +24,9 @@ comments: true
 
 在原始哈希表中，一个桶地址只能存储一个元素（即键值对）。**考虑将桶地址内的单个元素转变成一个链表，将所有冲突元素都存储在一个链表中**，此时哈希表操作方法为：
 
-- **查询元素：** 先将 key 输入到哈希函数得到桶地址（即访问链表头部），再遍历链表来确定对应的 value 。
-- **添加元素：** 先通过哈希函数访问链表头部，再将元素直接添加到链表头部即可。
-- **删除元素：** 同样先访问链表头部，再遍历链表查找对应元素，删除之即可。
+- **查询元素**：先将 key 输入到哈希函数得到桶地址（即访问链表头部），再遍历链表来确定对应的 value 。
+- **添加元素**：先通过哈希函数访问链表头部，再将元素直接添加到链表头部即可。
+- **删除元素**：同样先访问链表头部，再遍历链表查找对应元素，删除之即可。
 
 （图）
 
@@ -46,9 +46,9 @@ comments: true
 
 「线性探测」使用固定步长的线性查找来解决哈希冲突。
 
-**插入元素：** 如果出现哈希冲突，则从冲突位置向后线性遍历（步长一般取 1 ），直到找到一个空位，则将元素插入到该空位中。
+**插入元素**：如果出现哈希冲突，则从冲突位置向后线性遍历（步长一般取 1 ），直到找到一个空位，则将元素插入到该空位中。
 
-**查找元素：** 若出现哈希冲突，则使用相同步长执行线性查找，会遇到两种情况：
+**查找元素**：若出现哈希冲突，则使用相同步长执行线性查找，会遇到两种情况：
 
 1. 找到对应元素，返回 value 即可；
 2. 若遇到空位，则说明查找键值对不在哈希表中；
@@ -64,9 +64,9 @@ comments: true
 
 顾名思义，「多次哈希」的思路是基于多个哈希函数 $f_1(x)$ , $f_2(x)$ , $f_3(x)$ , $\cdots$ 进行探测。
 
-**插入元素：** 若哈希函数 $f_1(x)$ 出现冲突，则尝试 $f_2(x)$ ，以此类推……直到找到空位后插入元素。
+**插入元素**：若哈希函数 $f_1(x)$ 出现冲突，则尝试 $f_2(x)$ ，以此类推……直到找到空位后插入元素。
 
-**查找元素：** 以相同的哈希函数顺序查找，存在两种情况：
+**查找元素**：以相同的哈希函数顺序查找，存在两种情况：
 
 1. 找到目标元素，则返回之；
 2. 到空位或已尝试所有哈希函数，说明哈希表中无此元素；
diff --git a/docs/chapter_hashing/hash_map.md b/docs/chapter_hashing/hash_map.md
index 2d8a66a5d..cbb4ba049 100644
--- a/docs/chapter_hashing/hash_map.md
+++ b/docs/chapter_hashing/hash_map.md
@@ -16,10 +16,10 @@ comments: true
 
 除了哈希表之外，还可以使用以下数据结构来实现上述查询功能：
 
-1. **无序数组：** 每个元素为  `[学号, 姓名]` ；
-2. **有序数组：** 将 `1.` 中的数组按照学号从小到大排序；
-3. **链表：** 每个结点的值为 `[学号, 姓名]` ；
-4. **二叉搜索树：** 每个结点的值为 `[学号, 姓名]` ，根据学号大小来构建树；
+1. **无序数组**：每个元素为  `[学号, 姓名]` ；
+2. **有序数组**：将 `1.` 中的数组按照学号从小到大排序；
+3. **链表**：每个结点的值为 `[学号, 姓名]` ；
+4. **二叉搜索树**：每个结点的值为 `[学号, 姓名]` ，根据学号大小来构建树；
 
 使用上述方法，各项操作的时间复杂度如下表所示（在此不做赘述，详解可见 [二叉搜索树章节](https://www.hello-algo.com/chapter_tree/binary_search_tree/#_6)）。无论是查找元素、还是增删元素，哈希表的时间复杂度都是 $O(1)$ ，全面胜出！
 
diff --git a/docs/chapter_preface/about_the_book.md b/docs/chapter_preface/about_the_book.md
index 2fba23502..c3209280c 100644
--- a/docs/chapter_preface/about_the_book.md
+++ b/docs/chapter_preface/about_the_book.md
@@ -44,13 +44,13 @@ comments: true
 
 首先介绍数据结构与算法的评价维度、算法效率的评估方法，引出了计算复杂度概念。
 
-接下来，从 **函数渐近上界** 入手，分别介绍了 **时间复杂度** 和 **空间复杂度** ，包括推算方法、常见类型、示例等。同时，剖析了 **最差、最佳、平均** 时间复杂度的联系与区别。
+接下来，从 **函数渐近上界** 入手，分别介绍了 **时间复杂度** 和 **空间复杂度**，包括推算方法、常见类型、示例等。同时，剖析了 **最差、最佳、平均** 时间复杂度的联系与区别。
 
 ### 数据结构
 
 首先介绍了常用的 **基本数据类型** 、以及它们是如何在内存中存储的。
 
-接下来，介绍了两种 **数据结构分类方法** ，包括逻辑结构与物理结构。
+接下来，介绍了两种 **数据结构分类方法**，包括逻辑结构与物理结构。
 
 后续展开介绍了 **数组、链表、栈、队列、散列表、树、堆、图** 等数据结构，关心以下内容：
 
@@ -84,7 +84,7 @@ comments: true
 
 - 标题后标注 * 符号的是选读章节，如果你的时间有限，可以先跳过这些章节。
 - 文章中的重要名词会用「」符号标注，例如「数组 Array」。名词混淆会导致不必要的歧义，因此最好可以记住这类名词（包括中文和英文），以便后续阅读文献时使用。
-- 重点内容、总起句、总结句会被 **加粗** ，此类文字值得特别关注。
+- 重点内容、总起句、总结句会被 **加粗**，此类文字值得特别关注。
 - 专有名词和有特指含义的词句会使用 “ ” 标注，以避免歧义。
 - 在工程应用中，每种语言都有注释规范；而本书放弃了一部分的注释规范性，以换取更加紧凑的内容排版。注释主要分为三种类型：标题注释、内容注释、多行注释。
 
diff --git a/docs/chapter_preface/suggestions.md b/docs/chapter_preface/suggestions.md
index d4dbd24bc..b2e18905f 100644
--- a/docs/chapter_preface/suggestions.md
+++ b/docs/chapter_preface/suggestions.md
@@ -32,7 +32,7 @@ git clone https://github.com/krahets/hello-algo.git
 
 ### 运行源代码
 
-本书提供配套 Java, C++, Python 代码仓（后续可能拓展支持语言）。书中的代码栏上若标有 `*.java` , `*.cpp` , `*.py` ，则可在仓库 codes 文件夹中找到对应的 **代码源文件** 。
+本书提供配套 Java, C++, Python 代码仓（后续可能拓展支持语言）。书中的代码栏上若标有 `*.java` , `*.cpp` , `*.py` ，则可在仓库 codes 文件夹中找到对应的 **代码源文件**。
 
 ![code_md_to_repo](suggestions.assets/code_md_to_repo.png)
 
diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
index 466e76658..2bd2d4396 100644
--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@@ -9,7 +9,7 @@ comments: true
 使用二分查找有两个前置条件：
 
 - **要求输入数据是有序的**，这样才能通过判断大小关系来排除一半的搜索区间；
-- **二分查找仅适用于数组** ，而在链表中使用效率很低，因为其在循环中需要跳跃式（非连续地）访问元素。
+- **二分查找仅适用于数组**，而在链表中使用效率很低，因为其在循环中需要跳跃式（非连续地）访问元素。
 
 ## 算法实现
 
@@ -480,9 +480,9 @@ $$
 
 ## 复杂度分析
 
-**时间复杂度 $O(\log n)$ ：** 其中 $n$ 为数组或链表长度；每轮排除一半的区间，因此循环轮数为 $\log_2 n$ ，使用 $O(\log n)$ 时间。
+**时间复杂度 $O(\log n)$** ：其中 $n$ 为数组或链表长度；每轮排除一半的区间，因此循环轮数为 $\log_2 n$ ，使用 $O(\log n)$ 时间。
 
-**空间复杂度 $O(1)$ ：** 指针 `i` , `j` 使用常数大小空间。
+**空间复杂度 $O(1)$** ：指针 `i` , `j` 使用常数大小空间。
 
 ## 优点与缺点
 
diff --git a/docs/chapter_searching/hashing_search.md b/docs/chapter_searching/hashing_search.md
index 12746d2ef..076457303 100644
--- a/docs/chapter_searching/hashing_search.md
+++ b/docs/chapter_searching/hashing_search.md
@@ -193,9 +193,9 @@ comments: true
 
 ## 复杂度分析
 
-**时间复杂度：** $O(1)$ ，哈希表的查找操作使用 $O(1)$ 时间。
+**时间复杂度 $O(1)$** ：哈希表的查找操作使用 $O(1)$ 时间。
 
-**空间复杂度：** $O(n)$ ，其中 $n$ 为数组或链表长度。
+**空间复杂度 $O(n)$** ：其中 $n$ 为数组或链表长度。
 
 ## 优点与缺点
 
diff --git a/docs/chapter_searching/linear_search.md b/docs/chapter_searching/linear_search.md
index be98c013d..d9371ab2c 100644
--- a/docs/chapter_searching/linear_search.md
+++ b/docs/chapter_searching/linear_search.md
@@ -252,9 +252,9 @@ comments: true
 
 ## 复杂度分析
 
-**时间复杂度 $O(n)$ ：** 其中 $n$ 为数组或链表长度。
+**时间复杂度 $O(n)$** ：其中 $n$ 为数组或链表长度。
 
-**空间复杂度 $O(1)$ ：** 无需使用额外空间。
+**空间复杂度 $O(1)$** ：无需使用额外空间。
 
 ## 优点与缺点
 
diff --git a/docs/chapter_sorting/bubble_sort.md b/docs/chapter_sorting/bubble_sort.md
index 1dbc56475..e3e394b20 100644
--- a/docs/chapter_sorting/bubble_sort.md
+++ b/docs/chapter_sorting/bubble_sort.md
@@ -220,15 +220,15 @@ comments: true
 
 ## 算法特性
 
-**时间复杂度 $O(n^2)$ ：** 各轮「冒泡」遍历的数组长度为 $n - 1$ , $n - 2$ , $\cdots$ , $2$ , $1$ 次，求和为 $\frac{(n - 1) n}{2}$ ，因此使用 $O(n^2)$ 时间。
+**时间复杂度 $O(n^2)$** ：各轮「冒泡」遍历的数组长度为 $n - 1$ , $n - 2$ , $\cdots$ , $2$ , $1$ 次，求和为 $\frac{(n - 1) n}{2}$ ，因此使用 $O(n^2)$ 时间。
 
-**空间复杂度 $O(1)$ ：** 指针 $i$ , $j$ 使用常数大小的额外空间。
+**空间复杂度 $O(1)$** ：指针 $i$ , $j$ 使用常数大小的额外空间。
 
-**原地排序：** 指针变量仅使用常数大小额外空间。
+**原地排序**：指针变量仅使用常数大小额外空间。
 
-**稳定排序：** 不交换相等元素。
+**稳定排序**：不交换相等元素。
 
-**自适排序：** 引入 `flag` 优化后（见下文），最佳时间复杂度为 $O(N)$ 。
+**自适排序**：引入 `flag` 优化后（见下文），最佳时间复杂度为 $O(N)$ 。
 
 ## 效率优化
 
diff --git a/docs/chapter_sorting/insertion_sort.md b/docs/chapter_sorting/insertion_sort.md
index 679182f42..05ee7293e 100644
--- a/docs/chapter_sorting/insertion_sort.md
+++ b/docs/chapter_sorting/insertion_sort.md
@@ -183,15 +183,15 @@ comments: true
 
 ## 算法特性
 
-**时间复杂度 $O(n^2)$ ：** 最差情况下，各轮插入操作循环 $n - 1$ , $n-2$ , $\cdots$ , $2$ , $1$ 次，求和为 $\frac{(n - 1) n}{2}$ ，使用 $O(n^2)$ 时间。
+**时间复杂度 $O(n^2)$** ：最差情况下，各轮插入操作循环 $n - 1$ , $n-2$ , $\cdots$ , $2$ , $1$ 次，求和为 $\frac{(n - 1) n}{2}$ ，使用 $O(n^2)$ 时间。
 
-**空间复杂度 $O(1)$ ：** 指针 $i$ , $j$ 使用常数大小的额外空间。
+**空间复杂度 $O(1)$** ：指针 $i$ , $j$ 使用常数大小的额外空间。
 
-**原地排序：** 指针变量仅使用常数大小额外空间。
+**原地排序**：指针变量仅使用常数大小额外空间。
 
-**稳定排序：** 不交换相等元素。
+**稳定排序**：不交换相等元素。
 
-**自适应排序：** 最佳情况下，时间复杂度为 $O(n)$  。
+**自适应排序**：最佳情况下，时间复杂度为 $O(n)$  。
 
 ## 插入排序 vs 冒泡排序
 
@@ -199,7 +199,7 @@ comments: true
 
     虽然「插入排序」和「冒泡排序」的时间复杂度皆为 $O(n^2)$ ，但实际运行速度却有很大差别，这是为什么呢？
 
-回顾复杂度分析，两个方法的循环次数都是 $\frac{(n - 1) n}{2}$ 。但不同的是，「冒泡操作」是在做 **元素交换** ，需要借助一个临时变量实现，共 3 个单元操作；而「插入操作」是在做 **赋值** ，只需 1 个单元操作；因此，可以粗略估计出冒泡排序的计算开销约为插入排序的 3 倍。
+回顾复杂度分析，两个方法的循环次数都是 $\frac{(n - 1) n}{2}$ 。但不同的是，「冒泡操作」是在做 **元素交换**，需要借助一个临时变量实现，共 3 个单元操作；而「插入操作」是在做 **赋值**，只需 1 个单元操作；因此，可以粗略估计出冒泡排序的计算开销约为插入排序的 3 倍。
 
 插入排序运行速度快，并且具有原地、稳定、自适应的优点，因此很受欢迎。实际上，包括 Java 在内的许多编程语言的排序库函数的实现都用到了插入排序。库函数的大致思路：
 
diff --git a/docs/chapter_sorting/intro_to_sort.md b/docs/chapter_sorting/intro_to_sort.md
index a3cb071dc..c4d50c535 100644
--- a/docs/chapter_sorting/intro_to_sort.md
+++ b/docs/chapter_sorting/intro_to_sort.md
@@ -7,7 +7,7 @@ comments: true
 「排序算法 Sorting Algorithm」使得列表中的所有元素按照从小到大的顺序排列。
 
 - 待排序的列表的 **元素类型** 可以是整数、浮点数、字符、或字符串；
-- 排序算法可以根据需要设定 **判断规则** ，例如数字大小、字符 ASCII 码顺序、自定义规则；
+- 排序算法可以根据需要设定 **判断规则**，例如数字大小、字符 ASCII 码顺序、自定义规则；
 
 ![sorting_examples](intro_to_sort.assets/sorting_examples.png)
 
@@ -55,7 +55,7 @@ comments: true
 - 「自适应排序」的时间复杂度受输入数据影响，即最佳 / 最差 / 平均时间复杂度不相等。
 - 「非自适应排序」的时间复杂度恒定，与输入数据无关。
 
-我们希望 **最差 = 平均** ，即不希望排序算法的运行效率在某些输入数据下发生劣化。
+我们希望 **最差 = 平均**，即不希望排序算法的运行效率在某些输入数据下发生劣化。
 
 ### 比较类
 
diff --git a/docs/chapter_sorting/merge_sort.md b/docs/chapter_sorting/merge_sort.md
index ae0cfc7c2..5895fcb8e 100644
--- a/docs/chapter_sorting/merge_sort.md
+++ b/docs/chapter_sorting/merge_sort.md
@@ -6,8 +6,8 @@ comments: true
 
 「归并排序 Merge Sort」是算法中“分治思想”的典型体现，其有「划分」和「合并」两个阶段：
 
-1. **划分阶段：** 通过递归不断 **将数组从中点位置划分开**，将长数组的排序问题转化为短数组的排序问题；
-2. **合并阶段：** 划分到子数组长度为 1 时，开始向上合并，不断将 **左、右两个短排序数组** 合并为 **一个长排序数组**，直至合并至原数组时完成排序；
+1. **划分阶段**：通过递归不断 **将数组从中点位置划分开**，将长数组的排序问题转化为短数组的排序问题；
+2. **合并阶段**：划分到子数组长度为 1 时，开始向上合并，不断将 **左、右两个短排序数组** 合并为 **一个长排序数组**，直至合并至原数组时完成排序；
 
 ![merge_sort_preview](merge_sort.assets/merge_sort_preview.png)
 
@@ -15,14 +15,14 @@ comments: true
 
 ## 算法流程
 
-**「递归划分」** 从顶至底递归地 **将数组从中点切为两个子数组** ，直至长度为 1 ；
+**「递归划分」** 从顶至底递归地 **将数组从中点切为两个子数组**，直至长度为 1 ；
 
 1. 计算数组中点 `mid` ，递归划分左子数组（区间 `[left, mid]` ）和右子数组（区间 `[mid + 1, right]` ）；
 2. 递归执行 `1.` 步骤，直至子数组区间长度为 1 时，终止递归划分；
 
 **「回溯合并」** 从底至顶地将左子数组和右子数组合并为一个 **有序数组** ；
 
-需要注意，由于从长度为 1 的子数组开始合并，所以 **每个子数组都是有序的** 。因此，合并任务本质是要 **将两个有序子数组合并为一个有序数组** 。
+需要注意，由于从长度为 1 的子数组开始合并，所以 **每个子数组都是有序的**。因此，合并任务本质是要 **将两个有序子数组合并为一个有序数组**。
 
 === "Step1"
     ![merge_sort_step1](merge_sort.assets/merge_sort_step1.png)
@@ -56,8 +56,8 @@ comments: true
 
 观察发现，归并排序的递归顺序就是二叉树的「后序遍历」。
 
-- **后序遍历：** 先递归左子树、再递归右子树、最后处理根结点。
-- **归并排序：** 先递归左子树、再递归右子树、最后处理合并。
+- **后序遍历**：先递归左子树、再递归右子树、最后处理根结点。
+- **归并排序**：先递归左子树、再递归右子树、最后处理合并。
 
 === "Java"
 
@@ -406,11 +406,11 @@ comments: true
 
 ## 算法特性
 
-- **时间复杂度 $O(n \log n)$ ：** 划分形成高度为 $\log n$ 的递归树，每层合并的总操作数量为 $n$ ，总体使用 $O(n \log n)$ 时间。
-- **空间复杂度 $O(n)$ ：** 需借助辅助数组实现合并，使用 $O(n)$ 大小的额外空间；递归深度为 $\log n$ ，使用 $O(\log n)$ 大小的栈帧空间。
-- **非原地排序：** 辅助数组需要使用 $O(n)$ 额外空间。
-- **稳定排序：** 在合并时可保证相等元素的相对位置不变。
-- **非自适应排序：** 对于任意输入数据，归并排序的时间复杂度皆相同。
+- **时间复杂度 $O(n \log n)$** ：划分形成高度为 $\log n$ 的递归树，每层合并的总操作数量为 $n$ ，总体使用 $O(n \log n)$ 时间。
+- **空间复杂度 $O(n)$** ：需借助辅助数组实现合并，使用 $O(n)$ 大小的额外空间；递归深度为 $\log n$ ，使用 $O(\log n)$ 大小的栈帧空间。
+- **非原地排序**：辅助数组需要使用 $O(n)$ 额外空间。
+- **稳定排序**：在合并时可保证相等元素的相对位置不变。
+- **非自适应排序**：对于任意输入数据，归并排序的时间复杂度皆相同。
 
 ## 链表排序 *
 
diff --git a/docs/chapter_sorting/quick_sort.md b/docs/chapter_sorting/quick_sort.md
index 3eeac9c65..a712a1bff 100644
--- a/docs/chapter_sorting/quick_sort.md
+++ b/docs/chapter_sorting/quick_sort.md
@@ -6,13 +6,13 @@ comments: true
 
 「快速排序 Quick Sort」是一种基于“分治思想”的排序算法，速度很快、应用很广。
 
-快速排序的核心操作为「哨兵划分」，其目标为：选取数组某个元素为 **基准数** ，将所有小于基准数的元素移动至其左边，大于基准数的元素移动至其右边。「哨兵划分」的实现流程为：
+快速排序的核心操作为「哨兵划分」，其目标为：选取数组某个元素为 **基准数**，将所有小于基准数的元素移动至其左边，大于基准数的元素移动至其右边。「哨兵划分」的实现流程为：
 
 1. 以数组最左端元素作为基准数，初始化两个指针 `i` , `j` 指向数组两端；
 2. 设置一个循环，每轮中使用 `i` / `j` 分别寻找首个比基准数大 / 小的元素，并交换此两元素；
 3. 不断循环步骤 `2.` ，直至 `i` , `j` 相遇时跳出，最终把基准数交换至两个子数组的分界线；
 
-「哨兵划分」执行完毕后，原数组被划分成两个部分，即 **左子数组** 和 **右子数组** ，且满足 **左子数组任意元素 < 基准数 < 右子数组任意元素**。因此，接下来我们只需要排序两个子数组即可。
+「哨兵划分」执行完毕后，原数组被划分成两个部分，即 **左子数组** 和 **右子数组**，且满足 **左子数组任意元素 < 基准数 < 右子数组任意元素**。因此，接下来我们只需要排序两个子数组即可。
 
 === "Step 1"
     ![pivot_division_step1](quick_sort.assets/pivot_division_step1.png)
@@ -235,9 +235,9 @@ comments: true
 
 ## 算法流程
 
-1. 首先，对数组执行一次「哨兵划分」，得到待排序的 **左子数组** 和 **右子数组** 。
+1. 首先，对数组执行一次「哨兵划分」，得到待排序的 **左子数组** 和 **右子数组**；
 2. 接下来，对 **左子数组** 和 **右子数组** 分别 **递归执行**「哨兵划分」……
-3. 直至子数组长度为 1 时 **终止递归** ，即可完成对整个数组的排序。
+3. 直至子数组长度为 1 时 **终止递归**，即可完成对整个数组的排序；
 
 观察发现，快速排序和「二分查找」的原理类似，都是以对数阶的时间复杂度来缩小处理区间。
 
@@ -373,31 +373,31 @@ comments: true
 
 ## 算法特性
 
-**平均时间复杂度 $O(n \log n)$ ：** 平均情况下，哨兵划分的递归层数为 $\log n$ ，每层中的总循环数为 $n$ ，总体使用 $O(n \log n)$ 时间。
+**平均时间复杂度 $O(n \log n)$** ：平均情况下，哨兵划分的递归层数为 $\log n$ ，每层中的总循环数为 $n$ ，总体使用 $O(n \log n)$ 时间。
 
-**最差时间复杂度 $O(n^2)$ ：** 最差情况下，哨兵划分操作将长度为 $n$ 的数组划分为长度为 $0$ 和 $n - 1$ 的两个子数组，此时递归层数达到 $n$ 层，每层中的循环数为 $n$ ，总体使用 $O(n^2)$ 时间。
+**最差时间复杂度 $O(n^2)$** ：最差情况下，哨兵划分操作将长度为 $n$ 的数组划分为长度为 $0$ 和 $n - 1$ 的两个子数组，此时递归层数达到 $n$ 层，每层中的循环数为 $n$ ，总体使用 $O(n^2)$ 时间。
 
-**空间复杂度 $O(n)$ ：** 输入数组完全倒序下，达到最差递归深度 $n$ 。
+**空间复杂度 $O(n)$** ：输入数组完全倒序下，达到最差递归深度 $n$ 。
 
-**原地排序：** 只在递归中使用 $O(\log n)$ 大小的栈帧空间。
+**原地排序**：只在递归中使用 $O(\log n)$ 大小的栈帧空间。
 
-**非稳定排序：** 哨兵划分操作可能改变相等元素的相对位置。
+**非稳定排序**：哨兵划分操作可能改变相等元素的相对位置。
 
-**自适应排序：** 最差情况下，时间复杂度劣化至 $O(n^2)$ 。
+**自适应排序**：最差情况下，时间复杂度劣化至 $O(n^2)$ 。
 
 ## 快排为什么快？
 
-从命名能够看出，快速排序在效率方面一定“有两把刷子”。快速排序的平均时间复杂度虽然与「归并排序」和「堆排序」一致，但实际 **效率更高** ，这是因为：
+从命名能够看出，快速排序在效率方面一定“有两把刷子”。快速排序的平均时间复杂度虽然与「归并排序」和「堆排序」一致，但实际 **效率更高**，这是因为：
 
-- **出现最差情况的概率很低：** 虽然快速排序的最差时间复杂度为 $O(n^2)$ ，不如归并排序，但绝大部分情况下，快速排序可以达到 $O(n \log n)$ 的复杂度。
-- **缓存使用效率高：** 哨兵划分操作时，将整个子数组加载入缓存中，访问元素效率很高。而诸如「堆排序」需要跳跃式访问元素，因此不具有此特性。
-- **复杂度的常数系数低：** 在提及的三种算法中，快速排序的 **比较**、**赋值**、**交换** 三种操作的总体数量最少（类似于「插入排序」快于「冒泡排序」的原因）。
+- **出现最差情况的概率很低**：虽然快速排序的最差时间复杂度为 $O(n^2)$ ，不如归并排序，但绝大部分情况下，快速排序可以达到 $O(n \log n)$ 的复杂度。
+- **缓存使用效率高**：哨兵划分操作时，将整个子数组加载入缓存中，访问元素效率很高。而诸如「堆排序」需要跳跃式访问元素，因此不具有此特性。
+- **复杂度的常数系数低**：在提及的三种算法中，快速排序的 **比较**、**赋值**、**交换** 三种操作的总体数量最少（类似于「插入排序」快于「冒泡排序」的原因）。
 
 ## 基准数优化
 
-**普通快速排序在某些输入下的时间效率变差**。举个极端例子，假设输入数组是完全倒序的，由于我们选取最左端元素为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，从而 **左子数组长度为 $n - 1$ 、右子数组长度为 $0$** 。这样进一步递归下去，**每轮哨兵划分后的右子数组长度都为 $0$** ，分治策略失效，快速排序退化为「冒泡排序」了。
+**普通快速排序在某些输入下的时间效率变差**。举个极端例子，假设输入数组是完全倒序的，由于我们选取最左端元素为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，从而 **左子数组长度为 $n - 1$、右子数组长度为 $0$** 。这样进一步递归下去，**每轮哨兵划分后的右子数组长度都为 $0$** ，分治策略失效，快速排序退化为「冒泡排序」了。
 
-为了尽量避免这种情况发生，我们可以优化一下基准数的选取策略。首先，在哨兵划分中，我们可以 **随机选取一个元素作为基准数** 。但如果运气很差，每次都选择到比较差的基准数，那么效率依然不好。
+为了尽量避免这种情况发生，我们可以优化一下基准数的选取策略。首先，在哨兵划分中，我们可以 **随机选取一个元素作为基准数**。但如果运气很差，每次都选择到比较差的基准数，那么效率依然不好。
 
 进一步地，我们可以在数组中选取 3 个候选元素（一般为数组的首、尾、中点元素），**并将三个候选元素的中位数作为基准数**，这样基准数“既不大也不小”的概率就大大提升了。当然，如果数组很长的话，我们也可以选取更多候选元素，来进一步提升算法的稳健性。采取该方法后，时间复杂度劣化至 $O(n^2)$ 的概率极低。
 
diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md
index 9944f29e8..6f6272645 100644
--- a/docs/chapter_tree/avl_tree.md
+++ b/docs/chapter_tree/avl_tree.md
@@ -106,7 +106,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 
     ```
 
-「结点高度」是最远叶结点到该结点的距离，即走过的「边」的数量。需要特别注意，**叶结点的高度为 0 ，空结点的高度为 -1** 。我们封装两个工具函数，分别用于获取与更新结点的高度。
+「结点高度」是最远叶结点到该结点的距离，即走过的「边」的数量。需要特别注意，**叶结点的高度为 0 ，空结点的高度为 -1**。我们封装两个工具函数，分别用于获取与更新结点的高度。
 
 === "Java"
 
@@ -310,7 +310,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 
 ### Case 1 - 右旋
 
-如下图所示（结点下方为「平衡因子」），从底至顶看，二叉树中首个失衡结点是 **结点 3** 。我们聚焦在以该失衡结点为根结点的子树上，将该结点记为 `node` ，将其左子节点记为 `child` ，执行「右旋」操作。完成右旋后，该子树已经恢复平衡，并且仍然为二叉搜索树。
+如下图所示（结点下方为「平衡因子」），从底至顶看，二叉树中首个失衡结点是 **结点 3**。我们聚焦在以该失衡结点为根结点的子树上，将该结点记为 `node` ，将其左子节点记为 `child` ，执行「右旋」操作。完成右旋后，该子树已经恢复平衡，并且仍然为二叉搜索树。
 
 === "Step 1"
     ![right_rotate_step1](avl_tree.assets/right_rotate_step1.png)
diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md
index a4c5a5d2a..a0322154e 100644
--- a/docs/chapter_tree/binary_search_tree.md
+++ b/docs/chapter_tree/binary_search_tree.md
@@ -202,8 +202,8 @@ comments: true
 
 给定一个待插入元素 `num` ，为了保持二叉搜索树“左子树 < 根结点 < 右子树”的性质，插入操作分为两步：
 
-1. **查找插入位置：** 与查找操作类似，我们从根结点出发，根据当前结点值和 `num` 的大小关系循环向下搜索，直到越过叶结点（遍历到 $\text{null}$ ）时跳出循环；
-2. **在该位置插入结点：** 初始化结点 `num` ，将该结点放到 $\text{null}$ 的位置 ；
+1. **查找插入位置**：与查找操作类似，我们从根结点出发，根据当前结点值和 `num` 的大小关系循环向下搜索，直到越过叶结点（遍历到 $\text{null}$ ）时跳出循环；
+2. **在该位置插入结点**：初始化结点 `num` ，将该结点放到 $\text{null}$ 的位置 ；
 
 二叉搜索树不允许存在重复结点，否则将会违背其定义。因此若待插入结点在树中已经存在，则不执行插入，直接返回即可。
 
@@ -442,15 +442,15 @@ comments: true
 
 与插入结点一样，我们需要在删除操作后维持二叉搜索树的“左子树 < 根结点 < 右子树”的性质。首先，我们需要在二叉树中执行查找操作，获取待删除结点。接下来，根据待删除结点的子结点数量，删除操作需要分为三种情况：
 
-**待删除结点的子结点数量 $= 0$ **。表明待删除结点是叶结点，直接删除即可。
+**当待删除结点的子结点数量 $= 0$ 时**，表明待删除结点是叶结点，直接删除即可。
 
 ![bst_remove_case1](binary_search_tree.assets/bst_remove_case1.png)
 
-**待删除结点的子结点数量 $= 1$ **。将待删除结点替换为其子结点。
+**当待删除结点的子结点数量 $= 1$ 时**，将待删除结点替换为其子结点即可。
 
 ![bst_remove_case2](binary_search_tree.assets/bst_remove_case2.png)
 
-**待删除结点的子结点数量 $= 2$ **。删除操作分为三步：
+**当待删除结点的子结点数量 $= 2$ 时**，删除操作分为三步：
 
 1. 找到待删除结点在 **中序遍历序列** 中的下一个结点，记为 `nex` ；
 2. 在树中递归删除结点 `nex` ；
@@ -830,17 +830,17 @@ comments: true
 
 假设给定 $n$ 个数字，最常用的存储方式是「数组」，那么对于这串乱序的数字，常见操作的效率为：
 
-- **查找元素：** 由于数组是无序的，因此需要遍历数组来确定，使用 $O(n)$ 时间；
-- **插入元素：** 只需将元素添加至数组尾部即可，使用 $O(1)$ 时间；
-- **删除元素：** 先查找元素，使用 $O(n)$ 时间，再在数组中删除该元素，使用 $O(n)$ 时间；
-- **获取最小 / 最大元素：** 需要遍历数组来确定，使用 $O(n)$ 时间；
+- **查找元素**：由于数组是无序的，因此需要遍历数组来确定，使用 $O(n)$ 时间；
+- **插入元素**：只需将元素添加至数组尾部即可，使用 $O(1)$ 时间；
+- **删除元素**：先查找元素，使用 $O(n)$ 时间，再在数组中删除该元素，使用 $O(n)$ 时间；
+- **获取最小 / 最大元素**：需要遍历数组来确定，使用 $O(n)$ 时间；
 
 为了得到先验信息，我们也可以预先将数组元素进行排序，得到一个「排序数组」，此时操作效率为：
 
-- **查找元素：** 由于数组已排序，可以使用二分查找，平均使用 $O(\log n)$ 时间；
-- **插入元素：** 先查找插入位置，使用 $O(\log n)$ 时间，再插入到指定位置，使用 $O(n)$ 时间；
-- **删除元素：** 先查找元素，使用 $O(\log n)$ 时间，再在数组中删除该元素，使用 $O(n)$ 时间；
-- **获取最小 / 最大元素：** 数组头部和尾部元素即是最小和最大元素，使用 $O(1)$ 时间；
+- **查找元素**：由于数组已排序，可以使用二分查找，平均使用 $O(\log n)$ 时间；
+- **插入元素**：先查找插入位置，使用 $O(\log n)$ 时间，再插入到指定位置，使用 $O(n)$ 时间；
+- **删除元素**：先查找元素，使用 $O(\log n)$ 时间，再在数组中删除该元素，使用 $O(n)$ 时间；
+- **获取最小 / 最大元素**：数组头部和尾部元素即是最小和最大元素，使用 $O(1)$ 时间；
 
 观察发现，无序数组和有序数组中的各项操作的时间复杂度是“偏科”的，即有的快有的慢；**而二叉搜索树的各项操作的时间复杂度都是对数阶，在数据量 $n$ 很大时有巨大优势**。
 

From d6d6a16c7e24d9737d667507a729ec9e60cd1bda Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Tue, 10 Jan 2023 00:46:04 +0800
Subject: [PATCH 142/158] Update the access() function of linked_list

---
 .../chapter_array_and_linkedlist/linked_list.cpp    |  2 +-
 .../chapter_array_and_linkedlist/linked_list.cs     |  2 +-
 .../go/chapter_array_and_linkedlist/linked_list.go  |  2 +-
 .../chapter_array_and_linkedlist/linked_list.java   |  2 +-
 .../chapter_array_and_linkedlist/linked_list.py     |  2 +-
 .../chapter_array_and_linkedlist/linked_list.swift  |  2 +-
 docs/chapter_array_and_linkedlist/linked_list.md    | 13 +++++++------
 7 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp b/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp
index 13fa68691..5e976a89a 100644
--- a/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp
+++ b/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp
@@ -28,9 +28,9 @@ void remove(ListNode* n0) {
 /* 访问链表中索引为 index 的结点 */
 ListNode* access(ListNode* head, int index) {
     for (int i = 0; i < index; i++) {
-        head = head->next;
         if (head == nullptr)
             return nullptr;
+        head = head->next;
     }
     return head;
 }
diff --git a/codes/csharp/chapter_array_and_linkedlist/linked_list.cs b/codes/csharp/chapter_array_and_linkedlist/linked_list.cs
index d700a5ae7..d765724ff 100644
--- a/codes/csharp/chapter_array_and_linkedlist/linked_list.cs
+++ b/codes/csharp/chapter_array_and_linkedlist/linked_list.cs
@@ -39,9 +39,9 @@ namespace hello_algo.chapter_array_and_linkedlist
         {
             for (int i = 0; i < index; i++)
             {
-                head = head.next;
                 if (head == null)
                     return null;
+                head = head.next;
             }
             return head;
         }
diff --git a/codes/go/chapter_array_and_linkedlist/linked_list.go b/codes/go/chapter_array_and_linkedlist/linked_list.go
index fa4538ab4..8a60fd18e 100644
--- a/codes/go/chapter_array_and_linkedlist/linked_list.go
+++ b/codes/go/chapter_array_and_linkedlist/linked_list.go
@@ -29,10 +29,10 @@ func removeNode(n0 *ListNode) {
 /* 访问链表中索引为 index 的结点 */
 func access(head *ListNode, index int) *ListNode {
 	for i := 0; i < index; i++ {
-		head = head.Next
 		if head == nil {
 			return nil
 		}
+		head = head.Next
 	}
 	return head
 }
diff --git a/codes/java/chapter_array_and_linkedlist/linked_list.java b/codes/java/chapter_array_and_linkedlist/linked_list.java
index 570778ff5..0db8f6ae7 100644
--- a/codes/java/chapter_array_and_linkedlist/linked_list.java
+++ b/codes/java/chapter_array_and_linkedlist/linked_list.java
@@ -29,9 +29,9 @@ public class linked_list {
     /* 访问链表中索引为 index 的结点 */
     static ListNode access(ListNode head, int index) {
         for (int i = 0; i < index; i++) {
-            head = head.next;
             if (head == null)
                 return null;
+            head = head.next;
         }
         return head;
     }
diff --git a/codes/python/chapter_array_and_linkedlist/linked_list.py b/codes/python/chapter_array_and_linkedlist/linked_list.py
index dce110340..4fb6b1ba5 100644
--- a/codes/python/chapter_array_and_linkedlist/linked_list.py
+++ b/codes/python/chapter_array_and_linkedlist/linked_list.py
@@ -26,9 +26,9 @@ def remove(n0):
 """ 访问链表中索引为 index 的结点 """
 def access(head, index):
     for _ in range(index):
-        head = head.next
         if not head:
             return None
+        head = head.next
     return head
 
 """ 在链表中查找值为 target 的首个结点 """
diff --git a/codes/swift/chapter_array_and_linkedlist/linked_list.swift b/codes/swift/chapter_array_and_linkedlist/linked_list.swift
index 06837f750..90218b26b 100644
--- a/codes/swift/chapter_array_and_linkedlist/linked_list.swift
+++ b/codes/swift/chapter_array_and_linkedlist/linked_list.swift
@@ -29,10 +29,10 @@ func remove(n0: ListNode) {
 func access(head: ListNode, index: Int) -> ListNode? {
     var head: ListNode? = head
     for _ in 0 ..< index {
-        head = head?.next
         if head == nil {
             return nil
         }
+        head = head?.next
     }
     return head
 }
diff --git a/docs/chapter_array_and_linkedlist/linked_list.md b/docs/chapter_array_and_linkedlist/linked_list.md
index 7aa2754ca..8dd069788 100644
--- a/docs/chapter_array_and_linkedlist/linked_list.md
+++ b/docs/chapter_array_and_linkedlist/linked_list.md
@@ -400,6 +400,7 @@ comments: true
         n0.next = P;
         P.next = n1;
     }
+    
     /* 删除链表的结点 n0 之后的首个结点 */
     function remove(n0: ListNode): void {
         if (!n0.next) {
@@ -474,9 +475,9 @@ comments: true
     /* 访问链表中索引为 index 的结点 */
     ListNode access(ListNode head, int index) {
         for (int i = 0; i < index; i++) {
-            head = head.next;
             if (head == null)
                 return null;
+            head = head.next;
         }
         return head;
     }
@@ -488,9 +489,9 @@ comments: true
     /* 访问链表中索引为 index 的结点 */
     ListNode* access(ListNode* head, int index) {
         for (int i = 0; i < index; i++) {
-            head = head->next;
             if (head == nullptr)
                 return nullptr;
+            head = head->next;
         }
         return head;
     }
@@ -502,9 +503,9 @@ comments: true
     """ 访问链表中索引为 index 的结点 """
     def access(head, index):
         for _ in range(index):
-            head = head.next
             if not head:
                 return None
+            head = head.next
         return head
     ```
 
@@ -514,10 +515,10 @@ comments: true
     /* 访问链表中索引为 index 的结点 */
     func access(head *ListNode, index int) *ListNode {
         for i := 0; i < index; i++ {
-            head = head.Next
             if head == nil {
                 return nil
             }
+            head = head.Next
         }
         return head
     }
@@ -566,9 +567,9 @@ comments: true
     {
         for (int i = 0; i < index; i++)
         {
-            head = head.next;
             if (head == null)
                 return null;
+            head = head.next;
         }
         return head;
     }
@@ -581,10 +582,10 @@ comments: true
     func access(head: ListNode, index: Int) -> ListNode? {
         var head: ListNode? = head
         for _ in 0 ..< index {
-            head = head?.next
             if head == nil {
                 return nil
             }
+            head = head?.next
         }
         return head
     }

From b5019b0494bfbe28d50c0e3c5442cb3ba62edc03 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Tue, 10 Jan 2023 01:14:44 +0800
Subject: [PATCH 143/158] Update "about the book".

---
 docs/chapter_preface/about_the_book.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/docs/chapter_preface/about_the_book.md b/docs/chapter_preface/about_the_book.md
index c3209280c..01f513f00 100644
--- a/docs/chapter_preface/about_the_book.md
+++ b/docs/chapter_preface/about_the_book.md
@@ -205,9 +205,6 @@ comments: true
      */
     ```
 
-"""
-在 Java, C, C++, C#, Go, JS, TS 的代码注释中，`/* ... */` 用于注释函数、类、测试样例等标题， `// ...` 用于解释代码内容；类似地，在 Python 中，`""" ... """` 用于注释标题， `# ...` 用于解释代码。
-
 ## 本书特点 *
 
 ??? abstract "默认折叠，可以跳过"

From b7e09c4c1db1fd316d16f39453b9e8782a5d5579 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Tue, 10 Jan 2023 01:49:16 +0800
Subject: [PATCH 144/158] Unify the comment format of C# codes.

---
 .../chapter_array_and_linkedlist/array.cs     | 30 +++++--------------
 .../linked_list.cs                            | 18 ++++-------
 .../csharp/chapter_tree/binary_search_tree.cs |  6 +---
 codes/csharp/chapter_tree/binary_tree_bfs.cs  |  6 +---
 codes/csharp/chapter_tree/binary_tree_dfs.cs  | 15 ++--------
 5 files changed, 18 insertions(+), 57 deletions(-)

diff --git a/codes/csharp/chapter_array_and_linkedlist/array.cs b/codes/csharp/chapter_array_and_linkedlist/array.cs
index 95479574f..97a37f046 100644
--- a/codes/csharp/chapter_array_and_linkedlist/array.cs
+++ b/codes/csharp/chapter_array_and_linkedlist/array.cs
@@ -8,9 +8,7 @@ namespace hello_algo.chapter_array_and_linkedlist
 {
     public class Array
     {
-        /// <summary>
-        /// 随机返回一个数组元素
-        /// </summary>
+        /* 随机返回一个数组元素 */
         public static int RandomAccess(int[] nums)
         {
             Random random = new();
@@ -19,9 +17,7 @@ namespace hello_algo.chapter_array_and_linkedlist
             return randomNum;
         }
 
-        /// <summary>
-        /// 扩展数组长度
-        /// </summary>
+        /* 扩展数组长度 */
         public static int[] Extend(int[] nums, int enlarge)
         {
             // 初始化一个扩展长度后的数组
@@ -35,9 +31,7 @@ namespace hello_algo.chapter_array_and_linkedlist
             return res;
         }
 
-        /// <summary>
-        /// 在数组的索引 index 处插入元素 num
-        /// </summary>
+        /* 在数组的索引 index 处插入元素 num */
         public static void Insert(int[] nums, int num, int index)
         {
             // 把索引 index 以及之后的所有元素向后移动一位
@@ -49,9 +43,7 @@ namespace hello_algo.chapter_array_and_linkedlist
             nums[index] = num;
         }
 
-        /// <summary>
-        /// 删除索引 index 处元素
-        /// </summary>
+        /* 删除索引 index 处元素 */
         public static void Remove(int[] nums, int index)
         {
             // 把索引 index 之后的所有元素向前移动一位
@@ -61,9 +53,7 @@ namespace hello_algo.chapter_array_and_linkedlist
             }
         }
 
-        /// <summary>
-        /// 遍历数组
-        /// </summary>
+        /* 遍历数组 */
         public static void Traverse(int[] nums)
         {
             int count = 0;
@@ -79,9 +69,7 @@ namespace hello_algo.chapter_array_and_linkedlist
             }
         }
 
-        /// <summary>
-        /// 在数组中查找指定元素
-        /// </summary>
+        /* 在数组中查找指定元素 */
         public static int Find(int[] nums, int target)
         {
             for (int i = 0; i < nums.Length; i++)
@@ -92,15 +80,13 @@ namespace hello_algo.chapter_array_and_linkedlist
             return -1;
         }
 
-        /// <summary>
-        /// 辅助函数,数组转字符串
-        /// </summary>
+        /* 辅助函数,数组转字符串 */
         public static string ToString(int[] nums)
         {
             return string.Join(",", nums);
         }
         
-        // Driver Code 
+
         [Test]
         public static void Test()
         {
diff --git a/codes/csharp/chapter_array_and_linkedlist/linked_list.cs b/codes/csharp/chapter_array_and_linkedlist/linked_list.cs
index d765724ff..81e1499cb 100644
--- a/codes/csharp/chapter_array_and_linkedlist/linked_list.cs
+++ b/codes/csharp/chapter_array_and_linkedlist/linked_list.cs
@@ -9,9 +9,7 @@ namespace hello_algo.chapter_array_and_linkedlist
 {
     public class linked_list
     {
-        /// <summary>
-        /// 在链表的结点 n0 之后插入结点 P
-        /// </summary>
+        /* 在链表的结点 n0 之后插入结点 P */
         public static void Insert(ListNode n0, ListNode P)
         {
             ListNode? n1 = n0.next;
@@ -19,9 +17,7 @@ namespace hello_algo.chapter_array_and_linkedlist
             P.next = n1;
         }
 
-        /// <summary>
-        /// 删除链表的结点 n0 之后的首个结点
-        /// </summary>
+        /* 删除链表的结点 n0 之后的首个结点 */
         public static void Remove(ListNode n0)
         {
             if (n0.next == null)
@@ -32,9 +28,7 @@ namespace hello_algo.chapter_array_and_linkedlist
             n0.next = n1;
         }
 
-        /// <summary>
-        /// 访问链表中索引为 index 的结点
-        /// </summary>
+        /* 访问链表中索引为 index 的结点 */
         public static ListNode? Access(ListNode head, int index)
         {
             for (int i = 0; i < index; i++)
@@ -46,9 +40,7 @@ namespace hello_algo.chapter_array_and_linkedlist
             return head;
         }
 
-        /// <summary>
-        /// 在链表中查找值为 target 的首个结点
-        /// </summary>
+        /* 在链表中查找值为 target 的首个结点 */
         public static int Find(ListNode head, int target)
         {
             int index = 0;
@@ -62,7 +54,7 @@ namespace hello_algo.chapter_array_and_linkedlist
             return -1;
         }
 
-        // Driver Code 
+
         [Test]
         public void Test()
         {
diff --git a/codes/csharp/chapter_tree/binary_search_tree.cs b/codes/csharp/chapter_tree/binary_search_tree.cs
index 5164cf780..d2e5f95e6 100644
--- a/codes/csharp/chapter_tree/binary_search_tree.cs
+++ b/codes/csharp/chapter_tree/binary_search_tree.cs
@@ -35,11 +35,7 @@ namespace hello_algo.chapter_tree
             return root;
         }
 
-        /// <summary>
-        /// 查找结点
-        /// </summary>
-        /// <param name="num"></param>
-        /// <returns></returns>
+        /* 查找结点 */
         public TreeNode? search(int num)
         {
             TreeNode? cur = root;
diff --git a/codes/csharp/chapter_tree/binary_tree_bfs.cs b/codes/csharp/chapter_tree/binary_tree_bfs.cs
index f0c914acb..9a57dbc17 100644
--- a/codes/csharp/chapter_tree/binary_tree_bfs.cs
+++ b/codes/csharp/chapter_tree/binary_tree_bfs.cs
@@ -12,11 +12,7 @@ namespace hello_algo.chapter_tree
     public class binary_tree_bfs
     {
 
-        /// <summary>
-        /// 层序遍历
-        /// </summary>
-        /// <param name="root"></param>
-        /// <returns></returns>
+        /* 层序遍历 */
         public List<int> hierOrder(TreeNode root)
         {
             // 初始化队列，加入根结点
diff --git a/codes/csharp/chapter_tree/binary_tree_dfs.cs b/codes/csharp/chapter_tree/binary_tree_dfs.cs
index 0f89cb3b2..f8669d782 100644
--- a/codes/csharp/chapter_tree/binary_tree_dfs.cs
+++ b/codes/csharp/chapter_tree/binary_tree_dfs.cs
@@ -13,10 +13,7 @@ namespace hello_algo.chapter_tree
     {
         List<int> list = new();
 
-        /// <summary>
-        /// 前序遍历
-        /// </summary>
-        /// <param name="root"></param>
+        /* 前序遍历 */
         void preOrder(TreeNode? root)
         {
             if (root == null) return;
@@ -26,10 +23,7 @@ namespace hello_algo.chapter_tree
             preOrder(root.right);
         }
 
-        /// <summary>
-        /// 中序遍历
-        /// </summary>
-        /// <param name="root"></param>
+        /* 中序遍历 */
         void inOrder(TreeNode? root)
         {
             if (root == null) return;
@@ -39,10 +33,7 @@ namespace hello_algo.chapter_tree
             inOrder(root.right);
         }
 
-        /// <summary>
-        /// 后序遍历
-        /// </summary>
-        /// <param name="root"></param>
+        /* 后序遍历 */
         void postOrder(TreeNode? root)
         {
             if (root == null) return;

From 47f017177bad4faa8582c635772f9b64a2861584 Mon Sep 17 00:00:00 2001
From: nuomi1 <nuomi1@qq.com>
Date: Mon, 9 Jan 2023 23:02:22 +0800
Subject: [PATCH 145/158] feat: add Swift codes for stack article

---
 codes/swift/Package.swift                     |   6 +
 .../chapter_stack_and_queue/array_stack.swift |  84 +++++++++++++
 .../linkedlist_stack.swift                    |  93 ++++++++++++++
 .../swift/chapter_stack_and_queue/stack.swift |  39 ++++++
 docs/chapter_stack_and_queue/stack.md         | 116 ++++++++++++++++++
 5 files changed, 338 insertions(+)
 create mode 100644 codes/swift/chapter_stack_and_queue/array_stack.swift
 create mode 100644 codes/swift/chapter_stack_and_queue/linkedlist_stack.swift
 create mode 100644 codes/swift/chapter_stack_and_queue/stack.swift

diff --git a/codes/swift/Package.swift b/codes/swift/Package.swift
index 3a5a18ed3..6d6eaa8a5 100644
--- a/codes/swift/Package.swift
+++ b/codes/swift/Package.swift
@@ -13,6 +13,9 @@ let package = Package(
         .executable(name: "linked_list", targets: ["linked_list"]),
         .executable(name: "list", targets: ["list"]),
         .executable(name: "my_list", targets: ["my_list"]),
+        .executable(name: "stack", targets: ["stack"]),
+        .executable(name: "linkedlist_stack", targets: ["linkedlist_stack"]),
+        .executable(name: "array_stack", targets: ["array_stack"]),
     ],
     targets: [
         .target(name: "utils", path: "utils"),
@@ -24,5 +27,8 @@ let package = Package(
         .executableTarget(name: "linked_list", dependencies: ["utils"], path: "chapter_array_and_linkedlist", sources: ["linked_list.swift"]),
         .executableTarget(name: "list", path: "chapter_array_and_linkedlist", sources: ["list.swift"]),
         .executableTarget(name: "my_list", path: "chapter_array_and_linkedlist", sources: ["my_list.swift"]),
+        .executableTarget(name: "stack", path: "chapter_stack_and_queue", sources: ["stack.swift"]),
+        .executableTarget(name: "linkedlist_stack", dependencies: ["utils"], path: "chapter_stack_and_queue", sources: ["linkedlist_stack.swift"]),
+        .executableTarget(name: "array_stack", path: "chapter_stack_and_queue", sources: ["array_stack.swift"]),
     ]
 )
diff --git a/codes/swift/chapter_stack_and_queue/array_stack.swift b/codes/swift/chapter_stack_and_queue/array_stack.swift
new file mode 100644
index 000000000..faeeaa173
--- /dev/null
+++ b/codes/swift/chapter_stack_and_queue/array_stack.swift
@@ -0,0 +1,84 @@
+/**
+ * File: array_stack.swift
+ * Created Time: 2023-01-09
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* 基于数组实现的栈 */
+class ArrayStack {
+    private var stack: [Int]
+
+    init() {
+        // 初始化列表（动态数组）
+        stack = []
+    }
+
+    /* 获取栈的长度 */
+    func size() -> Int {
+        stack.count
+    }
+
+    /* 判断栈是否为空 */
+    func isEmpty() -> Bool {
+        stack.isEmpty
+    }
+
+    /* 入栈 */
+    func push(num: Int) {
+        stack.append(num)
+    }
+
+    /* 出栈 */
+    func pop() -> Int {
+        if stack.isEmpty {
+            fatalError("栈为空")
+        }
+        return stack.removeLast()
+    }
+
+    /* 访问栈顶元素 */
+    func peek() -> Int {
+        if stack.isEmpty {
+            fatalError("栈为空")
+        }
+        return stack.last!
+    }
+
+    /* 将 List 转化为 Array 并返回 */
+    func toArray() -> [Int] {
+        stack
+    }
+}
+
+@main
+enum _ArrayStack {
+    /* Driver Code */
+    static func main() {
+        /* 初始化栈 */
+        let stack = ArrayStack()
+
+        /* 元素入栈 */
+        stack.push(num: 1)
+        stack.push(num: 3)
+        stack.push(num: 2)
+        stack.push(num: 5)
+        stack.push(num: 4)
+        print("栈 stack = \(stack.toArray())")
+
+        /* 访问栈顶元素 */
+        let peek = stack.peek()
+        print("栈顶元素 peek = \(peek)")
+
+        /* 元素出栈 */
+        let pop = stack.pop()
+        print("出栈元素 pop = \(pop)，出栈后 stack = \(stack.toArray())")
+
+        /* 获取栈的长度 */
+        let size = stack.size()
+        print("栈的长度 size = \(size)")
+
+        /* 判断是否为空 */
+        let isEmpty = stack.isEmpty()
+        print("栈是否为空 = \(isEmpty)")
+    }
+}
diff --git a/codes/swift/chapter_stack_and_queue/linkedlist_stack.swift b/codes/swift/chapter_stack_and_queue/linkedlist_stack.swift
new file mode 100644
index 000000000..9d3c98b01
--- /dev/null
+++ b/codes/swift/chapter_stack_and_queue/linkedlist_stack.swift
@@ -0,0 +1,93 @@
+/**
+ * File: linkedlist_stack.swift
+ * Created Time: 2023-01-09
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+/* 基于链表实现的栈 */
+class LinkedListStack {
+    private var _peek: ListNode? // 将头结点作为栈顶
+    private var _size = 0 // 栈的长度
+
+    init() {}
+
+    /* 获取栈的长度 */
+    func size() -> Int {
+        _size
+    }
+
+    /* 判断栈是否为空 */
+    func isEmpty() -> Bool {
+        _size == 0
+    }
+
+    /* 入栈 */
+    func push(num: Int) {
+        let node = ListNode(x: num)
+        node.next = _peek
+        _peek = node
+        _size += 1
+    }
+
+    /* 出栈 */
+    func pop() -> Int {
+        let num = peek()
+        _peek = _peek?.next
+        _size -= 1
+        return num
+    }
+
+    /* 访问栈顶元素 */
+    func peek() -> Int {
+        if _size == 0 {
+            fatalError("栈为空")
+        }
+        return _peek!.val
+    }
+
+    /* 将 List 转化为 Array 并返回 */
+    func toArray() -> [Int] {
+        var node = _peek
+        var res = Array(repeating: 0, count: _size)
+        for i in sequence(first: res.count - 1, next: { $0 >= 0 + 1 ? $0 - 1 : nil }) {
+            res[i] = node!.val
+            node = node?.next
+        }
+        return res
+    }
+}
+
+@main
+enum _LinkedListStack {
+    /* Driver Code */
+    static func main() {
+        /* 初始化栈 */
+        let stack = LinkedListStack()
+
+        /* 元素入栈 */
+        stack.push(num: 1)
+        stack.push(num: 3)
+        stack.push(num: 2)
+        stack.push(num: 5)
+        stack.push(num: 4)
+        print("栈 stack = \(stack.toArray())")
+
+        /* 访问栈顶元素 */
+        let peek = stack.peek()
+        print("栈顶元素 peek = \(peek)")
+
+        /* 元素出栈 */
+        let pop = stack.pop()
+        print("出栈元素 pop = \(pop)，出栈后 stack = \(stack.toArray())")
+
+        /* 获取栈的长度 */
+        let size = stack.size()
+        print("栈的长度 size = \(size)")
+
+        /* 判断是否为空 */
+        let isEmpty = stack.isEmpty()
+        print("栈是否为空 = \(isEmpty)")
+    }
+}
diff --git a/codes/swift/chapter_stack_and_queue/stack.swift b/codes/swift/chapter_stack_and_queue/stack.swift
new file mode 100644
index 000000000..c6b8bc184
--- /dev/null
+++ b/codes/swift/chapter_stack_and_queue/stack.swift
@@ -0,0 +1,39 @@
+/**
+ * File: stack.swift
+ * Created Time: 2023-01-09
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+@main
+enum Stack {
+    /* Driver Code */
+    static func main() {
+        /* 初始化栈 */
+        // Swift 没有内置的栈类，可以把 Array 当作栈来使用
+        var stack: [Int] = []
+
+        /* 元素入栈 */
+        stack.append(1)
+        stack.append(3)
+        stack.append(2)
+        stack.append(5)
+        stack.append(4)
+        print("栈 stack = \(stack)")
+
+        /* 访问栈顶元素 */
+        let peek = stack.last!
+        print("栈顶元素 peek = \(peek)")
+
+        /* 元素出栈 */
+        let pop = stack.removeLast()
+        print("出栈元素 pop = \(pop)，出栈后 stack = \(stack)")
+
+        /* 获取栈的长度 */
+        let size = stack.count
+        print("栈的长度 size = \(size)")
+
+        /* 判断是否为空 */
+        let isEmpty = stack.isEmpty
+        print("栈是否为空 = \(isEmpty)")
+    }
+}
diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index d5a3f9164..04825695c 100644
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -231,7 +231,28 @@ comments: true
 === "Swift"
 
     ```swift title="stack.swift"
+    /* 初始化栈 */
+    // Swift 没有内置的栈类，可以把 Array 当作栈来使用
+    var stack: [Int] = []
 
+    /* 元素入栈 */
+    stack.append(1)
+    stack.append(3)
+    stack.append(2)
+    stack.append(5)
+    stack.append(4)
+
+    /* 访问栈顶元素 */
+    let peek = stack.last!
+
+    /* 元素出栈 */
+    let pop = stack.removeLast()
+
+    /* 获取栈的长度 */
+    let size = stack.count
+
+    /* 判断是否为空 */
+    let isEmpty = stack.isEmpty
     ```
 
 ## 栈的实现
@@ -606,7 +627,58 @@ comments: true
 === "Swift"
 
     ```swift title="linkedlist_stack.swift"
+    /* 基于链表实现的栈 */
+    class LinkedListStack {
+        private var _peek: ListNode? // 将头结点作为栈顶
+        private var _size = 0 // 栈的长度
 
+        init() {}
+
+        /* 获取栈的长度 */
+        func size() -> Int {
+            _size
+        }
+
+        /* 判断栈是否为空 */
+        func isEmpty() -> Bool {
+            _size == 0
+        }
+
+        /* 入栈 */
+        func push(num: Int) {
+            let node = ListNode(x: num)
+            node.next = _peek
+            _peek = node
+            _size += 1
+        }
+
+        /* 出栈 */
+        func pop() -> Int {
+            let num = peek()
+            _peek = _peek?.next
+            _size -= 1
+            return num
+        }
+
+        /* 访问栈顶元素 */
+        func peek() -> Int {
+            if _size == 0 {
+                fatalError("栈为空")
+            }
+            return _peek!.val
+        }
+
+        /* 将 List 转化为 Array 并返回 */
+        func toArray() -> [Int] {
+            var node = _peek
+            var res = Array(repeating: 0, count: _size)
+            for i in sequence(first: res.count - 1, next: { $0 >= 0 + 1 ? $0 - 1 : nil }) {
+                res[i] = node!.val
+                node = node?.next
+            }
+            return res
+        }
+    }
     ```
 
 ### 基于数组的实现
@@ -897,7 +969,51 @@ comments: true
 === "Swift"
 
     ```swift title="array_stack.swift"
+    /* 基于数组实现的栈 */
+    class ArrayStack {
+        private var stack: [Int]
 
+        init() {
+            // 初始化列表（动态数组）
+            stack = []
+        }
+
+        /* 获取栈的长度 */
+        func size() -> Int {
+            stack.count
+        }
+
+        /* 判断栈是否为空 */
+        func isEmpty() -> Bool {
+            stack.isEmpty
+        }
+
+        /* 入栈 */
+        func push(num: Int) {
+            stack.append(num)
+        }
+
+        /* 出栈 */
+        func pop() -> Int {
+            if stack.isEmpty {
+                fatalError("栈为空")
+            }
+            return stack.removeLast()
+        }
+
+        /* 访问栈顶元素 */
+        func peek() -> Int {
+            if stack.isEmpty {
+                fatalError("栈为空")
+            }
+            return stack.last!
+        }
+
+        /* 将 List 转化为 Array 并返回 */
+        func toArray() -> [Int] {
+            stack
+        }
+    }
     ```
 
 !!! tip

From 96d54bff3a983373ffc2d9c18d8b8446472d780e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BE=9A=E5=9B=BD=E7=8E=AE?= <gongguowei01@gmail.com>
Date: Tue, 10 Jan 2023 12:16:02 +0800
Subject: [PATCH 146/158] test(binary_search_tree): update test param all the
 language

use param value 7, not 5. function test param value with param value in example picture as same.
---
 codes/cpp/chapter_tree/binary_search_tree.cpp       | 2 +-
 codes/csharp/chapter_tree/binary_search_tree.cs     | 2 +-
 codes/java/chapter_tree/binary_search_tree.java     | 2 +-
 codes/javascript/chapter_tree/binary_search_tree.js | 2 +-
 codes/python/chapter_tree/binary_search_tree.py     | 2 +-
 codes/typescript/chapter_tree/binary_search_tree.ts | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/codes/cpp/chapter_tree/binary_search_tree.cpp b/codes/cpp/chapter_tree/binary_search_tree.cpp
index 246bdbaa1..648e194ae 100644
--- a/codes/cpp/chapter_tree/binary_search_tree.cpp
+++ b/codes/cpp/chapter_tree/binary_search_tree.cpp
@@ -131,7 +131,7 @@ int main() {
     PrintUtil::printTree(bst->getRoot());
 
     /* 查找结点 */
-    TreeNode* node = bst->search(5);
+    TreeNode* node = bst->search(7);
     cout << endl << "查找到的结点对象为 " << node << "，结点值 = " << node->val << endl;
 
     /* 插入结点 */
diff --git a/codes/csharp/chapter_tree/binary_search_tree.cs b/codes/csharp/chapter_tree/binary_search_tree.cs
index 8224317df..3cb991486 100644
--- a/codes/csharp/chapter_tree/binary_search_tree.cs
+++ b/codes/csharp/chapter_tree/binary_search_tree.cs
@@ -163,7 +163,7 @@ namespace hello_algo.chapter_tree
             PrintUtil.PrintTree(bst.getRoot());
 
             /* 查找结点 */
-            TreeNode? node = bst.search(5);
+            TreeNode? node = bst.search(7);
             Console.WriteLine("\n查找到的结点对象为 " + node + "，结点值 = " + node.val);
 
             /* 插入结点 */
diff --git a/codes/java/chapter_tree/binary_search_tree.java b/codes/java/chapter_tree/binary_search_tree.java
index 0770c567d..1755df56b 100644
--- a/codes/java/chapter_tree/binary_search_tree.java
+++ b/codes/java/chapter_tree/binary_search_tree.java
@@ -131,7 +131,7 @@ public class binary_search_tree {
         PrintUtil.printTree(bst.getRoot());
 
         /* 查找结点 */
-        TreeNode node = bst.search(5);
+        TreeNode node = bst.search(7);
         System.out.println("\n查找到的结点对象为 " + node + "，结点值 = " + node.val);
 
         /* 插入结点 */
diff --git a/codes/javascript/chapter_tree/binary_search_tree.js b/codes/javascript/chapter_tree/binary_search_tree.js
index 1e0d92738..345cff555 100644
--- a/codes/javascript/chapter_tree/binary_search_tree.js
+++ b/codes/javascript/chapter_tree/binary_search_tree.js
@@ -126,7 +126,7 @@ console.log("\n初始化的二叉树为\n");
 printTree(getRoot());
 
 /* 查找结点 */
-let node = search(5);
+let node = search(7);
 console.log("\n查找到的结点对象为 " + node + "，结点值 = " + node.val);
 
 /* 插入结点 */
diff --git a/codes/python/chapter_tree/binary_search_tree.py b/codes/python/chapter_tree/binary_search_tree.py
index 23e341854..811b3829d 100644
--- a/codes/python/chapter_tree/binary_search_tree.py
+++ b/codes/python/chapter_tree/binary_search_tree.py
@@ -145,7 +145,7 @@ if __name__ == "__main__":
     print_tree(bst.root)
 
     # 查找结点
-    node = bst.search(5)
+    node = bst.search(7)
     print("\n查找到的结点对象为: {}，结点值 = {}".format(node, node.val))
 
     # 插入结点
diff --git a/codes/typescript/chapter_tree/binary_search_tree.ts b/codes/typescript/chapter_tree/binary_search_tree.ts
index 6dad83421..1222b8d5d 100644
--- a/codes/typescript/chapter_tree/binary_search_tree.ts
+++ b/codes/typescript/chapter_tree/binary_search_tree.ts
@@ -150,7 +150,7 @@ console.log('\n初始化的二叉树为\n');
 printTree(getRoot());
 
 /* 查找结点 */
-let node = search(5);
+let node = search(7);
 console.log('\n查找到的结点对象为 ' + node + '，结点值 = ' + node!.val);
 
 /* 插入结点 */

From 9c5eedeb8ce7332ddf93ae2c6a8bb381127d93ca Mon Sep 17 00:00:00 2001
From: Cavin <xjr30226@126.com>
Date: Tue, 10 Jan 2023 16:02:46 +0800
Subject: [PATCH 147/158] Update binary_tree.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

优化第三段中对“左子树”和“右子树”的描述
---
 docs/chapter_tree/binary_tree.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md
index 077c03e0d..1061e019d 100644
--- a/docs/chapter_tree/binary_tree.md
+++ b/docs/chapter_tree/binary_tree.md
@@ -114,7 +114,7 @@ comments: true
 
 结点的两个指针分别指向「左子结点 Left Child Node」和「右子结点 Right Child Node」，并且称该结点为两个子结点的「父结点 Parent Node」。给定二叉树某结点，将左子结点以下的树称为该结点的「左子树 Left Subtree」，右子树同理。
 
-除了叶结点外，每个结点都有子结点和子树。例如，若将上图的「结点 2」看作父结点，那么其左子结点和右子结点分别为「结点 4」和「结点 5」，左子树和右子树分别为「结点 4 以下的树」和「结点 5 以下的树」。
+除了叶结点外，每个结点都有子结点和子树。例如，若将上图的「结点 2」看作父结点，那么其左子结点和右子结点分别为「结点 4」和「结点 5」，左子树和右子树分别为「结点 4 及其以下结点形成的树」和「结点 5 及其以下结点形成的树」。
 
 ![binary_tree_definition](binary_tree.assets/binary_tree_definition.png)
 

From 2572b83540edc08e2e64d9e0d2aed2489f371e7e Mon Sep 17 00:00:00 2001
From: sjinzh <99076655+sjinzh@users.noreply.github.com>
Date: Tue, 10 Jan 2023 17:19:21 +0800
Subject: [PATCH 148/158] update zig codes for Section 'Space Complexity' and
 'Space Time Tradeoff'

---
 codes/zig/build.zig                                       | 8 ++++----
 .../chapter_computational_complexity/leetcode_two_sum.zig | 4 ++++
 .../chapter_computational_complexity/space_complexity.zig | 4 ++++
 .../chapter_computational_complexity/time_complexity.zig  | 4 ++++
 .../worst_best_time_complexity.zig                        | 4 ++++
 codes/zig/include/ListNode.zig                            | 1 +
 codes/zig/include/PrintUtil.zig                           | 1 +
 codes/zig/include/TreeNode.zig                            | 1 +
 8 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/codes/zig/build.zig b/codes/zig/build.zig
index e72ca4a53..9584ba4b3 100644
--- a/codes/zig/build.zig
+++ b/codes/zig/build.zig
@@ -11,7 +11,7 @@ pub fn build(b: *std.build.Builder) void {
     const mode = b.standardReleaseOptions();
 
     // Section: "Time Complexity"
-        // File: "chapter_computational_complexity/time_complexity.zig"
+        // Source File: "chapter_computational_complexity/time_complexity.zig"
         // Run Command: zig build run_time_complexity
         const exe_time_complexity = b.addExecutable("time_complexity", "chapter_computational_complexity/time_complexity.zig");
         exe_time_complexity.addPackagePath("include", "include/include.zig");
@@ -24,7 +24,7 @@ pub fn build(b: *std.build.Builder) void {
         const run_step_time_complexity = b.step("run_time_complexity", "Run time_complexity");
         run_step_time_complexity.dependOn(&run_cmd_time_complexity.step);
 
-        // File: "chapter_computational_complexity/worst_best_time_complexity.zig"
+        // Source File: "chapter_computational_complexity/worst_best_time_complexity.zig"
         // Run Command: zig build run_worst_best_time_complexity
         const exe_worst_best_time_complexity = b.addExecutable("worst_best_time_complexity", "chapter_computational_complexity/worst_best_time_complexity.zig");
         exe_worst_best_time_complexity.addPackagePath("include", "include/include.zig");
@@ -38,7 +38,7 @@ pub fn build(b: *std.build.Builder) void {
         run_step_worst_best_time_complexity.dependOn(&run_cmd_worst_best_time_complexity.step);
 
     // Section: "Space Complexity"
-        // File: "chapter_computational_complexity/space_complexity.zig"
+        // Source File: "chapter_computational_complexity/space_complexity.zig"
         // Run Command: zig build run_space_complexity
         const exe_space_complexity = b.addExecutable("space_complexity", "chapter_computational_complexity/space_complexity.zig");
         exe_space_complexity.addPackagePath("include", "include/include.zig");
@@ -52,7 +52,7 @@ pub fn build(b: *std.build.Builder) void {
         run_step_space_complexity.dependOn(&run_cmd_space_complexity.step);
 
     // Section: "Space Time Tradeoff"
-        // File: "chapter_computational_complexity/leetcode_two_sum.zig"
+        // Source File: "chapter_computational_complexity/leetcode_two_sum.zig"
         // Run Command: zig build run_leetcode_two_sum
         const exe_leetcode_two_sum = b.addExecutable("leetcode_two_sum", "chapter_computational_complexity/leetcode_two_sum.zig");
         exe_leetcode_two_sum.addPackagePath("include", "include/include.zig");
diff --git a/codes/zig/chapter_computational_complexity/leetcode_two_sum.zig b/codes/zig/chapter_computational_complexity/leetcode_two_sum.zig
index 66b96f95e..dc963b595 100644
--- a/codes/zig/chapter_computational_complexity/leetcode_two_sum.zig
+++ b/codes/zig/chapter_computational_complexity/leetcode_two_sum.zig
@@ -44,6 +44,10 @@ const SolutionHashMap = struct {
 
 // Driver Code
 pub fn main() !void {
+    // 查看本地CPU架构和操作系统信息
+    var native_target_info = try std.zig.system.NativeTargetInfo.detect(std.zig.CrossTarget{});
+    std.debug.print("Native Info: CPU Arch = {}, OS = {}\n", .{native_target_info.target.cpu.arch, native_target_info.target.os.tag});
+
     // ======= Test Case =======
     var nums = [_]i32{ 2, 7, 11, 15 };
     var target: i32 = 9;
diff --git a/codes/zig/chapter_computational_complexity/space_complexity.zig b/codes/zig/chapter_computational_complexity/space_complexity.zig
index 9798821a5..3fe81a706 100644
--- a/codes/zig/chapter_computational_complexity/space_complexity.zig
+++ b/codes/zig/chapter_computational_complexity/space_complexity.zig
@@ -102,6 +102,10 @@ fn buildTree(mem_allocator: std.mem.Allocator, n: i32) !?*inc.TreeNode(i32) {
 
 // Driver Code
 pub fn main() !void {
+    // 查看本地CPU架构和操作系统信息
+    var native_target_info = try std.zig.system.NativeTargetInfo.detect(std.zig.CrossTarget{});
+    std.debug.print("Native Info: CPU Arch = {}, OS = {}\n", .{native_target_info.target.cpu.arch, native_target_info.target.os.tag});
+
     const n: i32 = 5;
     // 常数阶
     constant(n);
diff --git a/codes/zig/chapter_computational_complexity/time_complexity.zig b/codes/zig/chapter_computational_complexity/time_complexity.zig
index dab17034a..ef8d7fe65 100644
--- a/codes/zig/chapter_computational_complexity/time_complexity.zig
+++ b/codes/zig/chapter_computational_complexity/time_complexity.zig
@@ -139,6 +139,10 @@ fn factorialRecur(n: i32) i32 {
 
 // Driver Code
 pub fn main() void {
+    // 查看本地CPU架构和操作系统信息
+    var native_target_info = try std.zig.system.NativeTargetInfo.detect(std.zig.CrossTarget{});
+    std.debug.print("Native Info: CPU Arch = {}, OS = {}\n", .{native_target_info.target.cpu.arch, native_target_info.target.os.tag});
+
     // 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
     const n: i32 = 8;
     std.debug.print("输入数据大小 n = {}\n", .{n});
diff --git a/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig b/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig
index bd2a1464a..42961aafb 100644
--- a/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig
+++ b/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig
@@ -28,6 +28,10 @@ pub fn findOne(nums: []i32) i32 {
 
 // Driver Code
 pub fn main() void {
+    // 查看本地CPU架构和操作系统信息
+    var native_target_info = try std.zig.system.NativeTargetInfo.detect(std.zig.CrossTarget{});
+    std.debug.print("Native Info: CPU Arch = {}, OS = {}\n", .{native_target_info.target.cpu.arch, native_target_info.target.os.tag});
+
     var i: i32 = 0;
     while (i < 10) : (i += 1) {
         const n: usize = 100;
diff --git a/codes/zig/include/ListNode.zig b/codes/zig/include/ListNode.zig
index 8ce01d3ed..ae0246c09 100644
--- a/codes/zig/include/ListNode.zig
+++ b/codes/zig/include/ListNode.zig
@@ -5,6 +5,7 @@
 const std = @import("std");
 
 // Definition for a singly-linked list node
+// 编译期泛型
 pub fn ListNode(comptime T: type) type {
     return struct {
         const Self = @This();
diff --git a/codes/zig/include/PrintUtil.zig b/codes/zig/include/PrintUtil.zig
index 8a7dca7af..9e6b18b05 100644
--- a/codes/zig/include/PrintUtil.zig
+++ b/codes/zig/include/PrintUtil.zig
@@ -7,6 +7,7 @@ const ListNode = @import("ListNode.zig").ListNode;
 const TreeNode = @import("TreeNode.zig").TreeNode;
 
 // Print an array
+// 编译期泛型
 pub fn printArray(comptime T: type, nums: []T) void {
     std.debug.print("[", .{});
     if (nums.len > 0) {
diff --git a/codes/zig/include/TreeNode.zig b/codes/zig/include/TreeNode.zig
index 9bd51ba3d..12af9e8f3 100644
--- a/codes/zig/include/TreeNode.zig
+++ b/codes/zig/include/TreeNode.zig
@@ -5,6 +5,7 @@
 const std = @import("std");
 
 // Definition for a binary tree node
+// 编译期泛型
 pub fn TreeNode(comptime T: type) type {
     return struct {
         const Self = @This();

From 51e52121dce697c1a9a883e63590472354d1c4c5 Mon Sep 17 00:00:00 2001
From: mellowrsa <87369532+mellowrsa@users.noreply.github.com>
Date: Tue, 10 Jan 2023 18:05:52 +0800
Subject: [PATCH 149/158] Update time_complexity.md

---
 .../time_complexity.md                              | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 09aee7b79..ea523b46d 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -1434,11 +1434,14 @@ $$
         for (int i = n - 1; i > 0; i--) {
             // 内循环：冒泡操作
             for (int j = 0; j < i; j++) {
-                // 交换 nums[j] 与 nums[j + 1]
-                int tmp = nums[j];
-                nums[j] = nums[j + 1];
-                nums[j + 1] = tmp;
-                count += 3;  // 元素交换包含 3 个单元操作
+                if (nums[j] > nums [j+1]) 
+                {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    int tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    count += 3;  // 元素交换包含 3 个单元操作
+                }
             }
             
         }

From afaf2de9f4f82a5452d7c290d2967c7db7378fd4 Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 10 Jan 2023 21:46:03 +1100
Subject: [PATCH 150/158] removed: .editorconfig

---
 .editorconfig | 14 --------------
 1 file changed, 14 deletions(-)
 delete mode 100644 .editorconfig

diff --git a/.editorconfig b/.editorconfig
deleted file mode 100644
index f57b4f2fb..000000000
--- a/.editorconfig
+++ /dev/null
@@ -1,14 +0,0 @@
-# EditorConfig is awesome: https://EditorConfig.org
-
-# top-most EditorConfig file
-root = true
-
-# Unix-style newlines with a newline ending every file
-[*]
-end_of_line = lf
-insert_final_newline = true
-
-[codes/**.{java,js,ts,go,py,cpp,c,cs,swift,zig}]
-charset = utf-8
-indent_style = space
-indent_size = 4

From a667e71b2022a48553cc3f151e17b61f17835d53 Mon Sep 17 00:00:00 2001
From: sjinzh <99076655+sjinzh@users.noreply.github.com>
Date: Tue, 10 Jan 2023 19:29:57 +0800
Subject: [PATCH 151/158] fix bug

---
 .../time_complexity.c                                | 12 +++++++-----
 codes/zig/build.zig                                  |  2 +-
 .../time_complexity.zig                              | 12 +++++++-----
 3 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/codes/c/chapter_computational_complexity/time_complexity.c b/codes/c/chapter_computational_complexity/time_complexity.c
index b8821ec6a..ee827ed14 100644
--- a/codes/c/chapter_computational_complexity/time_complexity.c
+++ b/codes/c/chapter_computational_complexity/time_complexity.c
@@ -56,11 +56,13 @@ int bubbleSort(int *nums, int n) {
     for (int i = n - 1; i > 0; i--) {
         // 内循环：冒泡操作
         for (int j = 0; j < i; j++) {
-            // 交换 nums[j] 与 nums[j + 1]
-            int tmp = nums[j];
-            nums[j] = nums[j + 1];
-            nums[j + 1] = tmp;
-            count += 3;  // 元素交换包含 3 个单元操作
+            if (nums[j] > nums[j + 1]) {
+                // 交换 nums[j] 与 nums[j + 1]
+                int tmp = nums[j];
+                nums[j] = nums[j + 1];
+                nums[j + 1] = tmp;
+                count += 3;  // 元素交换包含 3 个单元操作
+            }
         }
     }
     return count;
diff --git a/codes/zig/build.zig b/codes/zig/build.zig
index 9584ba4b3..1a9fb0fba 100644
--- a/codes/zig/build.zig
+++ b/codes/zig/build.zig
@@ -5,7 +5,7 @@
 const std = @import("std");
 
 // Zig Version: 0.10.0
-// Zig Codes Build Command: zig build
+// Build Command: zig build
 pub fn build(b: *std.build.Builder) void {
     const target = b.standardTargetOptions(.{});
     const mode = b.standardReleaseOptions();
diff --git a/codes/zig/chapter_computational_complexity/time_complexity.zig b/codes/zig/chapter_computational_complexity/time_complexity.zig
index ef8d7fe65..3b45ed79f 100644
--- a/codes/zig/chapter_computational_complexity/time_complexity.zig
+++ b/codes/zig/chapter_computational_complexity/time_complexity.zig
@@ -59,11 +59,13 @@ fn bubbleSort(nums: []i32) i32 {
         var j: usize = 0;
         // 内循环：冒泡操作
         while (j < i) : (j += 1) {
-            // 交换 nums[j] 与 nums[j + 1]
-            var tmp = nums[j];
-            nums[j] = nums[j + 1];
-            nums[j + 1] = tmp;
-            count += 3;  // 元素交换包含 3 个单元操作
+            if (nums[j] > nums[j + 1]) {
+                // 交换 nums[j] 与 nums[j + 1]
+                var tmp = nums[j];
+                nums[j] = nums[j + 1];
+                nums[j + 1] = tmp;
+                count += 3;  // 元素交换包含 3 个单元操作
+            }
         }
     }
     return count;

From 749570da0d63df16777dca82b31c7d1d15fd355b Mon Sep 17 00:00:00 2001
From: sjinzh <99076655+sjinzh@users.noreply.github.com>
Date: Tue, 10 Jan 2023 19:44:04 +0800
Subject: [PATCH 152/158] fix bug

---
 codes/zig/chapter_computational_complexity/time_complexity.zig  | 2 +-
 .../worst_best_time_complexity.zig                              | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/codes/zig/chapter_computational_complexity/time_complexity.zig b/codes/zig/chapter_computational_complexity/time_complexity.zig
index 3b45ed79f..40f609459 100644
--- a/codes/zig/chapter_computational_complexity/time_complexity.zig
+++ b/codes/zig/chapter_computational_complexity/time_complexity.zig
@@ -140,7 +140,7 @@ fn factorialRecur(n: i32) i32 {
 }
 
 // Driver Code
-pub fn main() void {
+pub fn main() !void {
     // 查看本地CPU架构和操作系统信息
     var native_target_info = try std.zig.system.NativeTargetInfo.detect(std.zig.CrossTarget{});
     std.debug.print("Native Info: CPU Arch = {}, OS = {}\n", .{native_target_info.target.cpu.arch, native_target_info.target.os.tag});
diff --git a/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig b/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig
index 42961aafb..f9fcd2f67 100644
--- a/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig
+++ b/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig
@@ -27,7 +27,7 @@ pub fn findOne(nums: []i32) i32 {
 }
 
 // Driver Code
-pub fn main() void {
+pub fn main() !void {
     // 查看本地CPU架构和操作系统信息
     var native_target_info = try std.zig.system.NativeTargetInfo.detect(std.zig.CrossTarget{});
     std.debug.print("Native Info: CPU Arch = {}, OS = {}\n", .{native_target_info.target.cpu.arch, native_target_info.target.os.tag});

From 17de5fd5d17637d15ac837beec74983401927b4b Mon Sep 17 00:00:00 2001
From: reanon <793584285@qq.com>
Date: Mon, 9 Jan 2023 17:25:27 +0800
Subject: [PATCH 153/158] feat(include): add c code

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index c960a1bb3..ccb5e1b1e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,8 @@
 # Editor
 .vscode/
 .idea/
+cmake-build-debug/
+CMakeLists.txt
 hello-algo.iml
 
 # mkdocs files

From 24cdcd54df0b2f0c01a4cbf5ece35496a0b0cf08 Mon Sep 17 00:00:00 2001
From: reanon <793584285@qq.com>
Date: Wed, 11 Jan 2023 00:48:48 +0800
Subject: [PATCH 154/158] feat(codes/c): add C include/ codes and modify exist
 C codes

---
 .gitignore                                    |   2 +-
 codes/c/CMakeLists.txt                        |  11 ++
 .../CMakeLists.txt                            |   1 +
 codes/c/chapter_array_and_linkedlist/array.c  |  10 +-
 .../CMakeLists.txt                            |   2 +
 .../worst_best_time_complexity.c              |   3 +-
 codes/c/chapter_sorting/CMakeLists.txt        |   2 +
 codes/c/chapter_sorting/bubble_sort.c         |   4 +-
 codes/c/chapter_sorting/insertion_sort.c      |   2 +-
 codes/c/include/CMakeLists.txt                |   4 +
 codes/c/include/PrintUtil.h                   |  28 ----
 codes/c/include/include.h                     |  19 ++-
 codes/c/include/include_test.c                |  38 +++++
 codes/c/include/list_node.h                   |  72 ++++++++++
 codes/c/include/print_util.h                  | 135 ++++++++++++++++++
 codes/c/include/tree_node.h                   | 131 +++++++++++++++++
 16 files changed, 423 insertions(+), 41 deletions(-)
 create mode 100644 codes/c/CMakeLists.txt
 create mode 100644 codes/c/chapter_array_and_linkedlist/CMakeLists.txt
 create mode 100644 codes/c/chapter_computational_complexity/CMakeLists.txt
 create mode 100644 codes/c/chapter_sorting/CMakeLists.txt
 create mode 100644 codes/c/include/CMakeLists.txt
 delete mode 100644 codes/c/include/PrintUtil.h
 create mode 100644 codes/c/include/include_test.c
 create mode 100644 codes/c/include/list_node.h
 create mode 100644 codes/c/include/print_util.h
 create mode 100644 codes/c/include/tree_node.h

diff --git a/.gitignore b/.gitignore
index ccb5e1b1e..52026b066 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,8 +5,8 @@
 .vscode/
 .idea/
 cmake-build-debug/
-CMakeLists.txt
 hello-algo.iml
+*.dSYM/
 
 # mkdocs files
 site/
diff --git a/codes/c/CMakeLists.txt b/codes/c/CMakeLists.txt
new file mode 100644
index 000000000..dc9e56af3
--- /dev/null
+++ b/codes/c/CMakeLists.txt
@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.10)
+project(hello_algo C)
+
+set(CMAKE_C_STANDARD 11)
+
+include_directories(./include)
+
+add_subdirectory(include)
+add_subdirectory(chapter_computational_complexity)
+add_subdirectory(chapter_array_and_linkedlist)
+add_subdirectory(chapter_sorting)
diff --git a/codes/c/chapter_array_and_linkedlist/CMakeLists.txt b/codes/c/chapter_array_and_linkedlist/CMakeLists.txt
new file mode 100644
index 000000000..24658b301
--- /dev/null
+++ b/codes/c/chapter_array_and_linkedlist/CMakeLists.txt
@@ -0,0 +1 @@
+add_executable(array array.c)
\ No newline at end of file
diff --git a/codes/c/chapter_array_and_linkedlist/array.c b/codes/c/chapter_array_and_linkedlist/array.c
index 33dc99903..11fcb67f9 100644
--- a/codes/c/chapter_array_and_linkedlist/array.c
+++ b/codes/c/chapter_array_and_linkedlist/array.c
@@ -74,11 +74,11 @@ int main() {
     int size = 5;
     int arr[5];
     printf("数组 arr = ");
-    printArray(arr, size);
+    PrintArray(arr, size);
 
     int nums[5] = { 1, 3, 2, 5, 4 };
     printf("数组 nums = ");
-    printArray(nums, size);
+    PrintArray(nums, size);
     
     /* 随机访问 */
     int randomNum = randomAccess(nums, size);
@@ -89,17 +89,17 @@ int main() {
     int* res = extend(nums, size, enlarge);
     size += enlarge;
     printf("将数组长度扩展至 8 ，得到 nums = ");
-    printArray(res, size);
+    PrintArray(res, size);
     
     /* 插入元素 */
     insert(res, size, 6, 3);
     printf("在索引 3 处插入数字 6 ，得到 nums = ");
-    printArray(res, size);
+    PrintArray(res, size);
 
     /* 删除元素 */
     removeItem(res, size, 2);
     printf("删除索引 2 处的元素，得到 nums = ");
-    printArray(res, size);
+    PrintArray(res, size);
     
     /* 遍历数组 */
     traverse(res, size);
diff --git a/codes/c/chapter_computational_complexity/CMakeLists.txt b/codes/c/chapter_computational_complexity/CMakeLists.txt
new file mode 100644
index 000000000..d9e55dcf1
--- /dev/null
+++ b/codes/c/chapter_computational_complexity/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_executable(time_complexity time_complexity.c )
+add_executable(worst_best_time_complexity worst_best_time_complexity.c)
\ No newline at end of file
diff --git a/codes/c/chapter_computational_complexity/worst_best_time_complexity.c b/codes/c/chapter_computational_complexity/worst_best_time_complexity.c
index 2570ff3c3..531a76e51 100644
--- a/codes/c/chapter_computational_complexity/worst_best_time_complexity.c
+++ b/codes/c/chapter_computational_complexity/worst_best_time_complexity.c
@@ -41,7 +41,7 @@ int main(int argc, char *argv[]) {
         int *nums = randomNumbers(n);
         int index = findOne(nums, n);
         printf("\n数组 [ 1, 2, ..., n ] 被打乱后 = ");
-        printArray(nums, n);
+        PrintArray(nums, n);
         printf("数字 1 的索引为 %d\n", index);
         // 释放堆区内存
         if (nums != NULL) {
@@ -49,6 +49,5 @@ int main(int argc, char *argv[]) {
             nums = NULL;
         }
     }
-    getchar();
     return 0;
 }
diff --git a/codes/c/chapter_sorting/CMakeLists.txt b/codes/c/chapter_sorting/CMakeLists.txt
new file mode 100644
index 000000000..192e1cb97
--- /dev/null
+++ b/codes/c/chapter_sorting/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_executable(bubble_sort bubble_sort.c)
+add_executable(insertion_sort insertion_sort.c)
\ No newline at end of file
diff --git a/codes/c/chapter_sorting/bubble_sort.c b/codes/c/chapter_sorting/bubble_sort.c
index 5c74d9e4e..4a2a24b44 100644
--- a/codes/c/chapter_sorting/bubble_sort.c
+++ b/codes/c/chapter_sorting/bubble_sort.c
@@ -50,14 +50,14 @@ void bubble_sort_with_flag(int nums[], int size) {
 /* Driver Code */
 int main() {
     int nums[6] = {4, 1, 3, 1, 5, 2};
-    printf("冒泡排序后:\n");
+    printf("冒泡排序后: ");
     bubble_sort(nums, 6);
     for (int i = 0; i < 6; i++)
     {
         printf("%d ", nums[i]);
     }
 
-    printf("优化版冒泡排序后:\n");
+    printf("\n优化版冒泡排序后: ");
     bubble_sort_with_flag(nums, 6);
     for (int i = 0; i < 6; i++)
     {
diff --git a/codes/c/chapter_sorting/insertion_sort.c b/codes/c/chapter_sorting/insertion_sort.c
index 80e8b127b..f81b8d43e 100644
--- a/codes/c/chapter_sorting/insertion_sort.c
+++ b/codes/c/chapter_sorting/insertion_sort.c
@@ -28,7 +28,7 @@ void insertionSort(int nums[], int size) {
 int main() {
     int nums[] = {4, 1, 3, 1, 5, 2};
     insertionSort(nums, 6);
-    printf("插入排序完成后 nums = \n");
+    printf("插入排序完成后 nums = ");
     for (int i = 0; i < 6; i++)
     {
         printf("%d ", nums[i]);
diff --git a/codes/c/include/CMakeLists.txt b/codes/c/include/CMakeLists.txt
new file mode 100644
index 000000000..4189ae334
--- /dev/null
+++ b/codes/c/include/CMakeLists.txt
@@ -0,0 +1,4 @@
+add_executable(include
+        include_test.c
+        include.h print_util.h
+        list_node.h tree_node.h)
\ No newline at end of file
diff --git a/codes/c/include/PrintUtil.h b/codes/c/include/PrintUtil.h
deleted file mode 100644
index 59a8eac1b..000000000
--- a/codes/c/include/PrintUtil.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * File: PrintUtil.h
- * Created Time: 2022-12-21
- * Author: MolDum (moldum@163.com)
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-// #include "ListNode.h"
-// #include "TreeNode.h"
-
-/**
- * @brief Print an Array
- * 
- * @param arr 
- * @param n 
- */
-
-static void printArray(int* arr, int n)
-{
-    printf("[");
-    for (int i = 0; i < n - 1; i++) {
-        printf("%d, ", arr[i]);
-    }
-    printf("%d]\n", arr[n-1]);
-}
diff --git a/codes/c/include/include.h b/codes/c/include/include.h
index 2c4fd9252..9f30b0529 100644
--- a/codes/c/include/include.h
+++ b/codes/c/include/include.h
@@ -1,13 +1,28 @@
 /**
  * File: include.h
  * Created Time: 2022-12-20
- * Author: MolDuM (moldum@163.com)
+ * Author: MolDuM (moldum@163.com)、Reanon (793584285@qq.com)
  */
 
+#ifndef C_INCLUDE_H
+#define C_INCLUDE_H
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdbool.h>
 #include <time.h>
 
-#include "PrintUtil.h"
+#include "list_node.h"
+#include "tree_node.h"
+#include "print_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // C_INCLUDE_H
diff --git a/codes/c/include/include_test.c b/codes/c/include/include_test.c
new file mode 100644
index 000000000..baa8e649d
--- /dev/null
+++ b/codes/c/include/include_test.c
@@ -0,0 +1,38 @@
+/**
+ * File: include_test.c
+ * Created Time: 2023-01-10
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#include "include.h"
+
+void testListNode() {
+    int nums[] = {2, 3, 5, 6, 7};
+    int size = sizeof(nums) / sizeof(int);
+    ListNode *head = ArrayToLinkedList(nums, size);
+    PrintLinkedList(head);
+
+    ListNode *node = GetListNode(head, 5);
+    printf("find node: %d\n", node->val);
+}
+
+void testTreeNode() {
+    int nums[] = {1, 2, 3, NIL, 5, 6, NIL};
+    int size = sizeof(nums) / sizeof(int);
+    TreeNode *root = ArrayToTree(nums, size);
+
+    // print tree
+    PrintTree(root);
+
+    // tree to arr
+    int *arr = TreeToArray(root);
+    PrintArray(arr, size);
+}
+
+int main(int argc, char *argv[]) {
+    printf("==testListNode==\n");
+    testListNode();
+    printf("==testTreeNode==\n");
+    testTreeNode();
+    return 0;
+}
diff --git a/codes/c/include/list_node.h b/codes/c/include/list_node.h
new file mode 100644
index 000000000..5597d2102
--- /dev/null
+++ b/codes/c/include/list_node.h
@@ -0,0 +1,72 @@
+/**
+ * File: list_node.h
+ * Created Time: 2023-01-09
+ * Author: Reanon (793584285@qq.com)
+ */
+#ifndef LIST_NODE_H
+#define LIST_NODE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Definition for a singly-linked list node
+ *
+ */
+struct ListNode {
+    int val;               // 结点值
+    struct ListNode *next; // 指向下一结点的指针（引用）
+};
+
+// typedef 为 C 语言的关键字，作用是为一种数据类型定义一个新名字
+typedef struct ListNode ListNode;
+
+ListNode *NewListNode(int val) {
+    ListNode *node, *next;
+    node = (ListNode *) malloc(sizeof(ListNode));
+    node->val = val;
+    node->next = NULL;
+    return node;
+}
+
+/**
+ * @brief Generate a linked list with a vector
+ *
+ * @param list
+ * @return ListNode*
+ */
+
+ListNode *ArrayToLinkedList(const int *arr, size_t size) {
+    if (size <= 0) {
+        return NULL;
+    }
+
+    ListNode *dummy = NewListNode(0);
+    ListNode *node = dummy;
+    for (int i = 0; i < size; i++) {
+        node->next = NewListNode(arr[i]);
+        node = node->next;
+    }
+    return dummy->next;
+}
+
+/**
+ * @brief Get a list node with specific value from a linked list
+ *
+ * @param head
+ * @param val
+ * @return ListNode*
+ */
+ListNode *GetListNode(ListNode *head, int val) {
+    while (head != NULL && head->val != val) {
+        head = head->next;
+    }
+    return head;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // LIST_NODE_H
\ No newline at end of file
diff --git a/codes/c/include/print_util.h b/codes/c/include/print_util.h
new file mode 100644
index 000000000..fcb0a4ca6
--- /dev/null
+++ b/codes/c/include/print_util.h
@@ -0,0 +1,135 @@
+/**
+ * File: print_util.h
+ * Created Time: 2022-12-21
+ * Author: MolDum (moldum@163.com)、Reanon (793584285@qq.com)
+ */
+
+#ifndef PRINT_UTIL_H
+#define PRINT_UTIL_H
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "list_node.h"
+#include "tree_node.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @brief Print an Array
+ *
+ * @param arr
+ * @param size
+ */
+static void PrintArray(int *arr, int size) {
+    printf("[");
+    for (int i = 0; i < size - 1; i++) {
+        if (arr[i] != NIL) {
+            printf("%d, ", arr[i]);
+        } else {
+            printf("NULL, ");
+        }
+    }
+    if (arr[size - 1] != NIL) {
+        printf("%d]\n", arr[size - 1]);
+    }else{
+        printf("NULL]\n");
+    }
+}
+
+/**
+ * @brief Print a linked list
+ *
+ * @param head
+ */
+static void PrintLinkedList(ListNode *node) {
+    if (node == NULL) {
+        return;
+    }
+    while (node->next != NULL) {
+        printf("%d -> ", node->val);
+        node = node->next;
+    }
+    printf("%d\n", node->val);
+}
+
+struct Trunk {
+    struct Trunk *prev;
+    char *str;
+};
+
+typedef struct Trunk Trunk;
+
+Trunk *newTrunk(Trunk *prev, char *str) {
+    Trunk *trunk = (Trunk *) malloc(sizeof(Trunk));
+    trunk->prev = prev;
+    trunk->str = (char *) malloc(sizeof(char) * 10);
+    strcpy(trunk->str, str);
+    return trunk;
+}
+
+/**
+ * @brief Helper function to print branches of the binary tree
+ *
+ * @param trunk
+ */
+void showTrunks(Trunk *trunk) {
+    if (trunk == NULL) {
+        return;
+    }
+    showTrunks(trunk->prev);
+    printf("%s", trunk->str);
+}
+
+/**
+ * Help to print a binary tree, hide more details
+ * @param node
+ * @param prev
+ * @param isLeft
+ */
+static void printTreeHelper(TreeNode *node, Trunk *prev, bool isLeft) {
+    if (node == NULL) {
+        return;
+    }
+    char *prev_str = "    ";
+    Trunk *trunk = newTrunk(prev, prev_str);
+    printTreeHelper(node->right, trunk, true);
+    if (prev == NULL) {
+        trunk->str = "———";
+    } else if (isLeft) {
+        trunk->str = "/———";
+        prev_str = "   |";
+    } else {
+        trunk->str = "\\———";
+        prev->str = prev_str;
+    }
+    showTrunks(trunk);
+    printf("%d\n", node->val);
+
+    if (prev != NULL) {
+        prev->str = prev_str;
+    }
+    trunk->str = "   |";
+
+    printTreeHelper(node->left, trunk, false);
+}
+
+/**
+ * @brief Print a binary tree
+ *
+ * @param head
+ */
+static void PrintTree(TreeNode *root) {
+    printTreeHelper(root, NULL, false);
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PRINT_UTIL_H
diff --git a/codes/c/include/tree_node.h b/codes/c/include/tree_node.h
new file mode 100644
index 000000000..4b0e70187
--- /dev/null
+++ b/codes/c/include/tree_node.h
@@ -0,0 +1,131 @@
+/**
+ * File: tree_node.h
+ * Created Time: 2023-01-09
+ * Author: Reanon (793584285@qq.com)
+ */
+
+
+#ifndef TREE_NODE_H
+#define TREE_NODE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NIL ('#')
+#define MAX_NODE_SIZE 5000
+
+struct TreeNode {
+    int val;
+    int height;
+    struct TreeNode *left;
+    struct TreeNode *right;
+};
+
+typedef struct TreeNode TreeNode;
+
+
+TreeNode *NewTreeNode(int val) {
+    TreeNode *node;
+
+    node = (TreeNode *) malloc(sizeof(TreeNode));
+    node->val = val;
+    node->height = 0;
+    node->left = NULL;
+    node->right = NULL;
+    return node;
+}
+
+/**
+ * @brief Generate a binary tree with an array
+ *
+ * @param arr
+ * @param size
+ * @return TreeNode *
+ */
+TreeNode *ArrayToTree(const int *arr, size_t size) {
+    if (size <= 0) {
+        return NULL;
+    }
+
+    int front, rear, index;
+    TreeNode *root, *node;
+    TreeNode **queue;
+
+    /* 根结点 */
+    root = NewTreeNode(arr[0]);
+    /* 辅助队列 */
+    queue = (TreeNode **) malloc(sizeof(TreeNode) * MAX_NODE_SIZE);
+    // 队列指针
+    front = 0, rear = 0;
+    // 将根结点放入队尾
+    queue[rear++] = root;
+    // 记录遍历数组的索引
+    index = 0;
+    while (front < rear) {
+        // 取队列中的头结点，并让头结点出队
+        node = queue[front++];
+        index++;
+        if (index < size) {
+            if (arr[index] != NIL) {
+                node->left = NewTreeNode(arr[index]);
+                queue[rear++] = node->left;
+            }
+        }
+        index++;
+        if (index < size) {
+            if (arr[index] != NIL) {
+                node->right = NewTreeNode(arr[index]);
+                queue[rear++] = node->right;
+            }
+        }
+    }
+    return root;
+}
+
+
+/**
+ * @brief Generate a binary tree with an array
+ *
+ * @param arr
+ * @param size
+ * @return TreeNode *
+ */
+int *TreeToArray(TreeNode *root) {
+    if (root == NULL) {
+        return NULL;
+    }
+    int front, rear;
+    int index, *arr;
+    TreeNode *node;
+    TreeNode **queue;
+    /* 辅助队列 */
+    queue = (TreeNode **) malloc(sizeof(TreeNode) * MAX_NODE_SIZE);
+    // 队列指针
+    front = 0, rear = 0;
+    // 将根结点放入队尾
+    queue[rear++] = root;
+    /* 辅助数组 */
+    arr = (int *) malloc(sizeof(int) * MAX_NODE_SIZE);
+    // 数组指针
+    index = 0;
+    while (front < rear) {
+        // 取队列中的头结点，并让头结点出队
+        node = queue[front++];
+        if (node != NULL) {
+            arr[index] = node->val;
+            queue[rear++] = node->left;
+            queue[rear++] = node->right;
+        } else {
+            arr[index] = NIL;
+        }
+        index++;
+    }
+    return arr;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TREE_NODE_H

From 8723ca14694b36e00e729739aa1f594eef534814 Mon Sep 17 00:00:00 2001
From: reanon <793584285@qq.com>
Date: Wed, 11 Jan 2023 01:56:08 +0800
Subject: [PATCH 155/158] feat(tree): add C codes

---
 codes/c/CMakeLists.txt                        |  1 +
 codes/c/chapter_tree/CMakeLists.txt           |  4 ++
 codes/c/chapter_tree/binary_search_tree.c     |  8 +++
 codes/c/chapter_tree/binary_tree.c            | 43 +++++++++++
 codes/c/chapter_tree/binary_tree_bfs.c        | 66 +++++++++++++++++
 codes/c/chapter_tree/binary_tree_dfs.c        | 72 +++++++++++++++++++
 .../chapter_tree/binary_search_tree_test.go   |  2 +-
 7 files changed, 195 insertions(+), 1 deletion(-)
 create mode 100644 codes/c/chapter_tree/CMakeLists.txt
 create mode 100644 codes/c/chapter_tree/binary_search_tree.c
 create mode 100644 codes/c/chapter_tree/binary_tree.c
 create mode 100644 codes/c/chapter_tree/binary_tree_bfs.c
 create mode 100644 codes/c/chapter_tree/binary_tree_dfs.c

diff --git a/codes/c/CMakeLists.txt b/codes/c/CMakeLists.txt
index dc9e56af3..1a208dd9d 100644
--- a/codes/c/CMakeLists.txt
+++ b/codes/c/CMakeLists.txt
@@ -9,3 +9,4 @@ add_subdirectory(include)
 add_subdirectory(chapter_computational_complexity)
 add_subdirectory(chapter_array_and_linkedlist)
 add_subdirectory(chapter_sorting)
+add_subdirectory(chapter_tree)
diff --git a/codes/c/chapter_tree/CMakeLists.txt b/codes/c/chapter_tree/CMakeLists.txt
new file mode 100644
index 000000000..779315b7b
--- /dev/null
+++ b/codes/c/chapter_tree/CMakeLists.txt
@@ -0,0 +1,4 @@
+add_executable(binary_search binary_tree.c)
+add_executable(binary_tree_bfs binary_tree_bfs.c)
+add_executable(binary_tree_dfs binary_tree_dfs.c)
+add_executable(binary_search_tree binary_search_tree.c)
diff --git a/codes/c/chapter_tree/binary_search_tree.c b/codes/c/chapter_tree/binary_search_tree.c
new file mode 100644
index 000000000..f993faec3
--- /dev/null
+++ b/codes/c/chapter_tree/binary_search_tree.c
@@ -0,0 +1,8 @@
+/**
+ * File: binary_search_tree.c
+ * Created Time: 2023-01-11
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#include "../include/include.h"
+
diff --git a/codes/c/chapter_tree/binary_tree.c b/codes/c/chapter_tree/binary_tree.c
new file mode 100644
index 000000000..0a2f946a7
--- /dev/null
+++ b/codes/c/chapter_tree/binary_tree.c
@@ -0,0 +1,43 @@
+/**
+ * File: binary_tree.c
+ * Created Time: 2023-01-11
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#include "../include/include.h"
+
+/* Driver Code */
+int main() {
+    /* 初始化二叉树 */
+    // 初始化结点
+    TreeNode* n1 = NewTreeNode(1);
+    TreeNode* n2 = NewTreeNode(2);
+    TreeNode* n3 = NewTreeNode(3);
+    TreeNode* n4 = NewTreeNode(4);
+    TreeNode* n5 = NewTreeNode(5);
+    // 构建引用指向（即指针）
+    n1->left = n2;
+    n1->right = n3;
+    n2->left = n4;
+    n2->right = n5;
+    printf("初始化二叉树\n");
+    PrintTree(n1);
+
+    /* 插入与删除结点 */
+    TreeNode* P = NewTreeNode(0);
+    // 在 n1 -> n2 中间插入结点 P
+    n1->left = P;
+    P->left = n2;
+    printf("插入结点 P 后\n");
+    PrintTree(n1);
+
+    // 删除结点 P
+    n1->left = n2;
+    // 释放内存
+    free(P);
+    printf("删除结点 P 后\n");
+    PrintTree(n1);
+
+    return 0;
+}
+
diff --git a/codes/c/chapter_tree/binary_tree_bfs.c b/codes/c/chapter_tree/binary_tree_bfs.c
new file mode 100644
index 000000000..abad3735f
--- /dev/null
+++ b/codes/c/chapter_tree/binary_tree_bfs.c
@@ -0,0 +1,66 @@
+/**
+ * File: binary_tree_bfs.c
+ * Created Time: 2023-01-11
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#include "../include/include.h"
+
+/* 层序遍历 */
+int *levelOrder(TreeNode *root, int *size) {
+    /* 辅助队列 */
+    int front, rear;
+    int index, *arr;
+    TreeNode *node;
+    TreeNode **queue;
+
+    /* 辅助队列 */
+    queue = (TreeNode **) malloc(sizeof(TreeNode) * MAX_NODE_SIZE);
+    // 队列指针
+    front = 0, rear = 0;
+    // 加入根结点
+    queue[rear++] = root;
+    // 初始化一个列表，用于保存遍历序列
+    /* 辅助数组 */
+    arr = (int *) malloc(sizeof(int) * MAX_NODE_SIZE);
+    // 数组指针
+    index = 0;
+    while (front < rear) {
+        // 队列出队
+        node = queue[front++];
+        // 保存结点
+        arr[index++] = node->val;
+        if (node->left != NULL) {
+            // 左子结点入队
+            queue[rear++] = node->left;
+        }
+        if (node->right != NULL) {
+            // 右子结点入队
+            queue[rear++] = node->right;
+        }
+    }
+    // 更新数组长度的值
+    *size = index;
+    arr = realloc(arr, sizeof(int) * (*size));
+    return arr;
+}
+
+
+/* Driver Code */
+int main() {
+    /* 初始化二叉树 */
+    // 这里借助了一个从数组直接生成二叉树的函数
+    int nums[] = {1, 2, 3, NIL, 5, 6, NIL};
+    int size = sizeof(nums) / sizeof(int);
+    TreeNode *root = ArrayToTree(nums, size);
+    printf("初始化二叉树\n");
+    PrintTree(root);
+
+    /* 层序遍历 */
+    // 需要传入数组的长度
+    int *arr = levelOrder(root, &size);
+    printf("层序遍历的结点打印序列 = ");
+    PrintArray(arr, size);
+
+    return 0;
+}
\ No newline at end of file
diff --git a/codes/c/chapter_tree/binary_tree_dfs.c b/codes/c/chapter_tree/binary_tree_dfs.c
new file mode 100644
index 000000000..f72e6687b
--- /dev/null
+++ b/codes/c/chapter_tree/binary_tree_dfs.c
@@ -0,0 +1,72 @@
+/**
+ * File: binary_tree_dfs.c
+ * Created Time: 2023-01-11
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#include "../include/include.h"
+
+/* 辅助数组，用于存储遍历序列 */
+int *arr;
+
+/* 前序遍历 */
+void preOrder(TreeNode *root, int *size) {
+
+    if (root == NULL) return;
+    // 访问优先级：根结点 -> 左子树 -> 右子树
+    arr[(*size)++] = root->val;
+    preOrder(root->left, size);
+    preOrder(root->right, size);
+}
+
+/* 中序遍历 */
+void inOrder(TreeNode *root, int *size) {
+    if (root == NULL) return;
+    // 访问优先级：左子树 -> 根结点 -> 右子树
+    inOrder(root->left, size);
+    arr[(*size)++] = root->val;
+    inOrder(root->right, size);
+}
+
+/* 后序遍历 */
+void postOrder(TreeNode *root, int *size) {
+    if (root == NULL) return;
+    // 访问优先级：左子树 -> 右子树 -> 根结点
+    postOrder(root->left, size);
+    postOrder(root->right, size);
+    arr[(*size)++] = root->val;
+}
+
+
+/* Driver Code */
+int main() {
+    /* 初始化二叉树 */
+    // 这里借助了一个从数组直接生成二叉树的函数
+    int nums[] = {1, 2, 3, 4, 5, 6, 7};
+    int size = sizeof(nums) / sizt ceof(int);
+    TreeNode *root = ArrayToTree(nums, size);
+    printf("初始化二叉树\n");
+    PrintTree(root);
+
+    /* 前序遍历 */
+    // 初始化辅助数组
+    arr = (int *) malloc(sizeof(int) * MAX_NODE_SIZE);
+    size = 0;
+    preOrder(root, &size);
+    printf("前序遍历的结点打印序列 = ");
+    PrintArray(arr, size);
+
+    /* 中序遍历 */
+    size = 0;
+    inOrder(root, &size);
+    printf("中序遍历的结点打印序列 = ");
+    PrintArray(arr, size);
+
+    /* 后序遍历 */
+    size = 0;
+    postOrder(root, &size);
+    printf("后序遍历的结点打印序列 = ");
+    PrintArray(arr, size);
+
+    return 0;
+}
diff --git a/codes/go/chapter_tree/binary_search_tree_test.go b/codes/go/chapter_tree/binary_search_tree_test.go
index 2109d5a44..2a864d138 100644
--- a/codes/go/chapter_tree/binary_search_tree_test.go
+++ b/codes/go/chapter_tree/binary_search_tree_test.go
@@ -20,7 +20,7 @@ func TestBinarySearchTree(t *testing.T) {
 	fmt.Println("\n二叉树的根结点为:", node.Val)
 
 	// 查找结点
-	node = bst.Search(7)
+	node = bst.search(7)
 	fmt.Println("查找到的结点对象为", node, "，结点值 =", node.Val)
 
 	// 插入结点

From 483925686f7ac8103e88ec02c2f841d82e0b5153 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Wed, 11 Jan 2023 02:45:28 +0800
Subject: [PATCH 156/158] Update time_complexity.md

---
 docs/chapter_computational_complexity/time_complexity.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index ea523b46d..def052c92 100644
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -1434,7 +1434,7 @@ $$
         for (int i = n - 1; i > 0; i--) {
             // 内循环：冒泡操作
             for (int j = 0; j < i; j++) {
-                if (nums[j] > nums [j+1]) 
+                if (nums[j] > nums [j + 1]) 
                 {
                     // 交换 nums[j] 与 nums[j + 1]
                     int tmp = nums[j];

From 3e9edf7115b87cad90077b47d185b37a337a7a03 Mon Sep 17 00:00:00 2001
From: sjinzh <99076655+sjinzh@users.noreply.github.com>
Date: Wed, 11 Jan 2023 12:34:54 +0800
Subject: [PATCH 157/158] delete system info output in zig codes

---
 .../zig/chapter_computational_complexity/leetcode_two_sum.zig | 4 ----
 .../zig/chapter_computational_complexity/space_complexity.zig | 4 ----
 .../zig/chapter_computational_complexity/time_complexity.zig  | 4 ----
 .../worst_best_time_complexity.zig                            | 4 ----
 4 files changed, 16 deletions(-)

diff --git a/codes/zig/chapter_computational_complexity/leetcode_two_sum.zig b/codes/zig/chapter_computational_complexity/leetcode_two_sum.zig
index dc963b595..66b96f95e 100644
--- a/codes/zig/chapter_computational_complexity/leetcode_two_sum.zig
+++ b/codes/zig/chapter_computational_complexity/leetcode_two_sum.zig
@@ -44,10 +44,6 @@ const SolutionHashMap = struct {
 
 // Driver Code
 pub fn main() !void {
-    // 查看本地CPU架构和操作系统信息
-    var native_target_info = try std.zig.system.NativeTargetInfo.detect(std.zig.CrossTarget{});
-    std.debug.print("Native Info: CPU Arch = {}, OS = {}\n", .{native_target_info.target.cpu.arch, native_target_info.target.os.tag});
-
     // ======= Test Case =======
     var nums = [_]i32{ 2, 7, 11, 15 };
     var target: i32 = 9;
diff --git a/codes/zig/chapter_computational_complexity/space_complexity.zig b/codes/zig/chapter_computational_complexity/space_complexity.zig
index 3fe81a706..9798821a5 100644
--- a/codes/zig/chapter_computational_complexity/space_complexity.zig
+++ b/codes/zig/chapter_computational_complexity/space_complexity.zig
@@ -102,10 +102,6 @@ fn buildTree(mem_allocator: std.mem.Allocator, n: i32) !?*inc.TreeNode(i32) {
 
 // Driver Code
 pub fn main() !void {
-    // 查看本地CPU架构和操作系统信息
-    var native_target_info = try std.zig.system.NativeTargetInfo.detect(std.zig.CrossTarget{});
-    std.debug.print("Native Info: CPU Arch = {}, OS = {}\n", .{native_target_info.target.cpu.arch, native_target_info.target.os.tag});
-
     const n: i32 = 5;
     // 常数阶
     constant(n);
diff --git a/codes/zig/chapter_computational_complexity/time_complexity.zig b/codes/zig/chapter_computational_complexity/time_complexity.zig
index 40f609459..047950052 100644
--- a/codes/zig/chapter_computational_complexity/time_complexity.zig
+++ b/codes/zig/chapter_computational_complexity/time_complexity.zig
@@ -141,10 +141,6 @@ fn factorialRecur(n: i32) i32 {
 
 // Driver Code
 pub fn main() !void {
-    // 查看本地CPU架构和操作系统信息
-    var native_target_info = try std.zig.system.NativeTargetInfo.detect(std.zig.CrossTarget{});
-    std.debug.print("Native Info: CPU Arch = {}, OS = {}\n", .{native_target_info.target.cpu.arch, native_target_info.target.os.tag});
-
     // 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
     const n: i32 = 8;
     std.debug.print("输入数据大小 n = {}\n", .{n});
diff --git a/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig b/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig
index f9fcd2f67..0cdd61ebc 100644
--- a/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig
+++ b/codes/zig/chapter_computational_complexity/worst_best_time_complexity.zig
@@ -28,10 +28,6 @@ pub fn findOne(nums: []i32) i32 {
 
 // Driver Code
 pub fn main() !void {
-    // 查看本地CPU架构和操作系统信息
-    var native_target_info = try std.zig.system.NativeTargetInfo.detect(std.zig.CrossTarget{});
-    std.debug.print("Native Info: CPU Arch = {}, OS = {}\n", .{native_target_info.target.cpu.arch, native_target_info.target.os.tag});
-
     var i: i32 = 0;
     while (i < 10) : (i += 1) {
         const n: usize = 100;

From a482f8fd9b122873f831d8161a60eb59f02b57d1 Mon Sep 17 00:00:00 2001
From: JoseHung <1309716944@qq.com>
Date: Wed, 11 Jan 2023 14:44:32 +0800
Subject: [PATCH 158/158] JS code identation of binary search

---
 docs/chapter_searching/binary_search.md | 52 ++++++++++++-------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
index 2bd2d4396..da60b3b43 100644
--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@@ -141,20 +141,20 @@ $$
     ```js title="binary_search.js"
     /* 二分查找（双闭区间） */
     function binarySearch(nums, target) {
-    // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
-    let i = 0, j = nums.length - 1;
-    // 循环，当搜索区间为空时跳出（当 i > j 时为空）
-    while (i <= j) {
-        let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
-        if (nums[m] < target)          // 此情况说明 target 在区间 [m+1, j] 中
-            i = m + 1;
-        else if (nums[m] > target)     // 此情况说明 target 在区间 [i, m-1] 中
-            j = m - 1;
-        else
-            return m;                  // 找到目标元素，返回其索引
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        let i = 0, j = nums.length - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
+            if (nums[m] < target)          // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            else if (nums[m] > target)     // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            else
+                return m;                  // 找到目标元素，返回其索引
         }
-    // 未找到目标元素，返回 -1
-    return -1;
+        // 未找到目标元素，返回 -1
+        return -1;
     }
     ```
 
@@ -311,20 +311,20 @@ $$
     ```js title="binary_search.js"
     /* 二分查找（左闭右开） */
     function binarySearch1(nums, target) {
-    // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
-    let i = 0, j = nums.length;
-    // 循环，当搜索区间为空时跳出（当 i = j 时为空）
-    while (i < j) {
-        let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
-        if (nums[m] < target)          // 此情况说明 target 在区间 [m+1, j] 中
-            i = m + 1;
-        else if (nums[m] > target)     // 此情况说明 target 在区间 [i, m] 中
-            j = m;
-        else                           // 找到目标元素，返回其索引
-            return m;
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        let i = 0, j = nums.length;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
+            if (nums[m] < target)          // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            else if (nums[m] > target)     // 此情况说明 target 在区间 [i, m] 中
+                j = m;
+            else                           // 找到目标元素，返回其索引
+                return m;
         }
-    // 未找到目标元素，返回 -1
-    return -1;
+        // 未找到目标元素，返回 -1
+        return -1;
     }
     ```