diff --git a/docs/chapter_sorting/quick_sort.md b/docs/chapter_sorting/quick_sort.md
index b0fb8f4db..2bff19b7b 100755
--- a/docs/chapter_sorting/quick_sort.md
+++ b/docs/chapter_sorting/quick_sort.md
@@ -302,19 +302,16 @@ comments: true
         nums[j] = tmp;
     }
 
-    /* 快速排序类 */
-    // 快速排序类-哨兵划分
+    /* 哨兵划分 */
     int partition(int nums[], int left, int right) {
         // 以 nums[left] 为基准数
         int i = left, j = right;
         while (i < j) {
             while (i < j && nums[j] >= nums[left]) {
-                // 从右向左找首个小于基准数的元素
-                j--;
+                j--; // 从右向左找首个小于基准数的元素
             }
             while (i < j && nums[i] <= nums[left]) {
-                // 从左向右找首个大于基准数的元素
-                i++;
+                i++; // 从左向右找首个大于基准数的元素
             }
             // 交换这两个元素
             swap(nums, i, j);
@@ -563,30 +560,7 @@ comments: true
 === "C"
 
     ```c title="quick_sort.c"
-    /* 快速排序类 */
-    // 快速排序类-哨兵划分
-    int partition(int nums[], int left, int right) {
-        // 以 nums[left] 为基准数
-        int i = left, j = right;
-        while (i < j) {
-            while (i < j && nums[j] >= nums[left]) {
-                // 从右向左找首个小于基准数的元素
-                j--;
-            }
-            while (i < j && nums[i] <= nums[left]) {
-                // 从左向右找首个大于基准数的元素
-                i++;
-            }
-            // 交换这两个元素
-            swap(nums, i, j);
-        }
-        // 将基准数交换至两子数组的分界线
-        swap(nums, i, left);
-        // 返回基准数的索引
-        return i;
-    }
-
-    // 快速排序类-快速排序
+    /* 快速排序 */
     void quickSort(int nums[], int left, int right) {
         // 子数组长度为 1 时终止递归
         if (left >= right) {
@@ -1022,8 +996,7 @@ comments: true
 === "C"
 
     ```c title="quick_sort.c"
-    /* 快速排序类（中位基准数优化） */
-    // 选取三个候选元素的中位数
+    /* 选取三个候选元素的中位数 */
     int medianThree(int nums[], int left, int mid, int right) {
         int l = nums[left], m = nums[mid], r = nums[right];
         if ((l <= m && m <= r) || (r <= m && m <= l))
@@ -1033,7 +1006,7 @@ comments: true
         return right;
     }
 
-    /* 哨兵划分（三数取中值） */ 
+    /* 哨兵划分（三数取中值） */
     int partitionMedian(int nums[], int left, int right) {
         // 选取三个候选元素的中位数
         int med = medianThree(nums, left, (left + right) / 2, right);
@@ -1068,20 +1041,24 @@ comments: true
         return right
     }
 
-    /* 哨兵划分 */
-    fun partition(nums: IntArray, left: Int, right: Int): Int {
+    /* 哨兵划分（三数取中值） */
+    fun partitionMedian(nums: IntArray, left: Int, right: Int): Int {
+        // 选取三个候选元素的中位数
+        val med = medianThree(nums, left, (left + right) / 2, right)
+        // 将中位数交换至数组最左端
+        swap(nums, left, med)
         // 以 nums[left] 为基准数
         var i = left
         var j = right
         while (i < j) {
             while (i < j && nums[j] >= nums[left])
-                j--           // 从右向左找首个小于基准数的元素
+                j--                      // 从右向左找首个小于基准数的元素
             while (i < j && nums[i] <= nums[left])
-                i++           // 从左向右找首个大于基准数的元素
-            swap(nums, i, j)  // 交换这两个元素
+                i++                      // 从左向右找首个大于基准数的元素
+            swap(nums, i, j)             // 交换这两个元素
         }
-        swap(nums, i, left)   // 将基准数交换至两子数组的分界线
-        return i              // 返回基准数的索引
+        swap(nums, i, left)              // 将基准数交换至两子数组的分界线
+        return i                         // 返回基准数的索引
     }
     ```
 
@@ -1350,8 +1327,7 @@ comments: true
 === "C"
 
     ```c title="quick_sort.c"
-    /* 快速排序类（尾递归优化） */
-    // 快速排序（尾递归优化）
+    /* 快速排序（尾递归优化） */
     void quickSortTailCall(int nums[], int left, int right) {
         // 子数组长度为 1 时终止
         while (left < right) {
@@ -1359,11 +1335,15 @@ comments: true
             int pivot = partition(nums, left, right);
             // 对两个子数组中较短的那个执行快速排序
             if (pivot - left < right - pivot) {
-                quickSortTailCall(nums, left, pivot - 1); // 递归排序左子数组
-                left = pivot + 1;                         // 剩余未排序区间为 [pivot + 1, right]
+                // 递归排序左子数组
+                quickSortTailCall(nums, left, pivot - 1);
+                // 剩余未排序区间为 [pivot + 1, right]
+                left = pivot + 1;
             } else {
-                quickSortTailCall(nums, pivot + 1, right); // 递归排序右子数组
-                right = pivot - 1;                         // 剩余未排序区间为 [left, pivot - 1]
+                // 递归排序右子数组
+                quickSortTailCall(nums, pivot + 1, right);
+                // 剩余未排序区间为 [left, pivot - 1]
+                right = pivot - 1;
             }
         }
     }
diff --git a/overrides/main.html b/overrides/main.html
index 34d38843e..36cd9e32a 100644
--- a/overrides/main.html
+++ b/overrides/main.html
@@ -6,7 +6,7 @@
 {% elif config.theme.language == 'zh-Hant' %}
     {% set announcements = '紙質書（簡體中文版）已發行，詳情請見<a href="/chapter_paperbook/">這裡</a>' %}
 {% elif config.theme.language == 'en' %}
-    {% set announcements = 'Feel free to engage in Chinese-to-English translation and pull request review! Please visit <a href="https://github.com/krahets/hello-algo/issues/914">#914</a> for details.' %}
+    {% set announcements = 'Welcome to contribute to Chinese-to-English translation! Please visit <a href="https://github.com/krahets/hello-algo/issues/914">#914</a> for more details.' %}
 {% endif %}
 <div class="banner-svg">
     <svg xmlns="http://www.w3.org/2000/svg"
diff --git a/zh-Hant/docs/chapter_sorting/quick_sort.md b/zh-Hant/docs/chapter_sorting/quick_sort.md
index adf26b26d..722f002f9 100755
--- a/zh-Hant/docs/chapter_sorting/quick_sort.md
+++ b/zh-Hant/docs/chapter_sorting/quick_sort.md
@@ -1068,20 +1068,24 @@ comments: true
         return right
     }
 
-    /* 哨兵劃分 */
-    fun partition(nums: IntArray, left: Int, right: Int): Int {
+    /* 哨兵劃分（三數取中值） */
+    fun partitionMedian(nums: IntArray, left: Int, right: Int): Int {
+        // 選取三個候選元素的中位數
+        val med = medianThree(nums, left, (left + right) / 2, right)
+        // 將中位數交換至陣列最左端
+        swap(nums, left, med)
         // 以 nums[left] 為基準數
         var i = left
         var j = right
         while (i < j) {
             while (i < j && nums[j] >= nums[left])
-                j--           // 從右向左找首個小於基準數的元素
+                j--                      // 從右向左找首個小於基準數的元素
             while (i < j && nums[i] <= nums[left])
-                i++           // 從左向右找首個大於基準數的元素
-            swap(nums, i, j)  // 交換這兩個元素
+                i++                      // 從左向右找首個大於基準數的元素
+            swap(nums, i, j)             // 交換這兩個元素
         }
-        swap(nums, i, left)   // 將基準數交換至兩子陣列的分界線
-        return i              // 返回基準數的索引
+        swap(nums, i, left)              // 將基準數交換至兩子陣列的分界線
+        return i                         // 返回基準數的索引
     }
     ```