1. Fix the import error.

2. Some codes fine tuning.

docs/chapter_sorting/quick_sort.md

@@ -61,6 +61,25 @@ comments: true
     }
     ```
 
+=== "Python"
+
+    ```python title="quick_sort.py"
+    """ 哨兵划分 """
+    def partition(self, nums, left, right):
+        # 以 nums[left] 作为基准数
+        i, j = left, right
+        while i < j:
+            while i < j and nums[j] >= nums[left]:
+                j -= 1  # 从右向左找首个小于基准数的元素
+            while i < j and nums[i] <= nums[left]:
+                i += 1  # 从左向右找首个大于基准数的元素
+            # 元素交换
+            nums[i], nums[j] = nums[j], nums[i]
+        # 将基准数交换至两子数组的分界线
+        nums[i], nums[left] = nums[left], nums[i]
+        return i  # 返回基准数的索引
+    ```
+
 !!! note "快速排序的分治思想"
 
     哨兵划分的实质是将 **一个长数组的排序问题** 简化为 **两个短数组的排序问题**。
@@ -93,6 +112,21 @@ comments: true
     }
     ```
 
+=== "Python"
+
+    ```python title="quick_sort.py"
+    """ 快速排序 """
+    def quick_sort(self, nums, left, right):
+        # 子数组长度为 1 时终止递归
+        if left >= right:
+            return
+        # 哨兵划分
+        pivot = self.partition(nums, left, right)
+        # 递归左子数组、右子数组
+        self.quick_sort(nums, left, pivot - 1)
+        self.quick_sort(nums, pivot + 1, right)
+    ```
+
 ## 算法特性
 
 **平均时间复杂度 $O(n \log n)$ ：** 平均情况下，哨兵划分的递归层数为 $\log n$ ，每层中的总循环数为 $n$ ，总体使用 $O(n \log n)$ 时间。
@@ -149,6 +183,29 @@ comments: true
     }
     ```
 
+=== "Python"
+
+    ```python title="quick_sort.py"
+    """ 选取三个元素的中位数 """
+    def median_three(self, nums, left, mid, right):
+        # 使用了异或操作来简化代码
+        # 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
+        if (nums[left] > nums[mid]) ^ (nums[left] > nums[right]):
+            return left
+        elif (nums[mid] < nums[left]) ^ (nums[mid] > nums[right]):
+            return mid
+        return right
+
+    """ 哨兵划分（三数取中值） """
+    def partition(self, nums, left, right):
+        # 以 nums[left] 作为基准数
+        med = self.median_three(nums, left, (left + right) // 2, right)
+        # 将中位数交换至数组最左端
+        nums[left], nums[med] = nums[med], nums[left]
+        # 以 nums[left] 作为基准数
+        # 下同省略...
+    ```
+
 ## 尾递归优化
 
 **普通快速排序在某些输入下的空间效率变差。** 仍然以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 0 ，那么将形成一个高度为 $n - 1$ 的递归树，此时使用的栈帧空间大小劣化至 $O(n)$ 。
@@ -175,3 +232,21 @@ comments: true
         }
     }
     ```
+
+=== "Python"
+
+    ```python title="quick_sort.py"
+    """ 快速排序（尾递归优化） """
+    def quick_sort(self, nums, left, right):
+        # 子数组长度为 1 时终止
+        while left < right:
+            # 哨兵划分操作
+            pivot = self.partition(nums, left, right)
+            # 对两个子数组中较短的那个执行快排
+            if pivot - left < right - pivot:
+                self.quick_sort(nums, left, pivot - 1)  # 递归排序左子数组
+                left = pivot + 1     # 剩余待排序区间为 [pivot + 1, right]
+            else:
+                self.quick_sort(nums, pivot + 1, right)  # 递归排序右子数组
+                right = pivot - 1    # 剩余待排序区间为 [left, pivot - 1]
+    ```