Format python codes with black. (#453)

codes/python/chapter_stack_and_queue/array_deque.py

@@ -4,35 +4,37 @@ Created Time: 2023-03-01
 Author: Krahets (krahets@163.com)
 """
 
+
 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
@@ -44,7 +46,7 @@ class ArrayDeque:
         self.__size += 1
 
     def push_last(self, num: int) -> None:
-        """ 队尾入队 """
+        """队尾入队"""
         if self.__size == self.capacity():
             print("双向队列已满")
             return
@@ -55,7 +57,7 @@ class ArrayDeque:
         self.__size += 1
 
     def pop_first(self) -> int:
-        """ 队首出队 """
+        """队首出队"""
         num = self.peek_first()
         # 队首指针向后移动一位
         self.__front = self.index(self.__front + 1)
@@ -63,25 +65,25 @@ class ArrayDeque:
         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):
@@ -91,35 +93,35 @@ class ArrayDeque:
 
 """ Driver Code """
 if __name__ == "__main__":
-    """ 初始化双向队列 """
+    # 初始化双向队列
     deque = ArrayDeque(10)
     deque.push_last(3)
     deque.push_last(2)
     deque.push_last(5)
     print("双向队列 deque =", deque.to_array())
 
-    """ 访问元素 """
+    # 访问元素
     peek_first: int = deque.peek_first()
     print("队首元素 peek_first =", peek_first)
     peek_last: int = deque.peek_last()
     print("队尾元素 peek_last =", peek_last)
 
-    """ 元素入队 """
+    # 元素入队
     deque.push_last(4)
     print("元素 4 队尾入队后 deque =", deque.to_array())
     deque.push_first(1)
     print("元素 1 队首入队后 deque =", deque.to_array())
 
-    """ 元素出队 """
+    # 元素出队
     pop_last: int = deque.pop_last()
     print("队尾出队元素 =", pop_last, "，队尾出队后 deque =", deque.to_array())
     pop_first: int = deque.pop_first()
     print("队首出队元素 =", pop_first, "，队首出队后 deque =", deque.to_array())
 
-    """ 获取双向队列的长度 """
+    # 获取双向队列的长度
     size: int = deque.size()
     print("双向队列长度 size =", size)
 
-    """ 判断双向队列是否为空 """
+    # 判断双向队列是否为空
     is_empty: bool = deque.is_empty()
     print("双向队列是否为空 =", is_empty)

codes/python/chapter_stack_and_queue/array_queue.py

@@ -4,28 +4,30 @@ Created Time: 2022-12-01
 Author: Peng Chen (pengchzn@gmail.com)
 """
 
+
 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 越过数组尾部后回到头部
@@ -35,7 +37,7 @@ class ArrayQueue:
         self.__size += 1
 
     def pop(self) -> int:
-        """ 出队 """
+        """出队"""
         num: int = self.peek()
         # 队首指针向后移动一位，若越过尾部则返回到数组头部
         self.__front = (self.__front + 1) % self.capacity()
@@ -43,12 +45,12 @@ class ArrayQueue:
         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()):
@@ -59,10 +61,10 @@ class ArrayQueue:
 
 """ Driver Code """
 if __name__ == "__main__":
-    """ 初始化队列 """
+    # 初始化队列
     queue = ArrayQueue(10)
 
-    """ 元素入队 """
+    # 元素入队
     queue.push(1)
     queue.push(3)
     queue.push(2)
@@ -70,24 +72,24 @@ if __name__ == "__main__":
     queue.push(4)
     print("队列 queue =", queue.to_list())
 
-    """ 访问队首元素 """
+    # 访问队首元素
     peek: int = queue.peek()
     print("队首元素 peek =", peek)
 
-    """ 元素出队 """
+    # 元素出队
     pop: int = queue.pop()
     print("出队元素 pop =", pop)
     print("出队后 queue =", queue.to_list())
 
-    """ 获取队列的长度 """
+    # 获取队列的长度
     size: int = queue.size()
     print("队列长度 size =", size)
 
-    """ 判断队列是否为空 """
+    # 判断队列是否为空
     is_empty: bool = queue.is_empty()
     print("队列是否为空 =", is_empty)
 
-    """ 测试环形数组 """
+    # 测试环形数组
     for i in range(10):
         queue.push(i)
         queue.pop()

codes/python/chapter_stack_and_queue/array_stack.py

@@ -4,45 +4,47 @@ Created Time: 2022-11-29
 Author: Peng Chen (pengchzn@gmail.com)
 """
 
+
 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
 
 
 """ Driver Code """
 if __name__ == "__main__":
-    """ 初始化栈 """
+    # 初始化栈
     stack = ArrayStack()
 
-    """ 元素入栈 """
+    # 元素入栈
     stack.push(1)
     stack.push(3)
     stack.push(2)
@@ -50,19 +52,19 @@ if __name__ == "__main__":
     stack.push(4)
     print("栈 stack =", stack.to_list())
 
-    """ 访问栈顶元素 """
+    # 访问栈顶元素
     peek: int = stack.peek()
     print("栈顶元素 peek =", peek)
 
-    """ 元素出栈 """
+    # 元素出栈
     pop: int = stack.pop()
     print("出栈元素 pop =", pop)
     print("出栈后 stack =", stack.to_list())
 
-    """ 获取栈的长度 """
+    # 获取栈的长度
     size: int = stack.size()
     print("栈的长度 size =", size)
 
-    """ 判断是否为空 """
+    # 判断是否为空
     is_empty: bool = stack.is_empty()
     print("栈是否为空 =", is_empty)

codes/python/chapter_stack_and_queue/deque.py

@@ -8,35 +8,35 @@ from collections import deque
 
 """ Driver Code """
 if __name__ == "__main__":
-    """ 初始化双向队列 """
+    # 初始化双向队列
     deq: deque[int] = deque()
 
-    """ 元素入队 """
-    deq.append(2)      # 添加至队尾
+    # 元素入队
+    deq.append(2)  # 添加至队尾
     deq.append(5)
     deq.append(4)
     deq.appendleft(3)  # 添加至队首
     deq.appendleft(1)
     print("双向队列 deque =", deq)
 
-    """ 访问元素 """
+    # 访问元素
     front: int = deq[0]  # 队首元素
     print("队首元素 front =", front)
     rear: int = deq[-1]  # 队尾元素
     print("队尾元素 rear =", rear)
 
-    """ 元素出队 """
+    # 元素出队
     pop_front: int = deq.popleft()  # 队首元素出队
     print("队首出队元素  pop_front =", pop_front)
     print("队首出队后 deque =", deq)
-    pop_rear: int = deq.pop()       # 队尾元素出队
+    pop_rear: int = deq.pop()  # 队尾元素出队
     print("队尾出队元素  pop_rear =", pop_rear)
     print("队尾出队后 deque =", deq)
 
-    """ 获取双向队列的长度 """
+    # 获取双向队列的长度
     size: int = len(deq)
     print("双向队列长度 size =", size)
 
-    """ 判断双向队列是否为空 """
+    # 判断双向队列是否为空
     is_empty: bool = len(deq) == 0
     print("双向队列是否为空 =", is_empty)

codes/python/chapter_stack_and_queue/linkedlist_deque.py

@@ -4,32 +4,36 @@ Created Time: 2023-03-01
 Author: Krahets (krahets@163.com)
 """
 
+
 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():
@@ -49,15 +53,15 @@ class LinkedListDeque:
         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
@@ -83,23 +87,23 @@ class LinkedListDeque:
         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()):
@@ -110,35 +114,35 @@ class LinkedListDeque:
 
 """ Driver Code """
 if __name__ == "__main__":
-    """ 初始化双向队列 """
+    # 初始化双向队列
     deque = LinkedListDeque()
     deque.push_last(3)
     deque.push_last(2)
     deque.push_last(5)
     print("双向队列 deque =", deque.to_array())
 
-    """ 访问元素 """
+    # 访问元素
     peek_first: int = deque.peek_first()
     print("队首元素 peek_first =", peek_first)
     peek_last: int = deque.peek_last()
     print("队尾元素 peek_last =", peek_last)
 
-    """ 元素入队 """
+    # 元素入队
     deque.push_last(4)
     print("元素 4 队尾入队后 deque =", deque.to_array())
     deque.push_first(1)
     print("元素 1 队首入队后 deque =", deque.to_array())
 
-    """ 元素出队 """
+    # 元素出队
     pop_last: int = deque.pop_last()
     print("队尾出队元素 =", pop_last, "，队尾出队后 deque =", deque.to_array())
     pop_first: int = deque.pop_first()
     print("队首出队元素 =", pop_first, "，队首出队后 deque =", deque.to_array())
 
-    """ 获取双向队列的长度 """
+    # 获取双向队列的长度
     size: int = deque.size()
     print("双向队列长度 size =", size)
 
-    """ 判断双向队列是否为空 """
+    # 判断双向队列是否为空
     is_empty: bool = deque.is_empty()
     print("双向队列是否为空 =", is_empty)

codes/python/chapter_stack_and_queue/linkedlist_queue.py

@@ -5,27 +5,30 @@ Author: Peng Chen (pengchzn@gmail.com)
 """
 
 import sys, os.path as osp
+
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
+
 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)
         # 如果队列为空，则令头、尾节点都指向该节点
@@ -39,7 +42,7 @@ class LinkedListQueue:
         self.__size += 1
 
     def pop(self) -> int:
-        """ 出队 """
+        """出队"""
         num = self.peek()
         # 删除头节点
         self.__front = self.__front.next
@@ -47,14 +50,14 @@ class LinkedListQueue:
         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:
@@ -65,10 +68,10 @@ class LinkedListQueue:
 
 """ Driver Code """
 if __name__ == "__main__":
-    """ 初始化队列 """
+    # 初始化队列
     queue = LinkedListQueue()
 
-    """ 元素入队 """
+    # 元素入队
     queue.push(1)
     queue.push(3)
     queue.push(2)
@@ -76,19 +79,19 @@ if __name__ == "__main__":
     queue.push(4)
     print("队列 queue =", queue.to_list())
 
-    """ 访问队首元素 """
+    # 访问队首元素
     peek: int = queue.peek()
     print("队首元素 front =", peek)
 
-    """ 元素出队 """
+    # 元素出队
     pop_front: int = queue.pop()
     print("出队元素 pop =", pop_front)
     print("出队后 queue =", queue.to_list())
 
-    """ 获取队列的长度 """
+    # 获取队列的长度
     size: int = queue.size()
     print("队列长度 size =", size)
 
-    """ 判断队列是否为空 """
+    # 判断队列是否为空
     is_empty: bool = queue.is_empty()
     print("队列是否为空 =", is_empty)

codes/python/chapter_stack_and_queue/linkedlist_stack.py

@@ -5,46 +5,50 @@ Author: Peng Chen (pengchzn@gmail.com)
 """
 
 import sys, os.path as osp
+
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
+
 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:
@@ -56,10 +60,10 @@ class LinkedListStack:
 
 """ Driver Code """
 if __name__ == "__main__":
-    """ 初始化栈 """
+    # 初始化栈
     stack = LinkedListStack()
 
-    """ 元素入栈 """
+    # 元素入栈
     stack.push(1)
     stack.push(3)
     stack.push(2)
@@ -67,19 +71,19 @@ if __name__ == "__main__":
     stack.push(4)
     print("栈 stack =", stack.to_list())
 
-    """ 访问栈顶元素 """
+    # 访问栈顶元素
     peek: int = stack.peek()
     print("栈顶元素 peek =", peek)
 
-    """ 元素出栈 """
+    # 元素出栈
     pop: int = stack.pop()
     print("出栈元素 pop =", pop)
     print("出栈后 stack =", stack.to_list())
 
-    """ 获取栈的长度 """
+    # 获取栈的长度
     size: int = stack.size()
     print("栈的长度 size =", size)
 
-    """ 判断是否为空 """
+    # 判断是否为空
     is_empty: bool = stack.is_empty()
     print("栈是否为空 =", is_empty)

codes/python/chapter_stack_and_queue/queue.py

@@ -8,13 +8,12 @@ from collections import deque
 
 """ Driver Code """
 if __name__ == "__main__":
-    
-    """ 初始化队列 """
+    # 初始化队列
     # 在 Python 中，我们一般将双向队列类 deque 看作队列使用
     # 虽然 queue.Queue() 是纯正的队列类，但不太好用
     que: deque[int] = deque()
 
-    """ 元素入队 """
+    # 元素入队
     que.append(1)
     que.append(3)
     que.append(2)
@@ -22,19 +21,19 @@ if __name__ == "__main__":
     que.append(4)
     print("队列 que =", que)
 
-    """ 访问队首元素 """
+    # 访问队首元素
     front: int = que[0]
     print("队首元素 front =", front)
 
-    """ 元素出队 """
+    # 元素出队
     pop: int = que.popleft()
     print("出队元素 pop =", pop)
     print("出队后 que =", que)
 
-    """ 获取队列的长度 """
+    # 获取队列的长度
     size: int = len(que)
     print("队列长度 size =", size)
 
-    """ 判断队列是否为空 """
+    # 判断队列是否为空
     is_empty: bool = len(que) == 0
     print("队列是否为空 =", is_empty)

codes/python/chapter_stack_and_queue/stack.py

@@ -6,11 +6,11 @@ Author: Peng Chen (pengchzn@gmail.com)
 
 """ Driver Code """
 if __name__ == "__main__":
-    """ 初始化栈 """
-    # Python 没有内置的栈类，可以把 list 当作栈来使用 
+    # 初始化栈
+    # Python 没有内置的栈类，可以把 list 当作栈来使用
     stack: list[int] = []
 
-    """ 元素入栈 """
+    # 元素入栈
     stack.append(1)
     stack.append(3)
     stack.append(2)
@@ -18,19 +18,19 @@ if __name__ == "__main__":
     stack.append(4)
     print("栈 stack =", stack)
 
-    """ 访问栈顶元素 """
+    # 访问栈顶元素
     peek: int = stack[-1]
     print("栈顶元素 peek =", peek)
 
-    """ 元素出栈 """
+    # 元素出栈
     pop: int = stack.pop()
     print("出栈元素 pop =", pop)
     print("出栈后 stack =", stack)
 
-    """ 获取栈的长度 """
+    # 获取栈的长度
     size: int = len(stack)
     print("栈的长度 size =", size)
 
-    """ 判断是否为空 """
+    # 判断是否为空
     is_empty: bool = len(stack) == 0
     print("栈是否为空 =", is_empty)