Unify the comment style of python codes

docs/chapter_array_and_linkedlist/array.md

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

docs/chapter_array_and_linkedlist/linked_list.md

@@ -1,10 +1,10 @@
 # 链表
 
-内存空间是所有程序的公共资源，排除已被占用的内存空间，空闲内存空间通常散落在内存各处。在上一节中，我们提到存储数组的内存空间必须是连续的，而当我们需要申请一个非常大的数组时，空闲内存中可能没有这么大的连续空间。
+内存空间是所有程序的公共资源，排除已被占用的内存空间，空闲内存空间通常散落在内存各处。在上一节中，我们提到存储数组的内存空间必须是连续的，而当我们需要申请一个非常大的数组时，空闲内存中可能没有这么大的连续空间。与数组相比，链表更具灵活性，它可以被存储在非连续的内存空间中。
 
-与数组相比，链表更具灵活性，因为它可以存储在非连续的内存空间。「链表 Linked List」是一种线性数据结构，其每个元素都是一个节点对象，各个节点之间通过指针连接，从当前节点通过指针可以访问到下一个节点。由于指针记录了下个节点的内存地址，因此无需保证内存地址的连续性，从而可以将各个节点分散存储在内存各处。
+「链表 Linked List」是一种线性数据结构，其每个元素都是一个节点对象，各个节点之间通过指针连接，从当前节点通过指针可以访问到下一个节点。**由于指针记录了下个节点的内存地址，因此无需保证内存地址的连续性**，从而可以将各个节点分散存储在内存各处。
 
-链表「节点 Node」包含两项数据，一是节点「值 Value」，二是指向下一节点的「指针 Pointer」，或称指向下一节点的「引用 Reference」。
+链表「节点 Node」包含两项数据，一是节点「值 Value」，二是指向下一节点的「指针 Pointer」，或称「引用 Reference」。
 
 ![链表定义与存储方式](linked_list.assets/linkedlist_definition.png)
 
@@ -33,8 +33,8 @@
 === "Python"
 
     ```python title=""
-    """ 链表节点类 """ 
     class ListNode:
+        """链表节点类"""
         def __init__(self, val: int):
             self.val: int = val                  # 节点值
             self.next: Optional[ListNode] = None # 指向下一节点的指针（引用）
@@ -201,7 +201,7 @@
 === "Python"
 
     ```python title="linked_list.py"
-    """ 初始化链表 1 -> 3 -> 2 -> 5 -> 4 """
+    # 初始化链表 1 -> 3 -> 2 -> 5 -> 4
     # 初始化各个节点 
     n0 = ListNode(1)
     n1 = ListNode(3)
@@ -629,8 +629,8 @@
 === "Python"
 
     ```python title=""
-    """ 双向链表节点类 """ 
     class ListNode:
+        """双向链表节点类"""
         def __init__(self, val: int):
             self.val: int = val                   # 节点值
             self.next: Optional[ListNode] = None  # 指向后继节点的指针（引用）

docs/chapter_array_and_linkedlist/list.md

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