feat: add Swift codes for chapter_sorting articles (#313)

* feat: add Swift codes for bubble_sort article

* feat: add Swift codes for insertion_sort article

* feat: add Swift codes for quick_sort article

* feat: add Swift codes for merge_sort article

* feat: add Swift codes for radix_sort

* refactor: remove ^ operator

docs/chapter_sorting/quick_sort.md

@@ -233,7 +233,30 @@ comments: true
 === "Swift"
 
     ```swift title="quick_sort.swift"
+    /* 元素交换 */
+    func swap(nums: inout [Int], i: Int, j: Int) {
+        let tmp = nums[i]
+        nums[i] = nums[j]
+        nums[j] = tmp
+    }
 
+    /* 哨兵划分 */
+    func partition(nums: inout [Int], left: Int, right: Int) -> Int {
+        // 以 nums[left] 作为基准数
+        var i = left
+        var j = right
+        while i < j {
+            while i < j, nums[j] >= nums[left] {
+                j -= 1 // 从右向左找首个小于基准数的元素
+            }
+            while i < j, nums[i] <= nums[left] {
+                i += 1 // 从左向右找首个大于基准数的元素
+            }
+            swap(nums: &nums, i: i, j: j) // 交换这两个元素
+        }
+        swap(nums: &nums, i: i, j: left) // 将基准数交换至两子数组的分界线
+        return i // 返回基准数的索引
+    }
     ```
 
 !!! note "快速排序的分治思想"
@@ -375,7 +398,18 @@ comments: true
 === "Swift"
 
     ```swift title="quick_sort.swift"
-
+    /* 快速排序 */
+    func quickSort(nums: inout [Int], left: Int, right: Int) {
+        // 子数组长度为 1 时终止递归
+        if left >= right {
+            return
+        }
+        // 哨兵划分
+        let pivot = partition(nums: &nums, left: left, right: right)
+        // 递归左子数组、右子数组
+        quickSort(nums: &nums, left: left, right: pivot - 1)
+        quickSort(nums: &nums, left: pivot + 1, right: right)
+    }
     ```
 
 ## 算法特性
@@ -596,7 +630,26 @@ comments: true
 === "Swift"
 
     ```swift title="quick_sort.swift"
+    /* 选取三个元素的中位数 */
+    func medianThree(nums: [Int], left: Int, mid: Int, right: Int) -> Int {
+        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
+        }
+    }
 
+    /* 哨兵划分（三数取中值） */
+    func partition(nums: inout [Int], left: Int, right: Int) -> Int {
+        // 选取三个候选元素的中位数
+        let med = medianThree(nums: nums, left: left, mid: (left + right) / 2, right: right)
+        // 将中位数交换至数组最左端
+        swap(nums: &nums, i: left, j: med)
+        // 以 nums[left] 作为基准数
+        // 下同省略...
+    }
     ```
 
 ## 尾递归优化
@@ -763,5 +816,22 @@ comments: true
 === "Swift"
 
     ```swift title="quick_sort.swift"
-
+    /* 快速排序（尾递归优化） */
+    func quickSort(nums: inout [Int], left: Int, right: Int) {
+        var left = left
+        var right = right
+        // 子数组长度为 1 时终止
+        while left < right {
+            // 哨兵划分操作
+            let pivot = partition(nums: &nums, left: left, right: right)
+            // 对两个子数组中较短的那个执行快排
+            if (pivot - left) < (right - pivot) {
+                quickSort(nums: &nums, left: left, right: pivot - 1) // 递归排序左子数组
+                left = pivot + 1 // 剩余待排序区间为 [pivot + 1, right]
+            } else {
+                quickSort(nums: &nums, left: pivot + 1, right: right) // 递归排序右子数组
+                right = pivot - 1 // 剩余待排序区间为 [left, pivot - 1]
+            }
+        }
+    }
     ```