build

chapter_stack_and_queue/queue.md

@@ -86,7 +86,7 @@ comments: true
     """ 初始化队列 """
     # 在 Python 中，我们一般将双向队列类 deque 看作队列使用
     # 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不建议
-    que = collections.deque()
+    que: Deque[int] = collections.deque()
     
     """ 元素入队 """
     que.append(1)
@@ -96,16 +96,16 @@ comments: true
     que.append(4)
     
     """ 访问队首元素 """
-    front = que[0];
+    front: int = que[0];
     
     """ 元素出队 """
-    pop = que.popleft()
+    pop: int = que.popleft()
     
     """ 获取队列的长度 """
-    size = len(que)
+    size: int = len(que)
     
     """ 判断队列是否为空 """
-    is_empty = len(que) == 0
+    is_empty: bool = len(que) == 0
     ```
 
 === "Go"
@@ -431,19 +431,19 @@ comments: true
         """ 基于链表实现的队列 """
         def __init__(self):
             """ 构造方法 """
-            self.__front = None  # 头结点 front
-            self.__rear = None   # 尾结点 rear
-            self.__size = 0
+            self.__front: Optional[ListNode] = None  # 头结点 front
+            self.__rear: Optional[ListNode] = None   # 尾结点 rear
+            self.__size: int = 0
 
-        def size(self):
+        def size(self) -> int:
             """ 获取队列的长度 """
             return self.__size
 
-        def is_empty(self):
+        def is_empty(self) -> bool:
             """ 判断队列是否为空 """
             return not self.__front
 
-        def push(self, num):
+        def push(self, num: int) -> None:
             """ 入队 """
             # 尾结点后添加 num
             node = ListNode(num)
@@ -457,7 +457,7 @@ comments: true
                 self.__rear = node
             self.__size += 1
 
-        def poll(self):
+        def poll(self) -> int:
             """ 出队 """
             num = self.peek()
             # 删除头结点
@@ -465,14 +465,14 @@ comments: true
             self.__size -= 1
             return num
 
-        def peek(self):
+        def peek(self) -> int:
             """ 访问队首元素 """
             if self.size() == 0:
                 print("队列为空")
                 return False
             return self.__front.val
 
-        def to_list(self):
+        def to_list(self) -> List[int]:
             """ 转化为列表用于打印 """
             queue = []
             temp = self.__front
@@ -1104,51 +1104,51 @@ comments: true
     ```python title="array_queue.py"
     class ArrayQueue:
         """ 基于环形数组实现的队列 """
-        def __init__(self, size):
+        def __init__(self, size: int) -> None:
             """ 构造方法 """
-            self.__nums = [0] * size  # 用于存储队列元素的数组
-            self.__front = 0          # 队首指针，指向队首元素
-            self.__size = 0           # 队列长度
+            self.__nums: List[int] = [0] * size  # 用于存储队列元素的数组
+            self.__front: int = 0          # 队首指针，指向队首元素
+            self.__size: int = 0           # 队列长度
 
-        def capacity(self):
+        def capacity(self) -> int:
             """ 获取队列的容量 """
             return len(self.__nums)
 
-        def size(self):
+        def size(self) -> int:
             """ 获取队列的长度 """
             return self.__size
 
-        def is_empty(self):
+        def is_empty(self) -> bool:
             """ 判断队列是否为空 """
             return self.__size == 0
 
-        def push(self, num):
+        def push(self, num: int) -> None:
             """ 入队 """
             assert self.__size < self.capacity(), "队列已满"
             # 计算尾指针，指向队尾索引 + 1
             # 通过取余操作，实现 rear 越过数组尾部后回到头部
-            rear = (self.__front + self.__size) % self.capacity()
+            rear: int = (self.__front + self.__size) % self.capacity()
             # 将 num 添加至队尾
             self.__nums[rear] = num
             self.__size += 1
 
-        def poll(self):
+        def poll(self) -> int:
             """ 出队 """
-            num = self.peek()
+            num: int = self.peek()
             # 队首指针向后移动一位，若越过尾部则返回到数组头部
             self.__front = (self.__front + 1) % self.capacity()
             self.__size -= 1
             return num
 
-        def peek(self):
+        def peek(self) -> int:
             """ 访问队首元素 """
             assert not self.is_empty(), "队列为空"
             return self.__nums[self.__front]
 
-        def to_list(self):
+        def to_list(self) -> List[int]:
             """ 返回列表用于打印 """
-            res = [0] * self.size()
-            j = self.__front
+            res: List[int] = [0] * self.size()
+            j: int = self.__front
             for i in range(self.size()):
                 res[i] = self.__nums[(j % self.capacity())]
                 j += 1