feature(swift): Reimplement merge_sort and top_k (#898)

* feat: Add swift-collections

* fix: use heap

* refactor: merge

* fix: import HeapModule

codes/swift/Package.resolved

@@ -0,0 +1,14 @@
+{
+  "pins" : [
+    {
+      "identity" : "swift-collections",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-collections",
+      "state" : {
+        "branch" : "release/1.1",
+        "revision" : "4a1d92ba85027010d2c528c05576cde9a362254b"
+      }
+    }
+  ],
+  "version" : 2
+}

codes/swift/Package.swift

@@ -99,6 +99,9 @@ let package = Package(
         .executable(name: "max_capacity", targets: ["max_capacity"]),
         .executable(name: "max_product_cutting", targets: ["max_product_cutting"]),
     ],
+    dependencies: [
+        .package(url: "https://github.com/apple/swift-collections", branch: "release/1.1"),
+    ],
     targets: [
         // helper
         .target(name: "utils", path: "utils"),
@@ -141,7 +144,7 @@ let package = Package(
         .executableTarget(name: "avl_tree", dependencies: ["utils"], path: "chapter_tree", sources: ["avl_tree.swift"]),
         // chapter_heap
         .executableTarget(name: "my_heap", dependencies: ["utils"], path: "chapter_heap", sources: ["my_heap.swift"]),
-        .executableTarget(name: "top_k", dependencies: ["utils"], path: "chapter_heap", sources: ["top_k.swift"]),
+        .executableTarget(name: "top_k", dependencies: ["utils", .product(name: "HeapModule", package: "swift-collections")], path: "chapter_heap", sources: ["top_k.swift"]),
         // chapter_graph
         .executableTarget(name: "graph_adjacency_matrix", dependencies: ["utils"], path: "chapter_graph", sources: ["graph_adjacency_matrix.swift"]),
         .executableTarget(name: "graph_adjacency_list", dependencies: ["utils"], path: "chapter_graph", sources: ["graph_adjacency_list.swift"]),

codes/swift/chapter_heap/top_k.swift

@@ -4,21 +4,22 @@
  * Author: nuomi1 (nuomi1@qq.com)
  */
 
+import HeapModule
 import utils
 
 /* 基于堆查找数组中最大的 k 个元素 */
 func topKHeap(nums: [Int], k: Int) -> [Int] {
     // 将数组的前 k 个元素入堆
-    var heap = Array(nums.prefix(k))
+    var heap = Heap(nums.prefix(k))
     // 从第 k+1 个元素开始，保持堆的长度为 k
     for i in stride(from: k, to: nums.count, by: 1) {
         // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
-        if nums[i] > heap.first! {
+        if nums[i] > heap.min()! {
-            heap.removeFirst()
+            _ = heap.removeMin()
-            heap.insert(nums[i], at: 0)
+            heap.insert(nums[i])
         }
     }
-    return heap
+    return heap.unordered
 }
 
 @main

codes/swift/chapter_sorting/merge_sort.swift

@@ -5,38 +5,39 @@
  */
 
 /* 合并左子数组和右子数组 */
-// 左子数组区间 [left, mid]
-// 右子数组区间 [mid + 1, right]
 func merge(nums: inout [Int], left: Int, mid: Int, right: Int) {
-    // 初始化辅助数组
+    // 左子数组区间 [left, mid], 右子数组区间 [mid+1, right]
-    let tmp = Array(nums[left ..< (right + 1)])
+    // 创建一个临时数组 tmp ，用于存放合并后的结果
-    // 左子数组的起始索引和结束索引
+    var tmp = Array(repeating: 0, count: right - left + 1)
-    let leftStart = left - left
+    // 初始化左子数组和右子数组的起始索引
-    let leftEnd = mid - left
+    var i = left, j = mid + 1, k = 0
-    // 右子数组的起始索引和结束索引
+    // 当左右子数组都还有元素时，比较并将较小的元素复制到临时数组中
-    let rightStart = mid + 1 - left
+    while i <= mid, j <= right {
-    let rightEnd = right - left
+        if nums[i] <= nums[j] {
-    // i, j 分别指向左子数组、右子数组的首元素
+            tmp[k] = nums[i]
-    var i = leftStart
-    var j = rightStart
-    // 通过覆盖原数组 nums 来合并左子数组和右子数组
-    for k in left ... right {
-        // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
-        if i > leftEnd {
-            nums[k] = tmp[j]
-            j += 1
-        }
-        // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
-        else if j > rightEnd || tmp[i] <= tmp[j] {
-            nums[k] = tmp[i]
             i += 1
-        }
+            k += 1
-        // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+        } else {
-        else {
+            tmp[k] = nums[j]
-            nums[k] = tmp[j]
             j += 1
+            k += 1
         }
     }
+    // 将左子数组和右子数组的剩余元素复制到临时数组中
+    while i <= mid {
+        tmp[k] = nums[i]
+        i += 1
+        k += 1
+    }
+    while j <= right {
+        tmp[k] = nums[j]
+        j += 1
+        k += 1
+    }
+    // 将临时数组 tmp 中的元素复制回原数组 nums 的对应区间
+    for k in tmp.indices {
+        nums[left + k] = tmp[k]
+    }
 }
 
 /* 归并排序 */