build

docs/chapter_stack_and_queue/queue.md

@@ -345,50 +345,50 @@ comments: true
 
         def __init__(self):
             """构造方法"""
-            self.__front: ListNode | None = None  # 头节点 front
-            self.__rear: ListNode | None = None  # 尾节点 rear
-            self.__size: int = 0
+            self._front: ListNode | None = None  # 头节点 front
+            self._rear: ListNode | None = None  # 尾节点 rear
+            self._size: int = 0
 
         def size(self) -> int:
             """获取队列的长度"""
-            return self.__size
+            return self._size
 
         def is_empty(self) -> bool:
             """判断队列是否为空"""
-            return not self.__front
+            return not self._front
 
         def push(self, num: int):
             """入队"""
             # 尾节点后添加 num
             node = ListNode(num)
             # 如果队列为空，则令头、尾节点都指向该节点
-            if self.__front is None:
-                self.__front = node
-                self.__rear = node
+            if self._front is None:
+                self._front = node
+                self._rear = node
             # 如果队列不为空，则将该节点添加到尾节点后
             else:
-                self.__rear.next = node
-                self.__rear = node
-            self.__size += 1
+                self._rear.next = node
+                self._rear = node
+            self._size += 1
 
         def pop(self) -> int:
             """出队"""
             num = self.peek()
             # 删除头节点
-            self.__front = self.__front.next
-            self.__size -= 1
+            self._front = self._front.next
+            self._size -= 1
             return num
 
         def peek(self) -> int:
             """访问队首元素"""
             if self.is_empty():
                 raise IndexError("队列为空")
-            return self.__front.val
+            return self._front.val
 
         def to_list(self) -> list[int]:
             """转化为列表用于打印"""
             queue = []
-            temp = self.__front
+            temp = self._front
             while temp:
                 queue.append(temp.val)
                 temp = temp.next
@@ -1240,53 +1240,53 @@ comments: true
 
         def __init__(self, size: int):
             """构造方法"""
-            self.__nums: list[int] = [0] * size  # 用于存储队列元素的数组
-            self.__front: int = 0  # 队首指针，指向队首元素
-            self.__size: int = 0  # 队列长度
+            self._nums: list[int] = [0] * size  # 用于存储队列元素的数组
+            self._front: int = 0  # 队首指针，指向队首元素
+            self._size: int = 0  # 队列长度
 
         def capacity(self) -> int:
             """获取队列的容量"""
-            return len(self.__nums)
+            return len(self._nums)
 
         def size(self) -> int:
             """获取队列的长度"""
-            return self.__size
+            return self._size
 
         def is_empty(self) -> bool:
             """判断队列是否为空"""
-            return self.__size == 0
+            return self._size == 0
 
         def push(self, num: int):
             """入队"""
-            if self.__size == self.capacity():
+            if self._size == self.capacity():
                 raise IndexError("队列已满")
             # 计算尾指针，指向队尾索引 + 1
             # 通过取余操作，实现 rear 越过数组尾部后回到头部
-            rear: int = (self.__front + self.__size) % self.capacity()
+            rear: int = (self._front + self._size) % self.capacity()
             # 将 num 添加至队尾
-            self.__nums[rear] = num
-            self.__size += 1
+            self._nums[rear] = num
+            self._size += 1
 
         def pop(self) -> int:
             """出队"""
             num: int = self.peek()
             # 队首指针向后移动一位，若越过尾部则返回到数组头部
-            self.__front = (self.__front + 1) % self.capacity()
-            self.__size -= 1
+            self._front = (self._front + 1) % self.capacity()
+            self._size -= 1
             return num
 
         def peek(self) -> int:
             """访问队首元素"""
             if self.is_empty():
                 raise IndexError("队列为空")
-            return self.__nums[self.__front]
+            return self._nums[self._front]
 
         def to_list(self) -> list[int]:
             """返回列表用于打印"""
             res = [0] * self.size()
-            j: int = self.__front
+            j: int = self._front
             for i in range(self.size()):
-                res[i] = self.__nums[(j % self.capacity())]
+                res[i] = self._nums[(j % self.capacity())]
                 j += 1
             return res
     ```