build

chapter_stack_and_queue/deque.md

@@ -591,31 +591,33 @@ comments: true
 
     ```python title="linkedlist_deque.py"
     class ListNode:
-        """ 双向链表节点 """
+        """双向链表节点"""
+
         def __init__(self, val: int) -> None:
-            """ 构造方法 """
+            """构造方法"""
             self.val: int = val
             self.next: ListNode | None = None  # 后继节点引用（指针）
             self.prev: ListNode | None = None  # 前驱节点引用（指针）
 
     class LinkedListDeque:
-        """ 基于双向链表实现的双向队列 """
+        """基于双向链表实现的双向队列"""
+
         def __init__(self) -> None:
-            """ 构造方法 """
-            self.front: ListNode | None = None # 头节点 front
+            """构造方法"""
+            self.front: ListNode | None = None  # 头节点 front
             self.rear: ListNode | None = None  # 尾节点 rear
-            self.__size: int = 0        # 双向队列的长度
+            self.__size: int = 0  # 双向队列的长度
 
         def size(self) -> int:
-            """ 获取双向队列的长度 """
+            """获取双向队列的长度"""
             return self.__size
 
         def is_empty(self) -> bool:
-            """ 判断双向队列是否为空 """
+            """判断双向队列是否为空"""
             return self.size() == 0
 
         def push(self, num: int, is_front: bool) -> None:
-            """ 入队操作 """
+            """入队操作"""
             node = ListNode(num)
             # 若链表为空，则令 front, rear 都指向 node
             if self.is_empty():
@@ -635,15 +637,15 @@ comments: true
             self.__size += 1  # 更新队列长度
 
         def push_first(self, num: int) -> None:
-            """ 队首入队 """
+            """队首入队"""
             self.push(num, True)
 
         def push_last(self, num: int) -> None:
-            """ 队尾入队 """
+            """队尾入队"""
             self.push(num, False)
 
         def pop(self, is_front: bool) -> int:
-            """ 出队操作 """
+            """出队操作"""
             # 若队列为空，直接返回 None
             if self.is_empty():
                 return None
@@ -669,23 +671,23 @@ comments: true
             return val
 
         def pop_first(self) -> int:
-            """ 队首出队 """
+            """队首出队"""
             return self.pop(True)
 
         def pop_last(self) -> int:
-            """ 队尾出队 """
+            """队尾出队"""
             return self.pop(False)
 
         def peek_first(self) -> int:
-            """ 访问队首元素 """
+            """访问队首元素"""
             return None if self.is_empty() else self.front.val
 
         def peek_last(self) -> int:
-            """ 访问队尾元素 """
+            """访问队尾元素"""
             return None if self.is_empty() else self.rear.val
 
         def to_array(self) -> list[int]:
-            """ 返回数组用于打印 """
+            """返回数组用于打印"""
             node: ListNode | None = self.front
             res: list[int] = [0] * self.size()
             for i in range(self.size()):
@@ -1583,34 +1585,35 @@ comments: true
 
     ```python title="array_deque.py"
     class ArrayDeque:
-        """ 基于环形数组实现的双向队列 """
+        """基于环形数组实现的双向队列"""
+
         def __init__(self, capacity: int) -> None:
-            """ 构造方法 """
+            """构造方法"""
             self.__nums: list[int] = [0] * capacity
             self.__front: int = 0
             self.__size: int = 0
 
         def capacity(self) -> int:
-            """ 获取双向队列的容量 """
+            """获取双向队列的容量"""
             return len(self.__nums)
 
         def size(self) -> int:
-            """ 获取双向队列的长度 """
+            """获取双向队列的长度"""
             return self.__size
 
         def is_empty(self) -> bool:
-            """ 判断双向队列是否为空 """
+            """判断双向队列是否为空"""
             return self.__size == 0
 
         def index(self, i: int) -> int:
-            """ 计算环形数组索引 """
+            """计算环形数组索引"""
             # 通过取余操作实现数组首尾相连
             # 当 i 越过数组尾部后，回到头部
             # 当 i 越过数组头部后，回到尾部
             return (i + self.capacity()) % self.capacity()
 
         def push_first(self, num: int) -> None:
-            """ 队首入队 """
+            """队首入队"""
             if self.__size == self.capacity():
                 print("双向队列已满")
                 return
@@ -1622,7 +1625,7 @@ comments: true
             self.__size += 1
 
         def push_last(self, num: int) -> None:
-            """ 队尾入队 """
+            """队尾入队"""
             if self.__size == self.capacity():
                 print("双向队列已满")
                 return
@@ -1633,7 +1636,7 @@ comments: true
             self.__size += 1
 
         def pop_first(self) -> int:
-            """ 队首出队 """
+            """队首出队"""
             num = self.peek_first()
             # 队首指针向后移动一位
             self.__front = self.index(self.__front + 1)
@@ -1641,25 +1644,25 @@ comments: true
             return num
 
         def pop_last(self) -> int:
-            """ 队尾出队 """
+            """队尾出队"""
             num = self.peek_last()
             self.__size -= 1
             return num
 
         def peek_first(self) -> int:
-            """ 访问队首元素 """
+            """访问队首元素"""
             assert not self.is_empty(), "双向队列为空"
             return self.__nums[self.__front]
 
         def peek_last(self) -> int:
-            """ 访问队尾元素 """
+            """访问队尾元素"""
             assert not self.is_empty(), "双向队列为空"
             # 计算尾元素索引
             last = self.index(self.__front + self.__size - 1)
             return self.__nums[last]
 
         def to_array(self) -> list[int]:
-            """ 返回数组用于打印 """
+            """返回数组用于打印"""
             # 仅转换有效长度范围内的列表元素
             res = []
             for i in range(self.__size):

chapter_stack_and_queue/queue.md

@@ -428,23 +428,24 @@ comments: true
 
     ```python title="linkedlist_queue.py"
     class LinkedListQueue:
-        """ 基于链表实现的队列 """
+        """基于链表实现的队列"""
+
         def __init__(self):
-            """ 构造方法 """
+            """构造方法"""
             self.__front: ListNode | None = None  # 头节点 front
-            self.__rear: ListNode | None = None   # 尾节点 rear
+            self.__rear: ListNode | None = None  # 尾节点 rear
             self.__size: int = 0
 
         def size(self) -> int:
-            """ 获取队列的长度 """
+            """获取队列的长度"""
             return self.__size
 
         def is_empty(self) -> bool:
-            """ 判断队列是否为空 """
+            """判断队列是否为空"""
             return not self.__front
 
         def push(self, num: int) -> None:
-            """ 入队 """
+            """入队"""
             # 尾节点后添加 num
             node = ListNode(num)
             # 如果队列为空，则令头、尾节点都指向该节点
@@ -458,7 +459,7 @@ comments: true
             self.__size += 1
 
         def pop(self) -> int:
-            """ 出队 """
+            """出队"""
             num = self.peek()
             # 删除头节点
             self.__front = self.__front.next
@@ -466,14 +467,14 @@ comments: true
             return num
 
         def peek(self) -> int:
-            """ 访问队首元素 """
+            """访问队首元素"""
             if self.size() == 0:
                 print("队列为空")
                 return False
             return self.__front.val
 
         def to_list(self) -> list[int]:
-            """ 转化为列表用于打印 """
+            """转化为列表用于打印"""
             queue = []
             temp = self.__front
             while temp:
@@ -1103,27 +1104,28 @@ comments: true
 
     ```python title="array_queue.py"
     class ArrayQueue:
-        """ 基于环形数组实现的队列 """
+        """基于环形数组实现的队列"""
+
         def __init__(self, size: int) -> None:
-            """ 构造方法 """
+            """构造方法"""
             self.__nums: list[int] = [0] * size  # 用于存储队列元素的数组
-            self.__front: int = 0          # 队首指针，指向队首元素
-            self.__size: int = 0           # 队列长度
+            self.__front: int = 0  # 队首指针，指向队首元素
+            self.__size: int = 0  # 队列长度
 
         def capacity(self) -> int:
-            """ 获取队列的容量 """
+            """获取队列的容量"""
             return len(self.__nums)
 
         def size(self) -> int:
-            """ 获取队列的长度 """
+            """获取队列的长度"""
             return self.__size
 
         def is_empty(self) -> bool:
-            """ 判断队列是否为空 """
+            """判断队列是否为空"""
             return self.__size == 0
 
         def push(self, num: int) -> None:
-            """ 入队 """
+            """入队"""
             assert self.__size < self.capacity(), "队列已满"
             # 计算尾指针，指向队尾索引 + 1
             # 通过取余操作，实现 rear 越过数组尾部后回到头部
@@ -1133,7 +1135,7 @@ comments: true
             self.__size += 1
 
         def pop(self) -> int:
-            """ 出队 """
+            """出队"""
             num: int = self.peek()
             # 队首指针向后移动一位，若越过尾部则返回到数组头部
             self.__front = (self.__front + 1) % self.capacity()
@@ -1141,12 +1143,12 @@ comments: true
             return num
 
         def peek(self) -> int:
-            """ 访问队首元素 """
+            """访问队首元素"""
             assert not self.is_empty(), "队列为空"
             return self.__nums[self.__front]
 
         def to_list(self) -> list[int]:
-            """ 返回列表用于打印 """
+            """返回列表用于打印"""
             res: list[int] = [0] * self.size()
             j: int = self.__front
             for i in range(self.size()):

chapter_stack_and_queue/stack.md

@@ -409,42 +409,44 @@ comments: true
 
     ```python title="linkedlist_stack.py"
     class LinkedListStack:
-        """ 基于链表实现的栈 """
+        """基于链表实现的栈"""
+
         def __init__(self):
-            """ 构造方法 """
+            """构造方法"""
             self.__peek: ListNode | None = None
             self.__size: int = 0
 
         def size(self) -> int:
-            """ 获取栈的长度 """
+            """获取栈的长度"""
             return self.__size
 
         def is_empty(self) -> bool:
-            """ 判断栈是否为空 """
+            """判断栈是否为空"""
             return not self.__peek
 
         def push(self, val: int) -> None:
-            """ 入栈 """
+            """入栈"""
             node = ListNode(val)
             node.next = self.__peek
             self.__peek = node
             self.__size += 1
 
         def pop(self) -> int:
-            """ 出栈 """
+            """出栈"""
             num: int = self.peek()
             self.__peek = self.__peek.next
             self.__size -= 1
             return num
 
         def peek(self) -> int:
-            """ 访问栈顶元素 """
+            """访问栈顶元素"""
             # 判空处理
-            if not self.__peek: return None
+            if not self.__peek:
+                return None
             return self.__peek.val
 
         def to_list(self) -> list[int]:
-            """ 转化为列表用于打印 """
+            """转化为列表用于打印"""
             arr: list[int] = []
             node = self.__peek
             while node:
@@ -951,35 +953,36 @@ comments: true
 
     ```python title="array_stack.py"
     class ArrayStack:
-        """ 基于数组实现的栈 """
+        """基于数组实现的栈"""
+
         def __init__(self) -> None:
-            """ 构造方法 """
+            """构造方法"""
             self.__stack: list[int] = []
 
         def size(self) -> int:
-            """ 获取栈的长度 """
+            """获取栈的长度"""
             return len(self.__stack)
 
         def is_empty(self) -> bool:
-            """ 判断栈是否为空 """
+            """判断栈是否为空"""
             return self.__stack == []
 
         def push(self, item: int) -> None:
-            """ 入栈 """
+            """入栈"""
             self.__stack.append(item)
 
         def pop(self) -> int:
-            """ 出栈 """
+            """出栈"""
             assert not self.is_empty(), "栈为空"
             return self.__stack.pop()
 
         def peek(self) -> int:
-            """ 访问栈顶元素 """
+            """访问栈顶元素"""
             assert not self.is_empty(), "栈为空"
             return self.__stack[-1]
-        
+
         def to_list(self) -> list[int]:
-            """ 返回列表用于打印 """
+            """返回列表用于打印"""
             return self.__stack
     ```