build

docs/chapter_hashing/hash_algorithm.md

@@ -554,6 +554,46 @@ index = hash(key) % capacity
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="simple_hash.kt"
+    /* 加法哈希 */
+    fun addHash(key: String): Int {
+        var hash = 0L
+        for (c in key.toCharArray()) {
+            hash = (hash + c.code) % MODULUS
+        }
+        return hash.toInt()
+    }
+
+    /* 乘法哈希 */
+    fun mulHash(key: String): Int {
+        var hash = 0L
+        for (c in key.toCharArray()) {
+            hash = (31 * hash + c.code) % MODULUS
+        }
+        return hash.toInt()
+    }
+
+    /* 异或哈希 */
+    fun xorHash(key: String): Int {
+        var hash = 0
+        for (c in key.toCharArray()) {
+            hash = hash xor c.code
+        }
+        return hash and MODULUS
+    }
+
+    /* 旋转哈希 */
+    fun rotHash(key: String): Int {
+        var hash = 0L
+        for (c in key.toCharArray()) {
+            hash = ((hash shl 4) xor (hash shr 28) xor c.code.toLong()) % MODULUS
+        }
+        return hash.toInt()
+    }
+    ```
+
 === "Zig"
 
     ```zig title="simple_hash.zig"
@@ -868,6 +908,12 @@ $$
     // C 未提供内置 hash code 函数
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="built_in_hash.kt"
+
+    ```
+
 === "Zig"
 
     ```zig title="built_in_hash.zig"

docs/chapter_hashing/hash_collision.md

@@ -1311,6 +1311,121 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="hash_map_chaining.kt"
+    /* 链式地址哈希表 */
+    class HashMapChaining() {
+        var size: Int // 键值对数量
+        var capacity: Int // 哈希表容量
+        val loadThres: Double // 触发扩容的负载因子阈值
+        val extendRatio: Int // 扩容倍数
+        var buckets: MutableList<MutableList<Pair>> // 桶数组
+
+        /* 构造方法 */
+        init {
+            size = 0
+            capacity = 4
+            loadThres = 2.0 / 3.0
+            extendRatio = 2
+            buckets = ArrayList(capacity)
+            for (i in 0..<capacity) {
+                buckets.add(mutableListOf())
+            }
+        }
+
+        /* 哈希函数 */
+        fun hashFunc(key: Int): Int {
+            return key % capacity
+        }
+
+        /* 负载因子 */
+        fun loadFactor(): Double {
+            return (size / capacity).toDouble()
+        }
+
+        /* 查询操作 */
+        fun get(key: Int): String? {
+            val index = hashFunc(key)
+            val bucket = buckets[index]
+            // 遍历桶，若找到 key ，则返回对应 val
+            for (pair in bucket) {
+                if (pair.key == key) return pair.value
+            }
+            // 若未找到 key ，则返回 null
+            return null
+        }
+
+        /* 添加操作 */
+        fun put(key: Int, value: String) {
+            // 当负载因子超过阈值时，执行扩容
+            if (loadFactor() > loadThres) {
+                extend()
+            }
+            val index = hashFunc(key)
+            val bucket = buckets[index]
+            // 遍历桶，若遇到指定 key ，则更新对应 val 并返回
+            for (pair in bucket) {
+                if (pair.key == key) {
+                    pair.value = value
+                    return
+                }
+            }
+            // 若无该 key ，则将键值对添加至尾部
+            val pair = Pair(key, value)
+            bucket.add(pair)
+            size++
+        }
+
+        /* 删除操作 */
+        fun remove(key: Int) {
+            val index = hashFunc(key)
+            val bucket = buckets[index]
+            // 遍历桶，从中删除键值对
+            for (pair in bucket) {
+                if (pair.key == key) {
+                    bucket.remove(pair)
+                    size--
+                    break
+                }
+            }
+        }
+
+        /* 扩容哈希表 */
+        fun extend() {
+            // 暂存原哈希表
+            val bucketsTmp = buckets
+            // 初始化扩容后的新哈希表
+            capacity *= extendRatio
+            // mutablelist 无固定大小
+            buckets = mutableListOf()
+            for (i in 0..<capacity) {
+                buckets.add(mutableListOf())
+            }
+            size = 0
+            // 将键值对从原哈希表搬运至新哈希表
+            for (bucket in bucketsTmp) {
+                for (pair in bucket) {
+                    put(pair.key, pair.value)
+                }
+            }
+        }
+
+        /* 打印哈希表 */
+        fun print() {
+            for (bucket in buckets) {
+                val res = mutableListOf<String>()
+                for (pair in bucket) {
+                    val k = pair.key
+                    val v = pair.value
+                    res.add("$k -> $v")
+                }
+                println(res)
+            }
+        }
+    }
+    ```
+
 === "Zig"
 
     ```zig title="hash_map_chaining.zig"
@@ -2831,6 +2946,132 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="hash_map_open_addressing.kt"
+    /* 开放寻址哈希表 */
+    class HashMapOpenAddressing {
+        private var size: Int = 0 // 键值对数量
+        private var capacity = 4 // 哈希表容量
+        private val loadThres: Double = 2.0 / 3.0 // 触发扩容的负载因子阈值
+        private val extendRatio = 2 // 扩容倍数
+        private var buckets: Array<Pair?> // 桶数组
+        private val TOMBSTONE = Pair(-1, "-1") // 删除标记
+
+        /* 构造方法 */
+        init {
+            buckets = arrayOfNulls(capacity)
+        }
+
+        /* 哈希函数 */
+        fun hashFunc(key: Int): Int {
+            return key % capacity
+        }
+
+        /* 负载因子 */
+        fun loadFactor(): Double {
+            return (size / capacity).toDouble()
+        }
+
+        /* 搜索 key 对应的桶索引 */
+        fun findBucket(key: Int): Int {
+            var index = hashFunc(key)
+            var firstTombstone = -1
+            // 线性探测，当遇到空桶时跳出
+            while (buckets[index] != null) {
+                // 若遇到 key ，返回对应的桶索引
+                if (buckets[index]?.key == key) {
+                    // 若之前遇到了删除标记，则将键值对移动至该索引处
+                    if (firstTombstone != -1) {
+                        buckets[firstTombstone] = buckets[index]
+                        buckets[index] = TOMBSTONE
+                        return firstTombstone // 返回移动后的桶索引
+                    }
+                    return index // 返回桶索引
+                }
+                // 记录遇到的首个删除标记
+                if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {
+                    firstTombstone = index
+                }
+                // 计算桶索引，越过尾部则返回头部
+                index = (index + 1) % capacity
+            }
+            // 若 key 不存在，则返回添加点的索引
+            return if (firstTombstone == -1) index else firstTombstone
+        }
+
+        /* 查询操作 */
+        fun get(key: Int): String? {
+            // 搜索 key 对应的桶索引
+            val index = findBucket(key)
+            // 若找到键值对，则返回对应 val
+            if (buckets[index] != null && buckets[index] != TOMBSTONE) {
+                return buckets[index]?.value
+            }
+            // 若键值对不存在，则返回 null
+            return null
+        }
+
+        /* 添加操作 */
+        fun put(key: Int, value: String) {
+            // 当负载因子超过阈值时，执行扩容
+            if (loadFactor() > loadThres) {
+                extend()
+            }
+            // 搜索 key 对应的桶索引
+            val index = findBucket(key)
+            // 若找到键值对，则覆盖 val 并返回
+            if (buckets[index] != null && buckets[index] != TOMBSTONE) {
+                buckets[index]!!.value = value
+                return
+            }
+            // 若键值对不存在，则添加该键值对
+            buckets[index] = Pair(key, value)
+            size++
+        }
+
+        /* 删除操作 */
+        fun remove(key: Int) {
+            // 搜索 key 对应的桶索引
+            val index = findBucket(key)
+            // 若找到键值对，则用删除标记覆盖它
+            if (buckets[index] != null && buckets[index] != TOMBSTONE) {
+                buckets[index] = TOMBSTONE
+                size--
+            }
+        }
+
+        /* 扩容哈希表 */
+        fun extend() {
+            // 暂存原哈希表
+            val bucketsTmp = buckets
+            // 初始化扩容后的新哈希表
+            capacity *= extendRatio
+            buckets = arrayOfNulls(capacity)
+            size = 0
+            // 将键值对从原哈希表搬运至新哈希表
+            for (pair in bucketsTmp) {
+                if (pair != null && pair != TOMBSTONE) {
+                    put(pair.key, pair.value)
+                }
+            }
+        }
+
+        /* 打印哈希表 */
+        fun print() {
+            for (pair in buckets) {
+                if (pair == null) {
+                    println("null")
+                } else if (pair == TOMBSTONE) {
+                    println("TOMESTOME")
+                } else {
+                    println("${pair.key} -> ${pair.value}")
+                }
+            }
+        }
+    }
+    ```
+
 === "Zig"
 
     ```zig title="hash_map_open_addressing.zig"

docs/chapter_hashing/hash_map.md

@@ -277,6 +277,12 @@ comments: true
     // C 未提供内置哈希表
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="hash_map.kt"
+
+    ```
+
 === "Zig"
 
     ```zig title="hash_map.zig"
@@ -473,6 +479,12 @@ comments: true
     // C 未提供内置哈希表
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="hash_map.kt"
+
+    ```
+
 === "Zig"
 
     ```zig title="hash_map.zig"
@@ -1525,6 +1537,166 @@ index = hash(key) % capacity
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="array_hash_map.kt"
+    /* 键值对 */
+    class Pair(
+        var key: Int,
+        var value: String
+    )
+
+    /* 基于数组实现的哈希表 */
+    class ArrayHashMap {
+        private val buckets = arrayOfNulls<Pair>(100)
+
+        init {
+            // 初始化数组，包含 100 个桶
+            for (i in 0..<100) {
+                buckets[i] = null
+            }
+        }
+
+        /* 哈希函数 */
+        fun hashFunc(key: Int): Int {
+            val index = key % 100
+            return index
+        }
+
+        /* 查询操作 */
+        fun get(key: Int): String? {
+            val index = hashFunc(key)
+            val pair = buckets[index] ?: return null
+            return pair.value
+        }
+
+        /* 添加操作 */
+        fun put(key: Int, value: String) {
+            val pair = Pair(key, value)
+            val index = hashFunc(key)
+            buckets[index] = pair
+        }
+
+        /* 删除操作 */
+        fun remove(key: Int) {
+            val index = hashFunc(key)
+            // 置为 null ，代表删除
+            buckets[index] = null
+        }
+
+        /* 获取所有键值对 */
+        fun pairSet(): MutableList<Pair> {
+            val pairSet = ArrayList<Pair>()
+            for (pair in buckets) {
+                if (pair != null) pairSet.add(pair)
+            }
+            return pairSet
+        }
+
+        /* 获取所有键 */
+        fun keySet(): MutableList<Int> {
+            val keySet = ArrayList<Int>()
+            for (pair in buckets) {
+                if (pair != null) keySet.add(pair.key)
+            }
+            return keySet
+        }
+
+        /* 获取所有值 */
+        fun valueSet(): MutableList<String> {
+            val valueSet = ArrayList<String>()
+            for (pair in buckets) {
+                pair?.let { valueSet.add(it.value) }
+            }
+            return valueSet
+        }
+
+        /* 打印哈希表 */
+        fun print() {
+            for (kv in pairSet()) {
+                val key = kv.key
+                val value = kv.value
+                println("${key}->${value}")
+            }
+        }
+    }
+
+    /* 基于数组实现的哈希表 */
+    class ArrayHashMap {
+        private val buckets = arrayOfNulls<Pair>(100)
+
+        init {
+            // 初始化数组，包含 100 个桶
+            for (i in 0..<100) {
+                buckets[i] = null
+            }
+        }
+
+        /* 哈希函数 */
+        fun hashFunc(key: Int): Int {
+            val index = key % 100
+            return index
+        }
+
+        /* 查询操作 */
+        fun get(key: Int): String? {
+            val index = hashFunc(key)
+            val pair = buckets[index] ?: return null
+            return pair.value
+        }
+
+        /* 添加操作 */
+        fun put(key: Int, value: String) {
+            val pair = Pair(key, value)
+            val index = hashFunc(key)
+            buckets[index] = pair
+        }
+
+        /* 删除操作 */
+        fun remove(key: Int) {
+            val index = hashFunc(key)
+            // 置为 null ，代表删除
+            buckets[index] = null
+        }
+
+        /* 获取所有键值对 */
+        fun pairSet(): MutableList<Pair> {
+            val pairSet = ArrayList<Pair>()
+            for (pair in buckets) {
+                if (pair != null) pairSet.add(pair)
+            }
+            return pairSet
+        }
+
+        /* 获取所有键 */
+        fun keySet(): MutableList<Int> {
+            val keySet = ArrayList<Int>()
+            for (pair in buckets) {
+                if (pair != null) keySet.add(pair.key)
+            }
+            return keySet
+        }
+
+        /* 获取所有值 */
+        fun valueSet(): MutableList<String> {
+            val valueSet = ArrayList<String>()
+            for (pair in buckets) {
+                pair?.let { valueSet.add(it.value) }
+            }
+            return valueSet
+        }
+
+        /* 打印哈希表 */
+        fun print() {
+            for (kv in pairSet()) {
+                val key = kv.key
+                val value = kv.value
+                println("${key}->${value}")
+            }
+        }
+    }
+    ```
+
 === "Zig"
 
     ```zig title="array_hash_map.zig"