feat: add Swift codes for hash_collision article (#569)

* feat: add Swift codes for hash_collision article

* refactor: extract common Pair

* Update hash_map.md

---------

Co-authored-by: Yudong Jin <krahets@163.com>

codes/swift/Package.swift

@@ -27,6 +27,8 @@ let package = Package(
         // chapter_hashing
         .executable(name: "hash_map", targets: ["hash_map"]),
         .executable(name: "array_hash_map", targets: ["array_hash_map"]),
+        .executable(name: "hash_map_chaining", targets: ["hash_map_chaining"]),
+        .executable(name: "hash_map_open_addressing", targets: ["hash_map_open_addressing"]),
         // chapter_tree
         .executable(name: "binary_tree", targets: ["binary_tree"]),
         .executable(name: "binary_tree_bfs", targets: ["binary_tree_bfs"]),
@@ -90,7 +92,9 @@ let package = Package(
         .executableTarget(name: "array_deque", path: "chapter_stack_and_queue", sources: ["array_deque.swift"]),
         // chapter_hashing
         .executableTarget(name: "hash_map", dependencies: ["utils"], path: "chapter_hashing", sources: ["hash_map.swift"]),
-        .executableTarget(name: "array_hash_map", path: "chapter_hashing", sources: ["array_hash_map.swift"]),
+        .executableTarget(name: "array_hash_map", dependencies: ["utils"], path: "chapter_hashing", sources: ["array_hash_map.swift"]),
+        .executableTarget(name: "hash_map_chaining", dependencies: ["utils"], path: "chapter_hashing", sources: ["hash_map_chaining.swift"]),
+        .executableTarget(name: "hash_map_open_addressing", dependencies: ["utils"], path: "chapter_hashing", sources: ["hash_map_open_addressing.swift"]),
         // chapter_tree
         .executableTarget(name: "binary_tree", dependencies: ["utils"], path: "chapter_tree", sources: ["binary_tree.swift"]),
         .executableTarget(name: "binary_tree_bfs", dependencies: ["utils"], path: "chapter_tree", sources: ["binary_tree_bfs.swift"]),

codes/swift/chapter_hashing/array_hash_map.swift

@@ -4,16 +4,7 @@
  * Author: nuomi1 (nuomi1@qq.com)
  */
 
-/* 键值对 */
-class Pair {
-    var key: Int
-    var val: String
-
-    init(key: Int, val: String) {
-        self.key = key
-        self.val = val
-    }
-}
+import utils
 
 /* 基于数组简易实现的哈希表 */
 class ArrayHashMap {

codes/swift/chapter_hashing/hash_map_chaining.swift

@@ -0,0 +1,137 @@
+/**
+ * File: hash_map_chaining.swift
+ * Created Time: 2023-06-28
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+/* 链式地址哈希表 */
+class HashMapChaining {
+    var size: Int // 键值对数量
+    var capacity: Int // 哈希表容量
+    var loadThres: Double // 触发扩容的负载因子阈值
+    var extendRatio: Int // 扩容倍数
+    var buckets: [[Pair]] // 桶数组
+
+    /* 构造方法 */
+    init() {
+        size = 0
+        capacity = 4
+        loadThres = 2 / 3
+        extendRatio = 2
+        buckets = Array(repeating: [], count: capacity)
+    }
+
+    /* 哈希函数 */
+    func hashFunc(key: Int) -> Int {
+        key % capacity
+    }
+
+    /* 负载因子 */
+    func loadFactor() -> Double {
+        Double(size / capacity)
+    }
+
+    /* 查询操作 */
+    func get(key: Int) -> String? {
+        let index = hashFunc(key: key)
+        let bucket = buckets[index]
+        // 遍历桶，若找到 key 则返回对应 val
+        for pair in bucket {
+            if pair.key == key {
+                return pair.val
+            }
+        }
+        // 若未找到 key 则返回 nil
+        return nil
+    }
+
+    /* 添加操作 */
+    func put(key: Int, val: String) {
+        // 当负载因子超过阈值时，执行扩容
+        if loadFactor() > loadThres {
+            extend()
+        }
+        let index = hashFunc(key: key)
+        let bucket = buckets[index]
+        // 遍历桶，若遇到指定 key ，则更新对应 val 并返回
+        for pair in bucket {
+            if pair.key == key {
+                pair.val = val
+                return
+            }
+        }
+        // 若无该 key ，则将键值对添加至尾部
+        let pair = Pair(key: key, val: val)
+        buckets[index].append(pair)
+        size += 1
+    }
+
+    /* 删除操作 */
+    func remove(key: Int) {
+        let index = hashFunc(key: key)
+        let bucket = buckets[index]
+        // 遍历桶，从中删除键值对
+        for (pairIndex, pair) in bucket.enumerated() {
+            if pair.key == key {
+                buckets[index].remove(at: pairIndex)
+            }
+        }
+        size -= 1
+    }
+
+    /* 扩容哈希表 */
+    func extend() {
+        // 暂存原哈希表
+        let bucketsTmp = buckets
+        // 初始化扩容后的新哈希表
+        capacity *= extendRatio
+        buckets = Array(repeating: [], count: capacity)
+        size = 0
+        // 将键值对从原哈希表搬运至新哈希表
+        for bucket in bucketsTmp {
+            for pair in bucket {
+                put(key: pair.key, val: pair.val)
+            }
+        }
+    }
+
+    /* 打印哈希表 */
+    func print() {
+        for bucket in buckets {
+            let res = bucket.map { "\($0.key) -> \($0.val)" }
+            Swift.print(res)
+        }
+    }
+}
+
+@main
+enum _HashMapChaining {
+    /* Driver Code */
+    static func main() {
+        /* 初始化哈希表 */
+        let map = HashMapChaining()
+
+        /* 添加操作 */
+        // 在哈希表中添加键值对 (key, value)
+        map.put(key: 12836, val: "小哈")
+        map.put(key: 15937, val: "小啰")
+        map.put(key: 16750, val: "小算")
+        map.put(key: 13276, val: "小法")
+        map.put(key: 10583, val: "小鸭")
+        print("\n添加完成后，哈希表为\nKey -> Value")
+        map.print()
+
+        /* 查询操作 */
+        // 向哈希表输入键 key ，得到值 value
+        let name = map.get(key: 13276)
+        print("\n输入学号 13276 ，查询到姓名 \(name!)")
+
+        /* 删除操作 */
+        // 在哈希表中删除键值对 (key, value)
+        map.remove(key: 12836)
+        print("\n删除 12836 后，哈希表为\nKey -> Value")
+        map.print()
+    }
+}

codes/swift/chapter_hashing/hash_map_open_addressing.swift

@@ -0,0 +1,158 @@
+/**
+ * File: hash_map_open_addressing.swift
+ * Created Time: 2023-06-28
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+/* 开放寻址哈希表 */
+class HashMapOpenAddressing {
+    var size: Int // 键值对数量
+    var capacity: Int // 哈希表容量
+    var loadThres: Double // 触发扩容的负载因子阈值
+    var extendRatio: Int // 扩容倍数
+    var buckets: [Pair?] // 桶数组
+    var removed: Pair // 删除标记
+
+    /* 构造方法 */
+    init() {
+        size = 0
+        capacity = 4
+        loadThres = 2 / 3
+        extendRatio = 2
+        buckets = Array(repeating: nil, count: capacity)
+        removed = Pair(key: -1, val: "-1")
+    }
+
+    /* 哈希函数 */
+    func hashFunc(key: Int) -> Int {
+        key % capacity
+    }
+
+    /* 负载因子 */
+    func loadFactor() -> Double {
+        Double(size / capacity)
+    }
+
+    /* 查询操作 */
+    func get(key: Int) -> String? {
+        let index = hashFunc(key: key)
+        // 线性探测，从 index 开始向后遍历
+        for i in stride(from: 0, to: capacity, by: 1) {
+            // 计算桶索引，越过尾部返回头部
+            let j = (index + i) % capacity
+            // 若遇到空桶，说明无此 key ，则返回 nil
+            if buckets[j] == nil {
+                return nil
+            }
+            // 若遇到指定 key ，则返回对应 val
+            if buckets[j]?.key == key, buckets[j] != removed {
+                return buckets[j]?.val
+            }
+        }
+        return nil
+    }
+
+    /* 添加操作 */
+    func put(key: Int, val: String) {
+        // 当负载因子超过阈值时，执行扩容
+        if loadFactor() > loadThres {
+            extend()
+        }
+        let index = hashFunc(key: key)
+        // 线性探测，从 index 开始向后遍历
+        for i in stride(from: 0, through: capacity, by: 1) {
+            // 计算桶索引，越过尾部返回头部
+            let j = (index + i) % capacity
+            // 若遇到空桶、或带有删除标记的桶，则将键值对放入该桶
+            if buckets[j] == nil || buckets[j] == removed {
+                buckets[j] = Pair(key: key, val: val)
+                size += 1
+                return
+            }
+            // 若遇到指定 key ，则更新对应 val
+            if buckets[j]?.key == key {
+                buckets[j]?.val = val
+                return
+            }
+        }
+    }
+
+    /* 删除操作 */
+    func remove(key: Int) {
+        let index = hashFunc(key: key)
+        // 线性探测，从 index 开始向后遍历
+        for i in stride(from: 0, to: capacity, by: 1) {
+            // 计算桶索引，越过尾部返回头部
+            let j = (index + i) % capacity
+            // 若遇到空桶，说明无此 key ，则直接返回
+            if buckets[j] == nil {
+                return
+            }
+            // 若遇到指定 key ，则标记删除并返回
+            if buckets[j]?.key == key {
+                buckets[j] = removed
+                size -= 1
+                return
+            }
+        }
+    }
+
+    /* 扩容哈希表 */
+    func extend() {
+        // 暂存原哈希表
+        let bucketsTmp = buckets
+        // 初始化扩容后的新哈希表
+        capacity *= extendRatio
+        buckets = Array(repeating: nil, count: capacity)
+        size = 0
+        // 将键值对从原哈希表搬运至新哈希表
+        for pair in bucketsTmp {
+            if let pair, pair != removed {
+                put(key: pair.key, val: pair.val)
+            }
+        }
+    }
+
+    /* 打印哈希表 */
+    func print() {
+        for pair in buckets {
+            if let pair {
+                Swift.print("\(pair.key) -> \(pair.val)")
+            } else {
+                Swift.print("null")
+            }
+        }
+    }
+}
+
+@main
+enum _HashMapOpenAddressing {
+    /* Driver Code */
+    static func main() {
+        /* 初始化哈希表 */
+        let map = HashMapOpenAddressing()
+
+        /* 添加操作 */
+        // 在哈希表中添加键值对 (key, value)
+        map.put(key: 12836, val: "小哈")
+        map.put(key: 15937, val: "小啰")
+        map.put(key: 16750, val: "小算")
+        map.put(key: 13276, val: "小法")
+        map.put(key: 10583, val: "小鸭")
+        print("\n添加完成后，哈希表为\nKey -> Value")
+        map.print()
+
+        /* 查询操作 */
+        // 向哈希表输入键 key ，得到值 value
+        let name = map.get(key: 13276)
+        print("\n输入学号 13276 ，查询到姓名 \(name!)")
+
+        /* 删除操作 */
+        // 在哈希表中删除键值对 (key, value)
+        map.remove(key: 16750)
+        print("\n删除 16750 后，哈希表为\nKey -> Value")
+        map.print()
+    }
+}

codes/swift/utils/Pair.swift

@@ -0,0 +1,20 @@
+/**
+ * File: Pair.swift
+ * Created Time: 2023-06-28
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* 键值对 */
+public class Pair: Equatable {
+    public var key: Int
+    public var val: String
+
+    public init(key: Int, val: String) {
+        self.key = key
+        self.val = val
+    }
+
+    public static func == (lhs: Pair, rhs: Pair) -> Bool {
+        lhs.key == rhs.key && lhs.val == rhs.val
+    }
+}

docs/chapter_hashing/hash_map.md

@@ -515,7 +515,20 @@ index = hash(key) % capacity
 === "Swift"
 
     ```swift title="array_hash_map.swift"
-    [class]{Pair}-[func]{}
+    /* 键值对 */
+    public class Pair: Equatable {
+        public var key: Int
+        public var val: String
+    
+        public init(key: Int, val: String) {
+            self.key = key
+            self.val = val
+        }
+    
+        public static func == (lhs: Pair, rhs: Pair) -> Bool {
+            lhs.key == rhs.key && lhs.val == rhs.val
+        }
+    }
 
     [class]{ArrayHashMap}-[func]{}
     ```