完善所以c#相关的文档和代码

docs/chapter_sorting/quick_sort.md

@@ -196,6 +196,30 @@ comments: true
 === "C#"
 
     ```csharp title="quick_sort.cs"
+    /* 元素交换 */
+    void swap(int[] nums, int i, int j)
+    {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        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--;          // 从右向左找首个小于基准数的元素
+            while (i < j && nums[i] <= nums[left])
+                i++;          // 从左向右找首个大于基准数的元素
+            swap(nums, i, j); // 交换这两个元素
+        }
+        swap(nums, i, left);  // 将基准数交换至两子数组的分界线
+        return i;             // 返回基准数的索引
+    }
 
     ```
 
@@ -235,7 +259,7 @@ comments: true
 
     ```cpp title="quick_sort.cpp"
     /* 快速排序 */
-    static void quickSort(vector<int>& nums, int left, int right) {
+    void quickSort(vector<int>& nums, int left, int right) {
         // 子数组长度为 1 时终止递归
         if (left >= right)
             return;
@@ -320,6 +344,18 @@ comments: true
 === "C#"
 
     ```csharp title="quick_sort.cs"
+    /* 快速排序 */
+    void quickSort(int[] nums, int left, int right)
+    {
+        // 子数组长度为 1 时终止递归
+        if (left >= right)
+            return;
+        // 哨兵划分
+        int pivot = partition(nums, left, right);
+        // 递归左子数组、右子数组
+        quickSort(nums, left, pivot - 1);
+        quickSort(nums, pivot + 1, right);
+    }
 
     ```
 
@@ -513,7 +549,39 @@ comments: true
 === "C#"
 
     ```csharp title="quick_sort.cs"
+    /* 选取三个元素的中位数 */
+    int medianThree(int[] nums, int left, int mid, int right)
+    {
+        // 使用了异或操作来简化代码
+        // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
+        if ((nums[left] > nums[mid]) ^ (nums[left] > nums[right]))
+            return left;
+        else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))
+            return mid;
+        else
+            return right;
+    }
 
+    /* 哨兵划分（三数取中值） */
+    int partition(int[] nums, int left, int right)
+    {
+        // 选取三个候选元素的中位数
+        int med = medianThree(nums, left, (left + right) / 2, right);
+        // 将中位数交换至数组最左端
+        swap(nums, left, med);
+        // 以 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;             // 返回基准数的索引
+    }
     ```
 
 ## 尾递归优化
@@ -547,7 +615,7 @@ comments: true
 
     ```cpp title="quick_sort.cpp"
     /* 快速排序（尾递归优化） */
-    static void quickSort(vector<int>& nums, int left, int right) {
+    void quickSort(vector<int>& nums, int left, int right) {
         // 子数组长度为 1 时终止
         while (left < right) {
             // 哨兵划分操作
@@ -654,5 +722,25 @@ comments: true
 === "C#"
 
     ```csharp title="quick_sort.cs"
-
+    /* 快速排序（尾递归优化） */
+    void quickSort(int[] nums, int left, int right)
+    {
+        // 子数组长度为 1 时终止
+        while (left < right)
+        {
+            // 哨兵划分操作
+            int pivot = partition(nums, left, right);
+            // 对两个子数组中较短的那个执行快排
+            if (pivot - left < right - pivot)
+            {
+                quickSort(nums, left, pivot - 1);  // 递归排序左子数组
+                left = pivot + 1;  // 剩余待排序区间为 [pivot + 1, right]
+            }
+            else
+            {
+                quickSort(nums, pivot + 1, right); // 递归排序右子数组
+                right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
+            }
+        }
+    }
     ```