algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-11-04 14:18:20 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
* feat: add Swift codes for hash_collision article

* refactor: extract common Pair

* Update hash_map.md

---------

Co-authored-by: Yudong Jin <krahets@163.com>
This commit is contained in:
nuomi1
2023-07-01 20:39:55 +08:00
committed by GitHub
parent 69920a0599
commit 7f8b0fff54
6 changed files with 335 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
codes/swift/Package.swift
View File

@ -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"]),

11
codes/swift/chapter_hashing/array_hash_map.swift
View File

@ -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 {

137
codes/swift/chapter_hashing/hash_map_chaining.swift Normal file
View File

@ -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()
}
}

158
codes/swift/chapter_hashing/hash_map_open_addressing.swift Normal file
View File

@ -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()
}
}

20
codes/swift/utils/Pair.swift Normal file
View File

@ -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
}
}

15
docs/chapter_hashing/hash_map.md
View File

@ -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]{}
```