fuhouyin/hello-algo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: complete Dart codes for chapter_hashing (#566)

Browse Source
This commit is contained in:
liuyuxin 2023-06-25 20:57:37 +08:00 committed by GitHub
parent ff58d4113c
commit 62e8f0df50
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 415 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
codes/dart/chapter_hashing/built_in_hash.dart Normal file
View File

@ -0,0 +1,34 @@
/**
* File: built_in_hash.dart
* Created Time: 2023-06-25
* Author: liuyuxin (gvenusleo@gmail.com)
*/
import '../chapter_stack_and_queue/linkedlist_deque.dart';
/* Driver Code */
void main() {
int num = 3;
int hashNum = num.hashCode;
print("整数 $num 的哈希值为 $hashNum");
bool bol = true;
int hashBol = bol.hashCode;
print("布尔值 $bol 的哈希值为 $hashBol");
double dec = 3.14159;
int hashDec = dec.hashCode;
print("小数 $dec 的哈希值为 $hashDec");
String str = "Hello 算法";
int hashStr = str.hashCode;
print("字符串 $str 的哈希值为 $hashStr");
List arr = [12836, "小哈"];
int hashArr = arr.hashCode;
print("数组 $arr 的哈希值为 $hashArr");
ListNode obj = new ListNode(0);
int hashObj = obj.hashCode;
print("节点对象 $obj 的哈希值为 $hashObj");
}

138
codes/dart/chapter_hashing/hash_map_chaining.dart Normal file
View File

@ -0,0 +1,138 @@
/**
* File: hash_map_chaining.dart
* Created Time: 2023-06-24
* Author: liuyuxin (gvenusleo@gmail.com)
*/
/* 键值对 */
class Pair {
int key;
String val;
Pair(this.key, this.val);
}
/* 链式地址哈希表 */
class HashMapChaining {
late int size; // 键值对数量
late int capacity; // 哈希表容量
late double loadThres; // 触发扩容的负载因子阈值
late int extendRatio; // 扩容倍数
late List<List<Pair>> buckets; // 桶数组
/* 构造方法 */
HashMapChaining() {
size = 0;
capacity = 4;
loadThres = 2 / 3.0;
extendRatio = 2;
buckets = List.generate(capacity, (_) => []);
}
/* 哈希函数 */
int hashFunc(int key) {
return key % capacity;
}
/* 负载因子 */
double loadFactor() {
return size / capacity;
}
/* 查询操作 */
String? get(int key) {
int index = hashFunc(key);
List<Pair> bucket = buckets[index];
// 遍历桶，若找到 key 则返回对应 val
for (Pair pair in bucket) {
if (pair.key == key) {
return pair.val;
}
}
// 若未找到 key 则返回 null
return null;
}
/* 添加操作 */
void put(int key, String val) {
// 当负载因子超过阈值时，执行扩容
if (loadFactor() > loadThres) {
extend();
}
int index = hashFunc(key);
List<Pair> bucket = buckets[index];
// 遍历桶，若遇到指定 key ，则更新对应 val 并返回
for (Pair pair in bucket) {
if (pair.key == key) {
pair.val = val;
return;
}
}
// 若无该 key ，则将键值对添加至尾部
Pair pair = Pair(key, val);
bucket.add(pair);
size++;
}
/* 删除操作 */
void remove(int key) {
int index = hashFunc(key);
List<Pair> bucket = buckets[index];
// 遍历桶，从中删除键值对
bucket.removeWhere((Pair pair) => pair.key == key);
size--;
}
/* 扩容哈希表 */
void extend() {
// 暂存原哈希表
List<List<Pair>> bucketsTmp = buckets;
// 初始化扩容后的新哈希表
capacity *= extendRatio;
buckets = List.generate(capacity, (_) => []);
size = 0;
// 将键值对从原哈希表搬运至新哈希表
for (List<Pair> bucket in bucketsTmp) {
for (Pair pair in bucket) {
put(pair.key, pair.val);
}
}
}
/* 打印哈希表 */
void printHashMap() {
for (List<Pair> bucket in buckets) {
List<String> res = [];
for (Pair pair in bucket) {
res.add("${pair.key} -> ${pair.val}");
}
print(res);
}
}
}
/* Driver Code */
void main() {
/* 初始化哈希表 */
HashMapChaining map = HashMapChaining();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.put(12836, "小哈");
map.put(15937, "小啰");
map.put(16750, "小算");
map.put(13276, "小法");
map.put(10583, "小鸭");
print("\n添加完成后，哈希表为\nKey -> Value");
map.printHashMap();
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
String? name = map.get(13276);
print("\n输入学号 13276 ，查询到姓名 ${name}");
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.remove(12836);
print("\n删除 12836 后，哈希表为\nKey -> Value");
map.printHashMap();
}

157
codes/dart/chapter_hashing/hash_map_open_addressing.dart Normal file
View File

@ -0,0 +1,157 @@
/**
* File: hash_map_open_addressing.dart
* Created Time: 2023-06-25
* Author: liuyuxin (gvenusleo@gmail.com)
*/
/* 键值对 */
class Pair {
int key;
String val;
Pair(this.key, this.val);
}
/* 开放寻址哈希表 */
class HashMapOpenAddressing {
late int _size; // 键值对数量
late int _capacity; // 哈希表容量
late double _loadThres; // 触发扩容的负载因子阈值
late int _extendRatio; // 扩容倍数
late List<Pair?> _buckets; // 桶数组
late Pair _removed; // 删除标记
/* 构造方法 */
HashMapOpenAddressing() {
_size = 0;
_capacity = 4;
_loadThres = 2.0 / 3.0;
_extendRatio = 2;
_buckets = List.generate(_capacity, (index) => null);
_removed = Pair(-1, "-1");
}
/* 哈希函数 */
int hashFunc(int key) {
return key % _capacity;
}
/* 负载因子 */
double loadFactor() {
return _size / _capacity;
}
/* 查询操作 */
String? get(int key) {
int index = hashFunc(key);
// 线性探测，从 index 开始向后遍历
for (int i = 0; i < _capacity; i++) {
// 计算桶索引，越过尾部返回头部
int j = (index + i) % _capacity;
// 若遇到空桶，说明无此 key ，则返回 null
if (_buckets[j] == null) return null;
// 若遇到指定 key ，则返回对应 val
if (_buckets[j]!.key == key && _buckets[j] != _removed)
return _buckets[j]!.val;
}
return null;
}
/* 添加操作 */
void put(int key, String val) {
// 当负载因子超过阈值时，执行扩容
if (loadFactor() > _loadThres) {
extend();
}
int index = hashFunc(key);
// 线性探测，从 index 开始向后遍历
for (int i = 0; i < _capacity; i++) {
// 计算桶索引，越过尾部返回头部
int j = (index + i) % _capacity;
// 若遇到空桶、或带有删除标记的桶，则将键值对放入该桶
if (_buckets[j] == null || _buckets[j] == _removed) {
_buckets[j] = new Pair(key, val);
_size += 1;
return;
}
// 若遇到指定 key ，则更新对应 val
if (_buckets[j]!.key == key) {
_buckets[j]!.val = val;
return;
}
}
}
/* 删除操作 */
void remove(int key) {
int index = hashFunc(key);
// 线性探测，从 index 开始向后遍历
for (int i = 0; i < _capacity; i++) {
// 计算桶索引，越过尾部返回头部
int j = (index + i) % _capacity;
// 若遇到空桶，说明无此 key ，则直接返回
if (_buckets[j] == null) {
return;
}
// 若遇到指定 key ，则标记删除并返回
if (_buckets[j]!.key == key) {
_buckets[j] = _removed;
_size -= 1;
return;
}
}
}
/* 扩容哈希表 */
void extend() {
// 暂存原哈希表
List<Pair?> bucketsTmp = _buckets;
// 初始化扩容后的新哈希表
_capacity *= _extendRatio;
_buckets = List.generate(_capacity, (index) => null);
_size = 0;
// 将键值对从原哈希表搬运至新哈希表
for (Pair? pair in bucketsTmp) {
if (pair != null && pair != _removed) {
put(pair.key, pair.val);
}
}
}
/* 打印哈希表 */
void printHashMap() {
for (Pair? pair in _buckets) {
if (pair != null) {
print("${pair.key} -> ${pair.val}");
} else {
print(null);
}
}
}
}
/* Driver Code */
void main() {
/* 初始化哈希表 */
HashMapOpenAddressing map = HashMapOpenAddressing();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.put(12836, "小哈");
map.put(15937, "小啰");
map.put(16750, "小算");
map.put(13276, "小法");
map.put(10583, "小鸭");
print("\n添加完成后，哈希表为\nKey -> Value");
map.printHashMap();
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
String? name = map.get(13276);
print("\n输入学号 13276 ，查询到姓名 $name");
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.remove(16750);
print("\n删除 16750 后，哈希表为\nKey -> Value");
map.printHashMap();
}

62
codes/dart/chapter_hashing/simple_hash.dart Normal file
View File

@ -0,0 +1,62 @@
/**
* File: simple_hash.dart
* Created Time: 2023-06-25
* Author: liuyuxin (gvenusleo@gmail.com)
*/
/* 加法哈希 */
int addHash(String key) {
int hash = 0;
final int MODULUS = 1000000007;
for (int i = 0; i < key.length; i++) {
hash = (hash + key.codeUnitAt(i)) % MODULUS;
}
return hash;
}
/* 乘法哈希 */
int mulHash(String key) {
int hash = 0;
final int MODULUS = 1000000007;
for (int i = 0; i < key.length; i++) {
hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;
}
return hash;
}
/* 异或哈希 */
int xorHash(String key) {
int hash = 0;
final int MODULUS = 1000000007;
for (int i = 0; i < key.length; i++) {
hash ^= key.codeUnitAt(i);
}
return hash & MODULUS;
}
/* 旋转哈希 */
int rotHash(String key) {
int hash = 0;
final int MODULUS = 1000000007;
for (int i = 0; i < key.length; i++) {
hash = ((hash << 4) ^ (hash >> 28) ^ key.codeUnitAt(i)) % MODULUS;
}
return hash;
}
/* Dirver Code */
void main() {
String key = "Hello 算法";
int hash = addHash(key);
print("加法哈希值为 $hash");
hash = mulHash(key);
print("乘法哈希值为 $hash");
hash = xorHash(key);
print("异或哈希值为 $hash");
hash = rotHash(key);
print("旋转哈希值为 $hash");
}

2
codes/java/chapter_hashing/hash_map_open_addressing.java
View File

@ -1,5 +1,5 @@
/**
* File: hash_map_chaining.java
* File: hash_map_open_addressing.java
* Created Time: 2023-06-13
* Author: Krahets (krahets@163.com)
*/

1
codes/java/chapter_hashing/simple_hash.java
View File

@ -32,7 +32,6 @@ public class simple_hash {
int hash = 0;
final int MODULUS = 1000000007;
for (char c : key.toCharArray()) {
System.out.println((int)c);
hash ^= (int) c;
}
return hash & MODULUS;

24
docs/chapter_hashing/hash_algorithm.md
View File

@ -356,7 +356,29 @@ $$
=== "Dart"
```dart title="built_in_hash.dart"
int num = 3;
int hashNum = num.hashCode;
// 整数 3 的哈希值为 34803
bool bol = true;
int hashBol = bol.hashCode;
// 布尔值 true 的哈希值为 1231
double dec = 3.14159;
int hashDec = dec.hashCode;
// 小数 3.14159 的哈希值为 2570631074981783
String str = "Hello 算法";
int hashStr = str.hashCode;
// 字符串 Hello 算法 的哈希值为 468167534
List arr = [12836, "小哈"];
int hashArr = arr.hashCode;
// 数组 [12836, 小哈] 的哈希值为 976512528
ListNode obj = new ListNode(0);
int hashObj = obj.hashCode;
// 节点对象 Instance of 'ListNode' 的哈希值为 1033450432
```
在大多数编程语言中，**只有不可变对象才可作为哈希表的 `key`** 。假如我们将列表（动态数组）作为 `key` ，当列表的内容发生变化时，它的哈希值也随之改变，我们就无法在哈希表中查询到原先的 `value` 了。