Format python codes with black. (#453)

codes/python/chapter_computational_complexity/time_complexity.py

@@ -4,31 +4,35 @@ Created Time: 2022-11-25
 Author: Krahets (krahets@163.com)
 """
 
+
 def constant(n: int) -> int:
-    """ 常数阶 """
+    """常数阶"""
     count: int = 0
     size: int = 100000
     for _ in range(size):
         count += 1
     return count
 
+
 def linear(n: int) -> int:
-    """ 线性阶 """
+    """线性阶"""
     count: int = 0
     for _ in range(n):
         count += 1
     return count
 
+
 def array_traversal(nums: list[int]) -> int:
-    """ 线性阶（遍历数组）"""
+    """线性阶（遍历数组）"""
     count: int = 0
     # 循环次数与数组长度成正比
     for num in nums:
         count += 1
     return count
 
+
 def quadratic(n: int) -> int:
-    """ 平方阶 """
+    """平方阶"""
     count: int = 0
     # 循环次数与数组长度成平方关系
     for i in range(n):
@@ -36,8 +40,9 @@ def quadratic(n: int) -> int:
             count += 1
     return count
 
+
 def bubble_sort(nums: list[int]) -> int:
-    """ 平方阶（冒泡排序）"""
+    """平方阶（冒泡排序）"""
     count: int = 0  # 计数器
     # 外循环：待排序元素数量为 n-1, n-2, ..., 1
     for i in range(len(nums) - 1, 0, -1):
@@ -51,8 +56,9 @@ def bubble_sort(nums: list[int]) -> int:
                 count += 3  # 元素交换包含 3 个单元操作
     return count
 
+
 def exponential(n: int) -> int:
-    """ 指数阶（循环实现）"""
+    """指数阶（循环实现）"""
     count: int = 0
     base: int = 1
     # cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
@@ -63,36 +69,44 @@ def exponential(n: int) -> int:
     # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
     return count
 
+
 def exp_recur(n: int) -> int:
-    """ 指数阶（递归实现）"""
-    if n == 1: return 1
+    """指数阶（递归实现）"""
+    if n == 1:
+        return 1
     return exp_recur(n - 1) + exp_recur(n - 1) + 1
 
+
 def logarithmic(n: float) -> int:
-    """ 对数阶（循环实现）"""
+    """对数阶（循环实现）"""
     count: int = 0
     while n > 1:
         n = n / 2
         count += 1
     return count
 
+
 def log_recur(n: float) -> int:
-    """ 对数阶（递归实现）"""
-    if n <= 1: return 0
+    """对数阶（递归实现）"""
+    if n <= 1:
+        return 0
     return log_recur(n / 2) + 1
 
+
 def linear_log_recur(n: float) -> int:
-    """ 线性对数阶 """
-    if n <= 1: return 1
-    count: int = linear_log_recur(n // 2) + \
-                 linear_log_recur(n // 2)
+    """线性对数阶"""
+    if n <= 1:
+        return 1
+    count: int = linear_log_recur(n // 2) + linear_log_recur(n // 2)
     for _ in range(n):
         count += 1
     return count
 
+
 def factorial_recur(n: int) -> int:
-    """ 阶乘阶（递归实现）"""
-    if n == 0: return 1
+    """阶乘阶（递归实现）"""
+    if n == 0:
+        return 1
     count: int = 0
     # 从 1 个分裂出 n 个
     for _ in range(n):