build

chapter_stack_and_queue/deque.md

@@ -595,15 +595,15 @@ comments: true
         def __init__(self, val: int) -> None:
             """ 构造方法 """
             self.val: int = val
-            self.next: Optional[ListNode] = None  # 后继结点引用（指针）
-            self.prev: Optional[ListNode] = None  # 前驱结点引用（指针）
+            self.next: ListNode | None = None  # 后继结点引用（指针）
+            self.prev: ListNode | None = None  # 前驱结点引用（指针）
 
     class LinkedListDeque:
         """ 基于双向链表实现的双向队列 """
         def __init__(self) -> None:
             """ 构造方法 """
-            self.front: Optional[ListNode] = None # 头结点 front
-            self.rear: Optional[ListNode] = None  # 尾结点 rear
+            self.front: ListNode | None = None # 头结点 front
+            self.rear: ListNode | None = None  # 尾结点 rear
             self.__size: int = 0        # 双向队列的长度
 
         def size(self) -> int:
@@ -651,7 +651,7 @@ comments: true
             if is_front:
                 val: int = self.front.val  # 暂存头结点值
                 # 删除头结点
-                fnext: Optional[ListNode] = self.front.next
+                fnext: ListNode | None = self.front.next
                 if fnext != None:
                     fnext.prev = None
                     self.front.next = None
@@ -660,7 +660,7 @@ comments: true
             else:
                 val: int = self.rear.val  # 暂存尾结点值
                 # 删除尾结点
-                rprev: Optional[ListNode] = self.rear.prev
+                rprev: ListNode | None = self.rear.prev
                 if rprev != None:
                     rprev.next = None
                     self.rear.prev = None
@@ -684,10 +684,10 @@ comments: true
             """ 访问队尾元素 """
             return None if self.is_empty() else self.rear.val
 
-        def to_array(self) -> List[int]:
+        def to_array(self) -> list[int]:
             """ 返回数组用于打印 """
-            node: Optional[ListNode] = self.front
-            res: List[int] = [0] * self.size()
+            node: ListNode | None = self.front
+            res: list[int] = [0] * self.size()
             for i in range(self.size()):
                 res[i] = node.val
                 node = node.next
@@ -1584,10 +1584,9 @@ comments: true
     ```python title="array_deque.py"
     class ArrayDeque:
         """ 基于环形数组实现的双向队列 """
-
         def __init__(self, capacity: int) -> None:
             """ 构造方法 """
-            self.__nums: List[int] = [0] * capacity
+            self.__nums: list[int] = [0] * capacity
             self.__front: int = 0
             self.__size: int = 0
 
@@ -1659,7 +1658,7 @@ comments: true
             last = self.index(self.__front + self.__size - 1)
             return self.__nums[last]
 
-        def to_array(self) -> List[int]:
+        def to_array(self) -> list[int]:
             """ 返回数组用于打印 """
             # 仅转换有效长度范围内的列表元素
             res = []

chapter_stack_and_queue/queue.md

@@ -431,8 +431,8 @@ comments: true
         """ 基于链表实现的队列 """
         def __init__(self):
             """ 构造方法 """
-            self.__front: Optional[ListNode] = None  # 头结点 front
-            self.__rear: Optional[ListNode] = None   # 尾结点 rear
+            self.__front: ListNode | None = None  # 头结点 front
+            self.__rear: ListNode | None = None   # 尾结点 rear
             self.__size: int = 0
 
         def size(self) -> int:
@@ -472,7 +472,7 @@ comments: true
                 return False
             return self.__front.val
 
-        def to_list(self) -> List[int]:
+        def to_list(self) -> list[int]:
             """ 转化为列表用于打印 """
             queue = []
             temp = self.__front
@@ -1106,7 +1106,7 @@ comments: true
         """ 基于环形数组实现的队列 """
         def __init__(self, size: int) -> None:
             """ 构造方法 """
-            self.__nums: List[int] = [0] * size  # 用于存储队列元素的数组
+            self.__nums: list[int] = [0] * size  # 用于存储队列元素的数组
             self.__front: int = 0          # 队首指针，指向队首元素
             self.__size: int = 0           # 队列长度
 
@@ -1145,9 +1145,9 @@ comments: true
             assert not self.is_empty(), "队列为空"
             return self.__nums[self.__front]
 
-        def to_list(self) -> List[int]:
+        def to_list(self) -> list[int]:
             """ 返回列表用于打印 """
-            res: List[int] = [0] * self.size()
+            res: list[int] = [0] * self.size()
             j: int = self.__front
             for i in range(self.size()):
                 res[i] = self.__nums[(j % self.capacity())]

chapter_stack_and_queue/stack.md

@@ -412,7 +412,7 @@ comments: true
         """ 基于链表实现的栈 """
         def __init__(self):
             """ 构造方法 """
-            self.__peek: Optional[ListNode] = None
+            self.__peek: ListNode | None = None
             self.__size: int = 0
 
         def size(self) -> int:
@@ -443,9 +443,9 @@ comments: true
             if not self.__peek: return None
             return self.__peek.val
 
-        def to_list(self) -> List[int]:
+        def to_list(self) -> list[int]:
             """ 转化为列表用于打印 """
-            arr: List[int] = []
+            arr: list[int] = []
             node = self.__peek
             while node:
                 arr.append(node.val)
@@ -954,7 +954,7 @@ comments: true
         """ 基于数组实现的栈 """
         def __init__(self) -> None:
             """ 构造方法 """
-            self.__stack: List[int] = []
+            self.__stack: list[int] = []
 
         def size(self) -> int:
             """ 获取栈的长度 """
@@ -978,7 +978,7 @@ comments: true
             assert not self.is_empty(), "栈为空"
             return self.__stack[-1]
         
-        def to_list(self) -> List[int]:
+        def to_list(self) -> list[int]:
             """ 返回列表用于打印 """
             return self.__stack
     ```