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):