yetao
/
hello-algo
mirror of https://github.com/krahets/hello-algo.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat: Add Ruby code - chapter "Hashing" (#1276)

Browse Source 
* feat: add ruby code - chapter hashing

* feat: add ruby code blocks - chapter hashing

* fix: comments
pull/1283/head
khoaxuantu 7 months ago committed by GitHub
parent 2b11639103
commit be9931c8a1
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
9 changed files with 618 additions and 30 deletions
Show Stats Download Patch File Download Diff File

121
codes/ruby/chapter_hashing/array_hash_map.rb
Unescape View File

@ -0,0 +1,121 @@
=begin
File: array_hash_map.rb
Created Time: 2024-04-13
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
### 键值对 ###
class Pair
attr_accessor :key, :val
def initialize(key, val)
@key = key
@val = val
end
end
### 基于数组实现的哈希表 ###
class ArrayHashMap
### 构造方法 ###
def initialize
# 初始化数组，包含 100 个桶
@buckets = Array.new(100)
end
### 哈希函数 ###
def hash_func(key)
index = key % 100
end
### 查询操作 ###
def get(key)
index = hash_func(key)
pair = @buckets[index]
return if pair.nil?
pair.val
end
### 添加操作 ###
def put(key, val)
pair = Pair.new(key, val)
index = hash_func(key)
@buckets[index] = pair
end
### 删除操作 ###
def remove(key)
index = hash_func(key)
# 置为 nil ，代表删除
@buckets[index] = nil
end
### 获取所有键值对 ###
def entry_set
result = []
@buckets.each { |pair| result << pair unless pair.nil? }
result
end
### 获取所有键 ###
def key_set
result = []
@buckets.each { |pair| result << pair.key unless pair.nil? }
result
end
### 获取所有值 ###
def value_set
result = []
@buckets.each { |pair| result << pair.val unless pair.nil? }
result
end
### 打印哈希表 ###
def print
@buckets.each { |pair| puts "#{pair.key} -> #{pair.val}" unless pair.nil? }
end
end
### Driver Code ###
if __FILE__ == $0
# 初始化哈希表
hmap = ArrayHashMap.new
# 添加操作
# 在哈希表中添加键值对 (key, value)
hmap.put(12836, "小哈")
hmap.put(15937, "小啰")
hmap.put(16750, "小算")
hmap.put(13276, "小法")
hmap.put(10583, "小鸭")
puts "\n添加完成后，哈希表为\nKey -> Value"
hmap.print
# 查询操作
# 向哈希表中输入键 key , 得到值 value
name = hmap.get(15937)
puts "\n输入学号 15937 ，查询到姓名 #{name}"
# 删除操作
# 在哈希表中删除值对 (key, value)
hmap.remove(10583)
puts "\n删除 10583 后，哈希表为\nKey -> Value"
hmap.print
# 遍历哈希表
puts "\n遍历键值对 Key->Value"
for pair in hmap.entry_set
puts "#{pair.key} -> #{pair.val}"
end
puts "\n单独篇遍历键 Key"
for key in hmap.key_set
puts key
end
puts "\n单独遍历值 Value"
for val in hmap.value_set
puts val
end
end

34
codes/ruby/chapter_hashing/built_in_hash.rb
Unescape View File

@ -0,0 +1,34 @@
=begin
File: built_in_hash.rb
Created Time: 2024-04-13
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
require_relative '../utils/list_node'
### Driver Code ###
if __FILE__ == $0
num = 3
hash_num = num.hash
puts "整数 #{num} 的哈希值为 #{hash_num}"
bol = true
hash_bol = bol.hash
puts "布尔量 #{bol} 的哈希值为 #{hash_bol}"
dec = 3.14159
hash_dec = dec.hash
puts "小数 #{dec} 的哈希值为 #{hash_dec}"
str = "Hello 算法"
hash_str = str.hash
puts "字符串 #{str} 的哈希值为 #{hash_str}"
tup = [12836, '小哈']
hash_tup = tup.hash
puts "元组 #{tup} 的哈希值为 #{hash_tup}"
obj = ListNode.new(0)
hash_obj = obj.hash
puts "节点对象 #{obj} 的哈希值为 #{hash_obj}"
end

44
codes/ruby/chapter_hashing/hash_map.rb
Unescape View File

@ -0,0 +1,44 @@
=begin
File: hash_map.rb
Created Time: 2024-04-14
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
require_relative '../utils/print_util'
### Driver Code ###
if __FILE__ == $0
# 初始化哈希表
hmap = {}
# 添加操作
# 在哈希表中添加键值对 (key, value)
hmap[12836] = "小哈"
hmap[15937] = "小啰"
hmap[16750] = "小算"
hmap[13276] = "小法"
hmap[10583] = "小鸭"
puts "\n添加完成后，哈希表为\nKey -> Value"
print_hash_map(hmap)
# 查询操作
# 向哈希表中输入键 key ，得到值 value
name = hmap[15937]
puts "\n输入学号 15937 ，查询到姓名 #{name}"
# 删除操作
# 在哈希表中删除键值对 (key, value)
hmap.delete(10583)
puts "\n删除 10583 后，哈希表为\nKey -> Value"
print_hash_map(hmap)
# 遍历哈希表
puts "\n遍历键值对 Key->Value"
hmap.entries.each { |key, value| puts "#{key} -> #{value}" }
puts "\n单独遍历键 Key"
hmap.keys.each { |key| puts key }
puts "\n单独遍历值 Value"
hmap.values.each { |val| puts val }
end

128
codes/ruby/chapter_hashing/hash_map_chaining.rb
Unescape View File

@ -0,0 +1,128 @@
=begin
File: hash_map_chaining.rb
Created Time: 2024-04-13
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
require_relative './array_hash_map'
### 键式地址哈希表 ###
class HashMapChaining
### 构造方法 ###
def initialize
@size = 0 # 键值对数量
@capacity = 4 # 哈希表容量
@load_thres = 2.0 / 3.0 # 触发扩容的负载因子阈值
@extend_ratio = 2 # 扩容倍数
@buckets = Array.new(@capacity) { [] } # 桶数组
end
### 哈希函数 ###
def hash_func(key)
key % @capacity
end
### 负载因子 ###
def load_factor
@size / @capacity
end
### 查询操作 ###
def get(key)
index = hash_func(key)
bucket = @buckets[index]
# 遍历桶，若找到 key ，则返回对应 val
for pair in bucket
return pair.val if pair.key == key
end
# 若未找到 key , 则返回 nil
nil
end
### 添加操作 ###
def put(key, val)
# 当负载因子超过阈值时，执行扩容
extend if load_factor > @load_thres
index = hash_func(key)
bucket = @buckets[index]
# 遍历桶，若遇到指定 key ，则更新对应 val 并返回
for pair in bucket
if pair.key == key
pair.val = val
return
end
end
# 若无该 key ，则将键值对添加至尾部
pair = Pair.new(key, val)
bucket << pair
@size += 1
end
### 删除操作 ###
def remove(key)
index = hash_func(key)
bucket = @buckets[index]
# 遍历桶，从中删除键值对
for pair in bucket
if pair.key == key
bucket.delete(pair)
@size -= 1
break
end
end
end
### 扩容哈希表 ###
def extend
# 暫存原哈希表
buckets = @buckets
# 初始化扩容后的新哈希表
@capacity *= @extend_ratio
@buckets = Array.new(@capacity) { [] }
@size = 0
# 将键值对从原哈希表搬运至新哈希表
for bucket in buckets
for pair in bucket
put(pair.key, pair.val)
end
end
end
### 打印哈希表 ###
def print
for bucket in @buckets
res = []
for pair in bucket
res << "#{pair.key} -> #{pair.val}"
end
pp res
end
end
end
### Driver Code ###
if __FILE__ == $0
### 初始化哈希表
hashmap = HashMapChaining.new
# 添加操作
# 在哈希表中添加键值对 (key, value)
hashmap.put(12836, "小哈")
hashmap.put(15937, "小啰")
hashmap.put(16750, "小算")
hashmap.put(13276, "小法")
hashmap.put(10583, "小鸭")
puts "\n添加完成后，哈希表为\n[Key1 -> Value1, Key2 -> Value2, ...]"
hashmap.print
# 查询操作
# 向哈希表中输入键 key ，得到值 value
name = hashmap.get(13276)
puts "\n输入学号 13276 ，查询到姓名 #{name}"
# 删除操作
# 在哈希表中删除键值对 (key, value)
hashmap.remove(12836)
puts "\n删除 12836 后，哈希表为\n[Key1 -> Value1, Key2 -> Value2, ...]"
hashmap.print
end

147
codes/ruby/chapter_hashing/hash_map_open_addressing.rb
Unescape View File

@ -0,0 +1,147 @@
=begin
File: hash_map_open_addressing.rb
Created Time: 2024-04-13
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
require_relative './array_hash_map'
### 开放寻址哈希表 ###
class HashMapOpenAddressing
TOMBSTONE = Pair.new(-1, '-1') # 删除标记
### 构造方法 ###
def initialize
@size = 0 # 键值对数量
@capacity = 4 # 哈希表容量
@load_thres = 2.0 / 3.0 # 触发扩容的负载因子阈值
@extend_ratio = 2 # 扩容倍数
@buckets = Array.new(@capacity) # 桶数组
end
### 哈希函数 ###
def hash_func(key)
key % @capacity
end
### 负载因子 ###
def load_factor
@size / @capacity
end
### 搜索 key 对应的桶索引 ###
def find_bucket(key)
index = hash_func(key)
first_tombstone = -1
# 线性探测，当遇到空桶时跳出
while !@buckets[index].nil?
# 若遇到 key ，返回对应的桶索引
if @buckets[index].key == key
# 若之前遇到了删除标记，则将键值对移动至该索引处
if first_tombstone != -1
@buckets[first_tombstone] = @buckets[index]
@buckets[index] = TOMBSTONE
return first_tombstone # 返回移动后的桶索引
end
return index # 返回桶索引
end
# 记录遇到的首个删除标记
first_tombstone = index if first_tombstone == -1 && @buckets[index] == TOMBSTONE
# 计算桶索引，越过尾部则返回头部
index = (index + 1) % @capacity
end
# 若 key 不存在，则返回添加点的索引
first_tombstone == -1 ? index : first_tombstone
end
### 查询操作 ###
def get(key)
# 搜索 key 对应的桶索引
index = find_bucket(key)
# 若找到键值对，则返回对应 val
return @buckets[index].val unless [nil, TOMBSTONE].include?(@buckets[index])
# 若键值对不存在，则返回 nil
nil
end
### 添加操作 ###
def put(key, val)
# 当负载因子超过阈值时，执行扩容
extend if load_factor > @load_thres
# 搜索 key 对应的桶索引
index = find_bucket(key)
# 若找到键值对，则覆盖 val 开返回
unless [nil, TOMBSTONE].include?(@buckets[index])
@buckets[index].val = val
return
end
# 若键值对不存在，则添加该键值对
@buckets[index] = Pair.new(key, val)
@size += 1
end
### 删除操作 ###
def remove(key)
# 搜索 key 对应的桶索引
index = find_bucket(key)
# 若找到键值对，则用删除标记覆盖它
unless [nil, TOMBSTONE].include?(@buckets[index])
@buckets[index] = TOMBSTONE
@size -= 1
end
end
### 扩容哈希表 ###
def extend
# 暂存原哈希表
buckets_tmp = @buckets
# 初始化扩容后的新哈希表
@capacity *= @extend_ratio
@buckets = Array.new(@capacity)
@size = 0
# 将键值对从原哈希表搬运至新哈希表
for pair in buckets_tmp
put(pair.key, pair.val) unless [nil, TOMBSTONE].include?(pair)
end
end
### 打印哈希表 ###
def print
for pair in @buckets
if pair.nil?
puts "Nil"
elsif pair == TOMBSTONE
puts "TOMBSTONE"
else
puts "#{pair.key} -> #{pair.val}"
end
end
end
end
### Driver Code ###
if __FILE__ == $0
# 初始化哈希表
hashmap = HashMapOpenAddressing.new
# 添加操作
# 在哈希表中添加键值对 (key, val)
hashmap.put(12836, "小哈")
hashmap.put(15937, "小啰")
hashmap.put(16750, "小算")
hashmap.put(13276, "小法")
hashmap.put(10583, "小鸭")
puts "\n添加完成后，哈希表为\nKey -> Value"
hashmap.print
# 查询操作
# 向哈希表中输入键 key ，得到值 val
name = hashmap.get(13276)
puts "\n输入学号 13276 ，查询到姓名 #{name}"
# 删除操作
# 在哈希表中删除键值对 (key, val)
hashmap.remove(16750)
puts "\n删除 16750 后，哈希表为\nKey -> Value"
hashmap.print
end

62
codes/ruby/chapter_hashing/simple_hash.rb
Unescape View File

@ -0,0 +1,62 @@
=begin
File: simple_hash.rb
Created Time: 2024-04-14
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
### 加法哈希 ###
def add_hash(key)
hash = 0
modulus = 1_000_000_007
key.each_char { |c| hash += c.ord }
hash % modulus
end
### 乘法哈希 ###
def mul_hash(key)
hash = 0
modulus = 1_000_000_007
key.each_char { |c| hash = 31 * hash + c.ord }
hash % modulus
end
### 异或哈希 ###
def xor_hash(key)
hash = 0
modulus = 1_000_000_007
key.each_char { |c| hash ^= c.ord }
hash % modulus
end
### 旋转哈希 ###
def rot_hash(key)
hash = 0
modulus = 1_000_000_007
key.each_char { |c| hash = (hash << 4) ^ (hash >> 28) ^ c.ord }
hash % modulus
end
### Driver Code ###
if __FILE__ == $0
key = "Hello 算法"
hash = add_hash(key)
puts "加法哈希值为 #{hash}"
hash = mul_hash(key)
puts "乘法哈希值为 #{hash}"
hash = xor_hash(key)
puts "异或哈希值为 #{hash}"
hash = rot_hash(key)
puts "旋转哈希值为 #{hash}"
end

5
codes/ruby/utils/print_util.rb
Unescape View File

@ -56,3 +56,8 @@ def print_tree(root, prev=nil, is_right=false)
trunk.str = " |"
print_tree(root.left, trunk, false)
end
### 打印哈希表 ###
def print_hash_map(hmap)
hmap.entries.each { |key, value| puts "#{key} -> #{value}" }
end

22
docs/chapter_hashing/hash_algorithm.md
Unescape View File

@ -374,7 +374,29 @@ $$
=== "Ruby"
```ruby title="built_in_hash.rb"
num = 3
hash_num = num.hash
# 整数 3 的哈希值为 -4385856518450339636
bol = true
hash_bol = bol.hash
# 布尔量 true 的哈希值为 -1617938112149317027
dec = 3.14159
hash_dec = dec.hash
# 小数 3.14159 的哈希值为 -1479186995943067893
str = "Hello 算法"
hash_str = str.hash
# 字符串“Hello 算法”的哈希值为 -4075943250025831763
tup = [12836, '小哈']
hash_tup = tup.hash
# 元组 (12836, '小哈') 的哈希值为 1999544809202288822
obj = ListNode.new(0)
hash_obj = obj.hash
# 节点对象 #<ListNode:0x000078133140ab70> 的哈希值为 4302940560806366381
```
=== "Zig"

25
docs/chapter_hashing/hash_map.md
Unescape View File

@ -293,7 +293,24 @@
=== "Ruby"
```ruby title="hash_map.rb"
# 初始化哈希表
hmap = {}
# 添加操作
# 在哈希表中添加键值对 (key, value)
hmap[12836] = "小哈"
hmap[15937] = "小啰"
hmap[16750] = "小算"
hmap[13276] = "小法"
hmap[10583] = "小鸭"
# 查询操作
# 向哈希表中输入键 key ，得到值 value
name = hmap[15937]
# 删除操作
# 在哈希表中删除键值对 (key, value)
hmap.delete(10583)
```
=== "Zig"
@ -512,7 +529,15 @@
=== "Ruby"
```ruby title="hash_map.rb"
# 遍历哈希表
# 遍历键值对 key->value
hmap.entries.each { |key, value| puts "#{key} -> #{value}" }
# 单独遍历键 key
hmap.keys.each { |key| puts key }
# 单独遍历值 value
hmap.values.each { |val| puts val }
```
=== "Zig"

Write Preview
Loading…
Cancel
Save