Format python codes with black. (#453)

codes/python/chapter_sorting/bubble_sort.py

@@ -4,8 +4,9 @@ Created Time: 2022-11-25
 Author: timi (xisunyy@163.com)
 """
 
+
 def bubble_sort(nums: list[int]) -> None:
-    """ 冒泡排序 """
+    """冒泡排序"""
     n: int = len(nums)
     # 外循环：待排序元素数量为 n-1, n-2, ..., 1
     for i in range(n - 1, 0, -1):
@@ -15,8 +16,9 @@ def bubble_sort(nums: list[int]) -> None:
                 # 交换 nums[j] 与 nums[j + 1]
                 nums[j], nums[j + 1] = nums[j + 1], nums[j]
 
+
 def bubble_sort_with_flag(nums: list[int]) -> None:
-    """ 冒泡排序（标志优化） """
+    """冒泡排序（标志优化）"""
     n: int = len(nums)
     # 外循环：待排序元素数量为 n-1, n-2, ..., 1
     for i in range(n - 1, 0, -1):
@@ -28,11 +30,11 @@ def bubble_sort_with_flag(nums: list[int]) -> None:
                 nums[j], nums[j + 1] = nums[j + 1], nums[j]
                 flag = True  # 记录交换元素
         if not flag:
-            break            # 此轮冒泡未交换任何元素，直接跳出
+            break  # 此轮冒泡未交换任何元素，直接跳出
 
 
 """ Driver Code """
-if __name__ == '__main__':
+if __name__ == "__main__":
     nums: list[int] = [4, 1, 3, 1, 5, 2]
     bubble_sort(nums)
     print("排序后数组 nums =", nums)

codes/python/chapter_sorting/bucket_sort.py

@@ -4,6 +4,7 @@ Created Time: 2023-03-30
 Author: Krahets (krahets@163.com)
 """
 
+
 def bucket_sort(nums: list[float]) -> None:
     # 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
     k = len(nums) // 2
@@ -26,7 +27,7 @@ def bucket_sort(nums: list[float]) -> None:
             i += 1
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # 设输入数据为浮点数，范围为 [0, 1)
     nums = [0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37]
     bucket_sort(nums)

codes/python/chapter_sorting/counting_sort.py

@@ -4,8 +4,9 @@ Created Time: 2023-03-21
 Author: Krahets (krahets@163.com)
 """
 
+
 def counting_sort_naive(nums: list[int]) -> None:
-    """ 计数排序 """
+    """计数排序"""
     # 简单实现，无法用于排序对象
     # 1. 统计数组最大元素 m
     m = 0
@@ -23,8 +24,9 @@ def counting_sort_naive(nums: list[int]) -> None:
             nums[i] = num
             i += 1
 
+
 def counting_sort(nums: list[int]) -> None:
-    """ 计数排序 """
+    """计数排序"""
     # 完整实现，可排序对象，并且是稳定排序
     # 1. 统计数组最大元素 m
     m = max(nums)
@@ -49,6 +51,7 @@ def counting_sort(nums: list[int]) -> None:
     for i in range(n):
         nums[i] = res[i]
 
+
 """ Driver Code """
 if __name__ == "__main__":
     nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4]

codes/python/chapter_sorting/insertion_sort.py

@@ -4,9 +4,10 @@ Created Time: 2022-11-25
 Author: timi (xisunyy@163.com)
 """
 
+
 def insertion_sort(nums: list[int]) -> None:
-    """ 插入排序 """
-    # 外循环：base = nums[1], nums[2], ..., nums[n-1]   
+    """插入排序"""
+    # 外循环：base = nums[1], nums[2], ..., nums[n-1]
     for i in range(1, len(nums)):
         base: int = nums[i]
         j: int = i - 1
@@ -14,11 +15,11 @@ def insertion_sort(nums: list[int]) -> None:
         while j >= 0 and nums[j] > base:
             nums[j + 1] = nums[j]  # 1. 将 nums[j] 向右移动一位
             j -= 1
-        nums[j + 1] = base         # 2. 将 base 赋值到正确位置
+        nums[j + 1] = base  # 2. 将 base 赋值到正确位置
 
 
 """ Driver Code """
-if __name__ == '__main__':
+if __name__ == "__main__":
     nums: list[int] = [4, 1, 3, 1, 5, 2]
     insertion_sort(nums)
     print("排序后数组 nums =", nums)

codes/python/chapter_sorting/merge_sort.py

@@ -4,12 +4,13 @@ Created Time: 2022-11-25
 Author: timi (xisunyy@163.com)
 """
 
+
 def merge(nums: list[int], left: int, mid: int, right: int) -> None:
-    """ 合并左子数组和右子数组 """
+    """合并左子数组和右子数组"""
     # 左子数组区间 [left, mid]
     # 右子数组区间 [mid + 1, right]
     # 初始化辅助数组
-    tmp: list[int] = list(nums[left:right + 1])
+    tmp: list[int] = list(nums[left : right + 1])
     # 左子数组的起始索引和结束索引
     left_start: int = 0
     left_end: int = mid - left
@@ -34,21 +35,22 @@ def merge(nums: list[int], left: int, mid: int, right: int) -> None:
             nums[k] = tmp[j]
             j += 1
 
+
 def merge_sort(nums: list[int], left: int, right: int) -> None:
-    """ 归并排序 """
+    """归并排序"""
     # 终止条件
     if left >= right:
-        return                        # 当子数组长度为 1 时终止递归
+        return  # 当子数组长度为 1 时终止递归
     # 划分阶段
-    mid: int = (left + right) // 2    # 计算中点
-    merge_sort(nums, left, mid)       # 递归左子数组
+    mid: int = (left + right) // 2  # 计算中点
+    merge_sort(nums, left, mid)  # 递归左子数组
     merge_sort(nums, mid + 1, right)  # 递归右子数组
     # 合并阶段
     merge(nums, left, mid, right)
 
 
 """ Driver Code """
-if __name__ == '__main__':
-    nums: list[int] = [ 7, 3, 2, 6, 0, 1, 5, 4 ]
+if __name__ == "__main__":
+    nums: list[int] = [7, 3, 2, 6, 0, 1, 5, 4]
     merge_sort(nums, 0, len(nums) - 1)
     print("归并排序完成后 nums =", nums)

codes/python/chapter_sorting/quick_sort.py

@@ -4,10 +4,12 @@ Created Time: 2022-11-25
 Author: timi (xisunyy@163.com)
 """
 
+
 class QuickSort:
-    """ 快速排序类 """
+    """快速排序类"""
+
     def partition(self, nums: list[int], left: int, right: int) -> int:
-        """ 哨兵划分 """
+        """哨兵划分"""
         # 以 nums[left] 作为基准数
         i, j = left, right
         while i < j:
@@ -22,7 +24,7 @@ class QuickSort:
         return i  # 返回基准数的索引
 
     def quick_sort(self, nums: list[int], left: int, right: int) -> None:
-        """ 快速排序 """
+        """快速排序"""
         # 子数组长度为 1 时终止递归
         if left >= right:
             return
@@ -32,10 +34,12 @@ class QuickSort:
         self.quick_sort(nums, left, pivot - 1)
         self.quick_sort(nums, pivot + 1, right)
 
+
 class QuickSortMedian:
-    """ 快速排序类（中位基准数优化）"""
+    """快速排序类（中位基准数优化）"""
+
     def median_three(self, nums: list[int], left: int, mid: int, right: int) -> int:
-        """ 选取三个元素的中位数 """
+        """选取三个元素的中位数"""
         # 此处使用异或运算来简化代码
         # 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
         if (nums[left] < nums[mid]) ^ (nums[left] < nums[right]):
@@ -45,7 +49,7 @@ class QuickSortMedian:
         return right
 
     def partition(self, nums: list[int], left: int, right: int) -> int:
-        """ 哨兵划分（三数取中值） """
+        """哨兵划分（三数取中值）"""
         # 以 nums[left] 作为基准数
         med: int = self.median_three(nums, left, (left + right) // 2, right)
         # 将中位数交换至数组最左端
@@ -64,7 +68,7 @@ class QuickSortMedian:
         return i  # 返回基准数的索引
 
     def quick_sort(self, nums: list[int], left: int, right: int) -> None:
-        """ 快速排序 """
+        """快速排序"""
         # 子数组长度为 1 时终止递归
         if left >= right:
             return
@@ -74,10 +78,12 @@ class QuickSortMedian:
         self.quick_sort(nums, left, pivot - 1)
         self.quick_sort(nums, pivot + 1, right)
 
+
 class QuickSortTailCall:
-    """ 快速排序类（尾递归优化） """
+    """快速排序类（尾递归优化）"""
+
     def partition(self, nums: list[int], left: int, right: int) -> int:
-        """ 哨兵划分 """
+        """哨兵划分"""
         # 以 nums[left] 作为基准数
         i, j = left, right
         while i < j:
@@ -92,7 +98,7 @@ class QuickSortTailCall:
         return i  # 返回基准数的索引
 
     def quick_sort(self, nums: list[int], left: int, right: int) -> None:
-        """ 快速排序（尾递归优化） """
+        """快速排序（尾递归优化）"""
         # 子数组长度为 1 时终止
         while left < right:
             # 哨兵划分操作
@@ -100,15 +106,15 @@ class QuickSortTailCall:
             # 对两个子数组中较短的那个执行快排
             if pivot - left < right - pivot:
                 self.quick_sort(nums, left, pivot - 1)  # 递归排序左子数组
-                left = pivot + 1     # 剩余待排序区间为 [pivot + 1, right]
+                left = pivot + 1  # 剩余待排序区间为 [pivot + 1, right]
             else:
                 self.quick_sort(nums, pivot + 1, right)  # 递归排序右子数组
-                right = pivot - 1    # 剩余待排序区间为 [left, pivot - 1]
+                right = pivot - 1  # 剩余待排序区间为 [left, pivot - 1]
 
 
 """ Driver Code """
-if __name__ == '__main__':
-    # 快速排序 
+if __name__ == "__main__":
+    # 快速排序
     nums: list[int] = [2, 4, 1, 0, 3, 5]
     QuickSort().quick_sort(nums, 0, len(nums) - 1)
     print("快速排序完成后 nums =", nums)

codes/python/chapter_sorting/radix_sort.py

@@ -6,19 +6,20 @@ Author: Krahets (krahets@163.com)
 
 
 def digit(num: int, exp: int) -> int:
-    """ 获取元素 num 的第 k 位，其中 exp = 10^(k-1) """
+    """获取元素 num 的第 k 位，其中 exp = 10^(k-1)"""
     # 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
     return (num // exp) % 10
 
+
 def counting_sort_digit(nums: list[int], exp: int) -> None:
-    """ 计数排序（根据 nums 第 k 位排序） """
+    """计数排序（根据 nums 第 k 位排序）"""
     # 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
     counter = [0] * 10
     n = len(nums)
     # 统计 0~9 各数字的出现次数
     for i in range(n):
         d = digit(nums[i], exp)  # 获取 nums[i] 第 k 位，记为 d
-        counter[d] += 1          # 统计数字 d 的出现次数
+        counter[d] += 1  # 统计数字 d 的出现次数
     # 求前缀和，将“出现个数”转换为“数组索引”
     for i in range(1, 10):
         counter[i] += counter[i - 1]
@@ -27,14 +28,15 @@ def counting_sort_digit(nums: list[int], exp: int) -> None:
     for i in range(n - 1, -1, -1):
         d = digit(nums[i], exp)
         j = counter[d] - 1  # 获取 d 在数组中的索引 j
-        res[j] = nums[i]    # 将当前元素填入索引 j
-        counter[d] -= 1     # 将 d 的数量减 1
+        res[j] = nums[i]  # 将当前元素填入索引 j
+        counter[d] -= 1  # 将 d 的数量减 1
     # 使用结果覆盖原数组 nums
     for i in range(n):
         nums[i] = res[i]
 
+
 def radix_sort(nums: list[int]) -> None:
-    """ 基数排序 """
+    """基数排序"""
     # 获取数组的最大元素，用于判断最大位数
     m = max(nums)
     # 按照从低位到高位的顺序遍历
@@ -47,10 +49,21 @@ def radix_sort(nums: list[int]) -> None:
         counting_sort_digit(nums, exp)
         exp *= 10
 
+
 """ Driver Code """
-if __name__ == '__main__':
+if __name__ == "__main__":
     # 基数排序
-    nums = [10546151, 35663510, 42865989, 34862445, 81883077,
-            88906420, 72429244, 30524779, 82060337, 63832996]
+    nums = [
+        10546151,
+        35663510,
+        42865989,
+        34862445,
+        81883077,
+        88906420,
+        72429244,
+        30524779,
+        82060337,
+        63832996,
+    ]
     radix_sort(nums)
     print("基数排序完成后 nums =", nums)