Add typing annotations to Python codes. (#411)

codes/python/chapter_sorting/bubble_sort.py

@@ -8,9 +8,9 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def bubble_sort(nums):
+def bubble_sort(nums: List[int]) -> None:
     """ 冒泡排序 """
-    n = len(nums)
+    n: int = len(nums)
     # 外循环：待排序元素数量为 n-1, n-2, ..., 1
     for i in range(n - 1, 0, -1):
         # 内循环：冒泡操作
@@ -19,12 +19,12 @@ def bubble_sort(nums):
                 # 交换 nums[j] 与 nums[j + 1]
                 nums[j], nums[j + 1] = nums[j + 1], nums[j]
 
-def bubble_sort_with_flag(nums):
+def bubble_sort_with_flag(nums: List[int]) -> None:
     """ 冒泡排序（标志优化） """
-    n = len(nums)
+    n: int = len(nums)
     # 外循环：待排序元素数量为 n-1, n-2, ..., 1
     for i in range(n - 1, 0, -1):
-        flag = False  # 初始化标志位
+        flag: bool = False  # 初始化标志位
         # 内循环：冒泡操作
         for j in range(i):
             if nums[j] > nums[j + 1]:
@@ -37,10 +37,10 @@ def bubble_sort_with_flag(nums):
 
 """ Driver Code """
 if __name__ == '__main__':
-    nums = [4, 1, 3, 1, 5, 2]
+    nums: List[int] = [4, 1, 3, 1, 5, 2]
     bubble_sort(nums)
     print("排序后数组 nums =", nums)
 
-    nums1 = [4, 1, 3, 1, 5, 2]
+    nums1: List[int] = [4, 1, 3, 1, 5, 2]
     bubble_sort_with_flag(nums1)
     print("排序后数组 nums =", nums1)

codes/python/chapter_sorting/insertion_sort.py

@@ -8,12 +8,12 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def insertion_sort(nums):
+def insertion_sort(nums: List[int]) -> None:
     """ 插入排序 """
     # 外循环：base = nums[1], nums[2], ..., nums[n-1]   
     for i in range(1, len(nums)):
-        base = nums[i]
-        j = i - 1
+        base: int = nums[i]
+        j: int = i - 1
         # 内循环：将 base 插入到左边的正确位置
         while j >= 0 and nums[j] > base:
             nums[j + 1] = nums[j]  # 1. 将 nums[j] 向右移动一位
@@ -23,6 +23,6 @@ def insertion_sort(nums):
 
 """ Driver Code """
 if __name__ == '__main__':
-    nums = [4, 1, 3, 1, 5, 2]
+    nums: List[int] = [4, 1, 3, 1, 5, 2]
     insertion_sort(nums)
     print("排序后数组 nums =", nums)

codes/python/chapter_sorting/merge_sort.py

@@ -8,18 +8,21 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def merge(nums, left, mid, right):
+def merge(nums: List[int], left: int, mid: int, right: int) -> None:
     """ 合并左子数组和右子数组 """
     # 左子数组区间 [left, mid]
     # 右子数组区间 [mid + 1, right]
     # 初始化辅助数组 借助 copy模块
-    tmp = nums[left:right + 1]
+    tmp: List[int] = nums[left:right + 1].copy()
     # 左子数组的起始索引和结束索引
-    left_start, left_end = left - left, mid - left
+    left_start: int = 0
+    left_end: int = mid - left
     # 右子数组的起始索引和结束索引
-    right_start, right_end = mid + 1 - left, right - left
+    right_start: int = mid + 1 - left
+    right_end: int = right - left
     # i, j 分别指向左子数组、右子数组的首元素
-    i, j = left_start, right_start
+    i: int = left_start
+    j: int = right_start
     # 通过覆盖原数组 nums 来合并左子数组和右子数组
     for k in range(left, right + 1):
         # 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
@@ -35,13 +38,13 @@ def merge(nums, left, mid, right):
             nums[k] = tmp[j]
             j += 1
 
-def merge_sort(nums, left, right):
+def merge_sort(nums: List[int], left: int, right: int) -> None:
     """ 归并排序 """
     # 终止条件
     if left >= right:
         return                        # 当子数组长度为 1 时终止递归
     # 划分阶段
-    mid = (left + right) // 2         # 计算中点
+    mid: int = (left + right) // 2    # 计算中点
     merge_sort(nums, left, mid)       # 递归左子数组
     merge_sort(nums, mid + 1, right)  # 递归右子数组
     # 合并阶段
@@ -50,6 +53,6 @@ def merge_sort(nums, left, right):
 
 """ Driver Code """
 if __name__ == '__main__':
-    nums = [ 7, 3, 2, 6, 0, 1, 5, 4 ]
+    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

@@ -10,7 +10,7 @@ from modules import *
 
 class QuickSort:
     """ 快速排序类 """
-    def partition(self, nums, left, right):
+    def partition(self, nums: List[int], left: int, right: int) -> int:
         """ 哨兵划分 """
         # 以 nums[left] 作为基准数
         i, j = left, right
@@ -25,20 +25,20 @@ class QuickSort:
         nums[i], nums[left] = nums[left], nums[i]
         return i  # 返回基准数的索引
 
-    def quick_sort(self, nums, left, right):
+    def quick_sort(self, nums: List[int], left: int, right: int) -> None:
         """ 快速排序 """
         # 子数组长度为 1 时终止递归
         if left >= right:
             return
         # 哨兵划分
-        pivot = self.partition(nums, left, right)
+        pivot: int = self.partition(nums, left, right)
         # 递归左子数组、右子数组
         self.quick_sort(nums, left, pivot - 1)
         self.quick_sort(nums, pivot + 1, right)
 
 class QuickSortMedian:
     """ 快速排序类（中位基准数优化）"""
-    def median_three(self, nums, left, mid, right):
+    def median_three(self, nums: List[int], left: int, mid: int, right: int) -> int:
         """ 选取三个元素的中位数 """
         # 此处使用异或运算来简化代码
         # 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
@@ -48,10 +48,10 @@ class QuickSortMedian:
             return mid
         return right
 
-    def partition(self, nums, left, right):
+    def partition(self, nums: List[int], left: int, right: int) -> int:
         """ 哨兵划分（三数取中值） """
         # 以 nums[left] 作为基准数
-        med = self.median_three(nums, left, (left + right) // 2, right)
+        med: int = self.median_three(nums, left, (left + right) // 2, right)
         # 将中位数交换至数组最左端
         nums[left], nums[med] = nums[med], nums[left]
         # 以 nums[left] 作为基准数
@@ -67,19 +67,20 @@ class QuickSortMedian:
         nums[i], nums[left] = nums[left], nums[i]
         return i  # 返回基准数的索引
 
-    def quick_sort(self, nums, left, right):
+    def quick_sort(self, nums: List[int], left: int, right: int) -> None:
         """ 快速排序 """
         # 子数组长度为 1 时终止递归
-        if left >= right: return
+        if left >= right:
+            return
         # 哨兵划分
-        pivot = self.partition(nums, left, right)
+        pivot: int = self.partition(nums, left, right)
         # 递归左子数组、右子数组
         self.quick_sort(nums, left, pivot - 1)
         self.quick_sort(nums, pivot + 1, right)
 
 class QuickSortTailCall:
     """ 快速排序类（尾递归优化） """
-    def partition(self, nums, left, right):
+    def partition(self, nums: List[int], left: int, right: int) -> int:
         """ 哨兵划分 """
         # 以 nums[left] 作为基准数
         i, j = left, right
@@ -94,12 +95,12 @@ class QuickSortTailCall:
         nums[i], nums[left] = nums[left], nums[i]
         return i  # 返回基准数的索引
 
-    def quick_sort(self, nums, left, right):
+    def quick_sort(self, nums: List[int], left: int, right: int) -> None:
         """ 快速排序（尾递归优化） """
         # 子数组长度为 1 时终止
         while left < right:
             # 哨兵划分操作
-            pivot = self.partition(nums, left, right)
+            pivot: int = self.partition(nums, left, right)
             # 对两个子数组中较短的那个执行快排
             if pivot - left < right - pivot:
                 self.quick_sort(nums, left, pivot - 1)  # 递归排序左子数组
@@ -112,16 +113,16 @@ class QuickSortTailCall:
 """ Driver Code """
 if __name__ == '__main__':
     # 快速排序 
-    nums = [2, 4, 1, 0, 3, 5]
+    nums: List[int] = [2, 4, 1, 0, 3, 5]
     QuickSort().quick_sort(nums, 0, len(nums) - 1)
     print("快速排序完成后 nums =", nums)
 
     # 快速排序（中位基准数优化）
-    nums1 = [2, 4, 1, 0, 3, 5]
+    nums1: List[int] = [2, 4, 1, 0, 3, 5]
     QuickSortMedian().quick_sort(nums1, 0, len(nums1) - 1)
     print("快速排序（中位基准数优化）完成后 nums =", nums1)
 
     # 快速排序（尾递归优化）
-    nums2 = [2, 4, 1, 0, 3, 5]
+    nums2: List[int] = [2, 4, 1, 0, 3, 5]
     QuickSortTailCall().quick_sort(nums2, 0, len(nums2) - 1)
     print("快速排序（尾递归优化）完成后 nums =", nums2)