Bug fixes and improvements (#1298)

* Fix is_empty() implementation in the stack and queue chapter

* Update en/CONTRIBUTING.md

* Remove "剩余" from the state definition of knapsack problem

* Sync zh and zh-hant versions

* Update the stylesheets of code tabs

* Fix quick_sort.rb

* Fix TS code

* Update chapter_paperbook

* Upload the manuscript of 0.1 section

* Fix binary_tree_dfs.rb

* Bug fixes

* Update README

* Update README

* Update README

* Update README.md

* Update README

* Sync zh and zh-hant versions

* Bug fixes

zh-hant/codes/c/utils/common.h

@@ -4,8 +4,8 @@
  * Author: MolDuM (moldum@163.com)、Reanon (793584285@qq.com)
  */
 
-#ifndef C_INCLUDE_H
-#define C_INCLUDE_H
+#ifndef COMMON_H
+#define COMMON_H
 
 #include <assert.h>
 #include <stdbool.h>
@@ -33,4 +33,4 @@ extern "C" {
 }
 #endif
 
-#endif // C_INCLUDE_H
+#endif // COMMON_H

zh-hant/codes/python/chapter_stack_and_queue/array_stack.py

@@ -18,7 +18,7 @@ class ArrayStack:
 
     def is_empty(self) -> bool:
         """判斷堆疊是否為空"""
-        return self._stack == []
+        return self._size == 0
 
     def push(self, item: int):
         """入堆疊"""

zh-hant/codes/python/chapter_stack_and_queue/linkedlist_deque.py

@@ -30,7 +30,7 @@ class LinkedListDeque:
 
     def is_empty(self) -> bool:
         """判斷雙向佇列是否為空"""
-        return self.size() == 0
+        return self._size == 0
 
     def push(self, num: int, is_front: bool):
         """入列操作"""

zh-hant/codes/python/chapter_stack_and_queue/linkedlist_queue.py

@@ -26,7 +26,7 @@ class LinkedListQueue:
 
     def is_empty(self) -> bool:
         """判斷佇列是否為空"""
-        return not self._front
+        return self._size == 0
 
     def push(self, num: int):
         """入列"""

zh-hant/codes/python/chapter_stack_and_queue/linkedlist_stack.py

@@ -25,7 +25,7 @@ class LinkedListStack:
 
     def is_empty(self) -> bool:
         """判斷堆疊是否為空"""
-        return not self._peek
+        return self._size == 0
 
     def push(self, val: int):
         """入堆疊"""

zh-hant/codes/ruby/chapter_hashing/array_hash_map.rb

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

zh-hant/codes/ruby/chapter_hashing/built_in_hash.rb

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

zh-hant/codes/ruby/chapter_hashing/hash_map.rb

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

zh-hant/codes/ruby/chapter_hashing/hash_map_chaining.rb

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

zh-hant/codes/ruby/chapter_hashing/hash_map_open_addressing.rb

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

zh-hant/codes/ruby/chapter_hashing/simple_hash.rb

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

zh-hant/codes/ruby/chapter_sorting/quick_sort.rb

@@ -0,0 +1,154 @@
+=begin
+File: quick_sort.rb
+Created Time: 2024-04-01
+Author: Cy (3739004@gmail.com), Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### 快速排序類別 ###
+class QuickSort
+  class << self
+    ### 哨兵劃分 ###
+    def partition(nums, left, right)
+
+      # 以 nums[left] 為基準數
+      i, j = left, right
+      while i < j
+        while i < j && nums[j] >= nums[left]
+          j -= 1 # 從右向左找首個小於基準數的元素
+        end
+        while i < j && nums[i] <= nums[left]
+          i += 1 # 從左向右找首個大於基準數的元素
+        end
+        # 元素交換
+        nums[i], nums[j] = nums[j], nums[i]
+      end
+      # 將基準數交換至兩子陣列的分界線
+      nums[i], nums[left] = nums[left], nums[i]
+      i # 返回基準數的索引
+    end
+
+    ### 快速排序類別 ###
+    def quick_sort(nums, left, right)
+      # 子陣列長度不為 1 時遞迴
+      if left < right
+        # 哨兵劃分
+        pivot = partition(nums, left, right)
+        # 遞迴左子陣列、右子陣列
+        quick_sort(nums, left, pivot - 1)
+        quick_sort(nums, pivot + 1, right)
+      end
+      nums
+    end
+  end
+end
+
+### 快速排序類別（中位數最佳化）###
+class QuickSortMedian
+  class << self
+    ### 選取三個候選元素的中位數 ###
+    def median_three(nums, left, mid, right)
+      # 選取三個候選元素的中位數
+      _l, _m, _r = nums[left], nums[mid], nums[right]
+      # m 在 l 和 r 之間
+      return mid if (_l <= _m && _m <= _r) || (_r <= _m && _m <= _l)
+      # l 在 m 和 r 之間
+      return left if (_m <= _l && _l <= _r) || (_r <= _l && _l <= _m)
+      return right
+    end
+
+    ### 哨兵劃分（三數取中值）###
+    def partition(nums, left, right)
+      ### 以 nums[left] 為基準數
+      med = median_three(nums, left, (left + right) / 2, right)
+      # 將中位數交換至陣列最左斷
+      nums[left], nums[med] = nums[med], nums[left]
+      i, j = left, right
+      while i < j
+        while i < j && nums[j] >= nums[left]
+          j -= 1 # 從右向左找首個小於基準數的元素
+        end
+        while i < j && nums[i] <= nums[left]
+          i += 1 # 從左向右找首個大於基準數的元素
+        end
+        # 元素交換
+        nums[i], nums[j] = nums[j], nums[i]
+      end
+      # 將基準數交換至兩子陣列的分界線
+      nums[i], nums[left] = nums[left], nums[i]
+      i # 返回基準數的索引
+    end
+
+    ### 快速排序 ###
+    def quick_sort(nums, left, right)
+      # 子陣列長度不為 1 時遞迴
+      if left < right
+        # 哨兵劃分
+        pivot = partition(nums, left, right)
+        # 遞迴左子陣列、右子陣列
+        quick_sort(nums, left, pivot - 1)
+        quick_sort(nums, pivot + 1, right)
+      end
+      nums
+    end
+  end
+end
+
+### 快速排序類別（尾遞迴最佳化）###
+class QuickSortTailCall
+  class << self
+    ### 哨兵劃分 ###
+    def partition(nums, left, right)
+      # 以 nums[left]為基準數
+      i = left
+      j = right
+      while i < j
+        while i < j && nums[j] >= nums[left]
+          j -= 1 # 從右向左找首個小於基準數的元素
+        end
+        while i < j && nums[i] <= nums[left]
+          i += 1 # 從左向右找首個大於基準數的元素
+        end
+        # 元素交換
+        nums[i], nums[j] = nums[j], nums[i]
+      end
+      # 將基準數交換至兩子陣列的分界線
+      nums[i], nums[left] = nums[left], nums[i]
+      i # 返回基準數的索引
+    end
+
+    ### 快速排序（尾遞迴最佳化）
+    def quick_sort(nums, left, right)
+      # 子陣列長度不為 1 時遞迴
+      while left < right
+        # 哨兵劃分
+        pivot = partition(nums, left, right)
+        # 對兩個子陣列中較短的那個執行快速排序
+        if pivot - left < right - pivot
+          quick_sort(nums, left, pivot - 1)
+          left = pivot + 1 # 剩餘未排序區間為 [pivot + 1, right]
+        else
+          quick_sort(nums, pivot + 1, right)
+          right = pivot - 1 # 剩餘未排序區間為 [left, pivot - 1]
+        end
+      end
+    end
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 快速排序
+  nums = [2, 4, 1, 0, 3, 5]
+  QuickSort.quick_sort(nums, 0, nums.length - 1)
+  puts "快速排序完成後 nums = #{nums}"
+
+  # 快速排序（中位基準數最佳化）
+  nums1 = [2, 4, 1, 0, 3, 5]
+  QuickSortMedian.quick_sort(nums1, 0, nums1.length - 1)
+  puts "快速排序（中位基準數最佳化）完成後 nums1 = #{nums1}"
+
+  # 快速排序（尾遞迴最佳化）
+  nums2 = [2, 4, 1, 0, 3, 5]
+  QuickSortTailCall.quick_sort(nums2, 0, nums2.length - 1)
+  puts "快速排序（尾遞迴最佳化）完成後 nums2 = #{nums2}"
+end

zh-hant/codes/ruby/chapter_tree/array_binary_tree.rb

@@ -0,0 +1,124 @@
+=begin
+File: array_binary_tree.rb
+Created Time: 2024-04-17
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+require_relative '../utils/tree_node'
+require_relative '../utils/print_util'
+
+### 陣列表示下的二元樹類別 ###
+class ArrayBinaryTree
+  ### 建構子 ###
+  def initialize(arr)
+    @tree = arr.to_a
+  end
+
+  ### 串列容量 ###
+  def size
+    @tree.length
+  end
+
+  ### 獲取索引為 i 節點的值 ###
+  def val(i)
+    # 若索引越界，則返回 nil ，代表空位
+    return if i < 0 || i >= size
+
+    @tree[i]
+  end
+
+  ### 獲取索引為 i 節點的左子節點的索引 ###
+  def left(i)
+    2 * i + 1
+  end
+
+  ### 獲取索引為 i 節點的右子節點的索引 ###
+  def right(i)
+    2 * i + 2
+  end
+
+  ### 獲取索引為 i 節點的父節點的索引 ###
+  def parent(i)
+    (i - 1) / 2
+  end
+
+  ### 層序走訪 ###
+  def level_order
+    @res = []
+
+    # 直接走訪陣列
+    for i in 0...size
+      @res << val(i) unless val(i).nil?
+    end
+
+    @res
+  end
+
+  ### 深度優先走訪 ###
+  def dfs(i, order)
+    return if val(i).nil?
+    # 前序走訪
+    @res << val(i) if order == :pre
+    dfs(left(i), order)
+    # 中序走訪
+    @res << val(i) if order == :in
+    dfs(right(i), order)
+    # 後序走訪
+    @res << val(i) if order == :post
+  end
+
+  ### 前序走訪 ###
+  def pre_order
+    @res = []
+    dfs(0, :pre)
+    @res
+  end
+
+  ### 中序走訪 ###
+  def in_order
+    @res = []
+    dfs(0, :in)
+    @res
+  end
+
+  ### 後序走訪 ###
+  def post_order
+    @res = []
+    dfs(0, :post)
+    @res
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 初始化二元樹
+  # 這裡藉助了一個從陣列直接生成二元樹的函式
+  arr = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]
+  root = arr_to_tree(arr)
+  puts "\n初始化二元樹\n\n"
+  puts '二元樹的陣列表示：'
+  pp arr
+  puts '二元樹的鏈結串列表示：'
+  print_tree(root)
+
+  # 陣列表示下的二元樹類別
+  abt = ArrayBinaryTree.new(arr)
+
+  # 訪問節點
+  i = 1
+  l, r, _p = abt.left(i), abt.right(i), abt.parent(i)
+  puts "\n當前節點的索引為 #{i} ，值為 #{abt.val(i).inspect}"
+  puts "其左子節點的索引為 #{l} ，值為 #{abt.val(l).inspect}"
+  puts "其右子節點的索引為 #{r} ，值為 #{abt.val(r).inspect}"
+  puts "其父節點的索引為 #{_p} ，值為 #{abt.val(_p).inspect}"
+
+  # 走訪樹
+  res = abt.level_order
+  puts "\n層序走訪為： #{res}"
+  res = abt.pre_order
+  puts "前序走訪為： #{res}"
+  res = abt.in_order
+  puts "中序走訪為： #{res}"
+  res = abt.post_order
+  puts "後序走訪為： #{res}"
+end

zh-hant/codes/ruby/chapter_tree/avl_tree.rb

@@ -0,0 +1,216 @@
+=begin
+File: avl_tree.rb
+Created Time: 2024-04-17
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+require_relative '../utils/tree_node'
+require_relative '../utils/print_util'
+
+### AVL 樹 ###
+class AVLTree
+  ### 建構子 ###
+  def initialize
+    @root = nil
+  end
+
+  ### 獲取二元樹根節點 ###
+  def get_root
+    @root
+  end
+
+  ### 獲取節點高度 ###
+  def height(node)
+    # 空節點高度為 -1 ，葉節點高度為 0
+    return node.height unless node.nil?
+
+    -1
+  end
+
+  ### 更新節點高度 ###
+  def update_height(node)
+    # 節點高度等於最高子樹高度 + 1
+    node.height = [height(node.left), height(node.right)].max + 1
+  end
+
+  ### 獲取平衡因子 ###
+  def balance_factor(node)
+    # 空節點平衡因子為 0
+    return 0 if node.nil?
+
+    # 節點平衡因子 = 左子樹高度 - 右子樹高度
+    height(node.left) - height(node.right)
+  end
+
+  ### 右旋操作 ###
+  def right_rotate(node)
+    child = node.left
+    grand_child = child.right
+    # 以 child 為原點，將 node 向右旋轉
+    child.right = node
+    node.left = grand_child
+    # 更新節點高度
+    update_height(node)
+    update_height(child)
+    # 返回旋轉後子樹的根節點
+    child
+  end
+
+  ### 左旋操作 ###
+  def left_rotate(node)
+    child = node.right
+    grand_child = child.left
+    # 以 child 為原點，將 node 向左旋轉
+    child.left = node
+    node.right = grand_child
+    # 更新節點高度
+    update_height(node)
+    update_height(child)
+    # 返回旋轉後子樹的根節點
+    child
+  end
+
+  ### 執行旋轉操作，使該子樹重新恢復平衡 ###
+  def rotate(node)
+    # 獲取節點 node 的平衡因子
+    balance_factor = balance_factor(node)
+    # 左遍樹
+    if balance_factor > 1
+      if balance_factor(node.left) >= 0
+        # 右旋
+        return right_rotate(node)
+      else
+        # 先左旋後右旋
+        node.left = left_rotate(node.left)
+        return right_rotate(node)
+      end
+    # 右遍樹
+    elsif balance_factor < -1
+      if balance_factor(node.right) <= 0
+        # 左旋
+        return left_rotate(node)
+      else
+        # 先右旋後左旋
+        node.right = right_rotate(node.right)
+        return left_rotate(node)
+      end
+    end
+    # 平衡樹，無須旋轉，直接返回
+    node
+  end
+
+  ### 插入節點 ###
+  def insert(val)
+    @root = insert_helper(@root, val)
+  end
+
+  ### 遞迴插入節點（輔助方法）###
+  def insert_helper(node, val)
+    return TreeNode.new(val) if node.nil?
+    # 1. 查詢插入位置並插入節點
+    if val < node.val
+      node.left = insert_helper(node.left, val)
+    elsif val > node.val
+      node.right = insert_helper(node.right, val)
+    else
+      # 重複節點不插入，直接返回
+      return node
+    end
+    # 更新節點高度
+    update_height(node)
+    # 2. 執行旋轉操作，使該子樹重新恢復平衡
+    rotate(node)
+  end
+
+  ### 刪除節點 ###
+  def remove(val)
+    @root = remove_helper(@root, val)
+  end
+
+  ### 遞迴刪除節點（輔助方法）###
+  def remove_helper(node, val)
+    return if node.nil?
+    # 1. 查詢節點並刪除
+    if val < node.val
+      node.left = remove_helper(node.left, val)
+    elsif val > node.val
+      node.right = remove_helper(node.right, val)
+    else
+      if node.left.nil? || node.right.nil?
+        child = node.left || node.right
+        # 子節點數量 = 0 ，直接刪除 node 並返回
+        return if child.nil?
+        # 子節點數量 = 1 ，直接刪除 node
+        node = child
+      else
+        # 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點
+        temp = node.right
+        while !temp.left.nil?
+          temp = temp.left
+        end
+        node.right = remove_helper(node.right, temp.val)
+        node.val = temp.val
+      end
+    end
+    # 更新節點高度
+    update_height(node)
+    # 2. 執行旋轉操作，使該子樹重新恢復平衡
+    rotate(node)
+  end
+
+  ### 查詢節點 ###
+  def search(val)
+    cur = @root
+    # 迴圈查詢，越過葉節點後跳出
+    while !cur.nil?
+      # 目標節點在 cur 的右子樹中
+      if cur.val < val
+        cur = cur.right
+      # 目標節點在 cur 的左子樹中
+      elsif cur.val > val
+        cur = cur.left
+      # 找到目標節點，跳出迴圈
+      else
+        break
+      end
+    end
+    # 返回目標節點
+    cur
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  def test_insert(tree, val)
+    tree.insert(val)
+    puts "\n插入節點 #{val} 後，AVL 樹為"
+    print_tree(tree.get_root)
+  end
+
+  def test_remove(tree, val)
+    tree.remove(val)
+    puts "\n刪除節點 #{val} 後，AVL 樹為"
+    print_tree(tree.get_root)
+  end
+
+  # 初始化空 AVL 樹
+  avl_tree = AVLTree.new
+
+  # 插入節點
+  # 請關注插入節點後，AVL 樹是如何保持平衡的
+  for val in [1, 2, 3, 4, 5, 8, 7, 9, 10, 6]
+    test_insert(avl_tree, val)
+  end
+
+  # 插入重複節點
+  test_insert(avl_tree, 7)
+
+  # 刪除節點
+  # 請關注刪除節點後，AVL 樹是如何保持平衡的
+  test_remove(avl_tree, 8) # 刪除度為 0 的節點
+  test_remove(avl_tree, 5) # 刪除度為 1 的節點
+  test_remove(avl_tree, 4) # 刪除度為 2 的節點
+
+  result_node = avl_tree.search(7)
+  puts "\n查詢到的節點物件為 #{result_node}，節點值 = #{result_node.val}"
+end

zh-hant/codes/ruby/chapter_tree/binary_search_tree.rb

@@ -0,0 +1,161 @@
+=begin
+File: binary_search_tree.rb
+Created Time: 2024-04-18
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+require_relative '../utils/tree_node'
+require_relative '../utils/print_util'
+
+### 二元搜尋樹 ###
+class BinarySearchTree
+  ### 建構子 ###
+  def initialize
+    # 初始化空樹
+    @root = nil
+  end
+
+  ### 獲取二元樹根節點 ###
+  def get_root
+    @root
+  end
+
+  ### 查詢節點 ###
+  def search(num)
+    cur = @root
+
+    # 迴圈查詢，越過葉節點後跳出
+    while !cur.nil?
+      # 目標節點在 cur 的右子樹中
+      if cur.val < num
+        cur = cur.right
+      # 目標節點在 cur 的左子樹中
+      elsif cur.val > num
+        cur = cur.left
+      # 找到目標節點，跳出迴圈
+      else
+        break
+      end
+    end
+
+    cur
+  end
+
+  ### 插入節點 ###
+  def insert(num)
+    # 若樹為空，則初始化根節點
+    if @root.nil?
+      @root = TreeNode.new(num)
+      return
+    end
+
+    # 迴圈查詢，越過葉節點後跳出
+    cur, pre = @root, nil
+    while !cur.nil?
+      # 找到重複節點，直接返回
+      return if cur.val == num
+
+      pre = cur
+      # 插入位置在 cur 的右子樹中
+      if cur.val < num
+        cur = cur.right
+      # 插入位置在 cur 的左子樹中
+      else
+        cur = cur.left
+      end
+    end
+
+    # 插入節點
+    node = TreeNode.new(num)
+    if pre.val < num
+      pre.right = node
+    else
+      pre.left = node
+    end
+  end
+
+  ### 刪除節點 ###
+  def remove(num)
+    # 若樹為空，直接提前返回
+    return if @root.nil?
+
+    # 迴圈查詢，越過葉節點後跳出
+    cur, pre = @root, nil
+    while !cur.nil?
+      # 找到待刪除節點，跳出迴圈
+      break if cur.val == num
+
+      pre = cur
+      # 待刪除節點在 cur 的右子樹中
+      if cur.val < num
+        cur = cur.right
+      # 待刪除節點在 cur 的左子樹中
+      else
+        cur = cur.left
+      end
+    end
+    # 若無待刪除節點，則直接返回
+    return if cur.nil?
+
+    # 子節點數量 = 0 or 1
+    if cur.left.nil? || cur.right.nil?
+      # 當子節點數量 = 0 / 1 時， child = null / 該子節點
+      child = cur.left || cur.right
+      # 刪除節點 cur
+      if cur != @root
+        if pre.left == cur
+          pre.left = child
+        else
+          pre.right = child
+        end
+      else
+        # 若刪除節點為根節點，則重新指定根節點
+        @root = child
+      end
+    # 子節點數量 = 2
+    else
+      # 獲取中序走訪中 cur 的下一個節點
+      tmp = cur.right
+      while !tmp.left.nil?
+        tmp = tmp.left
+      end
+      # 遞迴刪除節點 tmp
+      remove(tmp.val)
+      # 用 tmp 覆蓋 cur
+      cur.val = tmp.val
+    end
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 初始化二元搜尋樹
+  bst = BinarySearchTree.new
+  nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15]
+  # 請注意，不同的插入順序會生成不同的二元樹，該序列可以生成一個完美二元樹
+  nums.each { |num| bst.insert(num) }
+  puts "\n初始化的二元樹為\n"
+  print_tree(bst.get_root)
+
+  # 查詢節點
+  node = bst.search(7)
+  puts "\n查詢到的節點物件為: #{node}，節點值 = #{node.val}"
+
+  # 插入節點
+  bst.insert(16)
+  puts "\n插入節點 16 後，二元樹為\n"
+  print_tree(bst.get_root)
+
+  # 刪除節點
+  bst.remove(1)
+  puts "\n刪除節點 1 後，二元樹為\n"
+  print_tree(bst.get_root)
+
+  bst.remove(2)
+  puts "\n刪除節點 2 後，二元樹為\n"
+  print_tree(bst.get_root)
+
+  bst.remove(4)
+  puts "\n刪除節點 4 後，二元樹為\n"
+  print_tree(bst.get_root)
+end

zh-hant/codes/ruby/chapter_tree/binary_tree.rb

@@ -0,0 +1,38 @@
+=begin
+File: binary_tree.rb
+Created Time: 2024-04-18
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+require_relative '../utils/tree_node'
+require_relative '../utils/print_util'
+
+### Driver Code ###
+if __FILE__ == $0
+  # 初始化二元樹
+  # 初始化節點
+  n1 = TreeNode.new(1)
+  n2 = TreeNode.new(2)
+  n3 = TreeNode.new(3)
+  n4 = TreeNode.new(4)
+  n5 = TreeNode.new(5)
+  # 構建節點之間的引用（指標）
+  n1.left = n2
+  n1.right = n3
+  n2.left = n4
+  n2.right = n5
+  puts "\n初始化二元樹\n\n"
+  print_tree(n1)
+
+  # 插入與刪除節點
+  _p = TreeNode.new(0)
+  # 在 n1 -> n2 中間插入節點 _p
+  n1.left = _p
+  _p.left = n2
+  puts "\n插入節點 _p 後\n\n"
+  print_tree(n1)
+  # 刪除節點
+  n1.left = n2
+  puts "\n刪除節點 _p 後\n\n"
+  print_tree(n1)
+end

zh-hant/codes/ruby/chapter_tree/binary_tree_bfs.rb

@@ -0,0 +1,36 @@
+=begin
+File: binary_tree_bfs.rb
+Created Time: 2024-04-18
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+require_relative '../utils/tree_node'
+require_relative '../utils/print_util'
+
+### 層序走訪 ###
+def level_order(root)
+  # 初始化佇列，加入根節點
+  queue = [root]
+  # 初始化一個串列，用於儲存走訪序列
+  res = []
+  while !queue.empty?
+    node = queue.shift # 隊列出隊
+    res << node.val # 儲存節點值
+    queue << node.left unless node.left.nil? # 左子節點入列
+    queue << node.right unless node.right.nil? # 右子節點入列
+  end
+  res
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 初始化二元樹
+  # 這裡藉助了一個從陣列直接生成二元樹的函式
+  root = arr_to_tree([1, 2, 3, 4, 5, 6, 7])
+  puts "\n初始化二元樹\n\n"
+  print_tree(root)
+
+  # 層序走訪
+  res = level_order(root)
+  puts "\n層序走訪的節點列印序列 = #{res}"
+end

zh-hant/codes/ruby/chapter_tree/binary_tree_dfs.rb

@@ -0,0 +1,62 @@
+=begin
+File: binary_tree_dfs.rb
+Created Time: 2024-04-18
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+require_relative '../utils/tree_node'
+require_relative '../utils/print_util'
+
+### 前序走訪 ###
+def pre_order(root)
+  return if root.nil?
+
+  # 訪問優先順序：根節點 -> 左子樹 -> 右子樹
+  $res << root.val
+  pre_order(root.left)
+  pre_order(root.right)
+end
+
+### 中序走訪 ###
+def in_order(root)
+  return if root.nil?
+
+  # 訪問優先順序：左子樹 -> 根節點 -> 右子樹
+  in_order(root.left)
+  $res << root.val
+  in_order(root.right)
+end
+
+### 後序走訪 ###
+def post_order(root)
+  return if root.nil?
+
+  # 訪問優先順序：左子樹 -> 右子樹 -> 根節點
+  post_order(root.left)
+  post_order(root.right)
+  $res << root.val
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 初始化二元樹
+  # 這裡藉助了一個從陣列直接生成二元樹的函式
+  root = arr_to_tree([1, 2, 3, 4, 5, 6, 7])
+  puts "\n初始化二元樹\n\n"
+  print_tree(root)
+
+  # 前序走訪
+  $res = []
+  pre_order(root)
+  puts "\n前序走訪的節點列印序列 = #{$res}"
+
+  # 中序走訪
+  $res.clear
+  in_order(root)
+  puts "\nn中序走訪的節點列印序列 = #{$res}"
+
+  # 後序走訪
+  $res.clear
+  post_order(root)
+  puts "\nn後序走訪的節點列印序列 = #{$res}"
+end

zh-hant/codes/ruby/utils/print_util.rb

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

zh-hant/codes/ruby/utils/tree_node.rb

@@ -16,3 +16,38 @@ class TreeNode
     @height = 0
   end
 end
+
+### 將串列反序列化為二元數樹：遞迴 ###
+def arr_to_tree_dfs(arr, i)
+  # 如果索引超出陣列長度，或者對應的元素為 nil ，則返回 nil
+  return if i < 0 || i >= arr.length || arr[i].nil?
+  # 構建當前節點
+  root = TreeNode.new(arr[i])
+  # 遞迴構建左右子樹
+  root.left = arr_to_tree_dfs(arr, 2 * i + 1)
+  root.right = arr_to_tree_dfs(arr, 2 * i + 2)
+  root
+end
+
+### 將串列反序列化為二元樹 ###
+def arr_to_tree(arr)
+  arr_to_tree_dfs(arr, 0)
+end
+
+### 將二元樹序列化為串列：遞迴 ###
+def tree_to_arr_dfs(root, i, res)
+  return if root.nil?
+
+  res += Array.new(i - res.length + 1) if i >= res.length
+  res[i] = root.val
+
+  tree_to_arr_dfs(root.left, 2 * i + 1, res)
+  tree_to_arr_dfs(root.right, 2 * i + 2, res)
+end
+
+### 將二元樹序列化為串列 ###
+def tree_to_arr(root)
+  res = []
+  tree_to_arr_dfs(root, 0, res)
+  res
+end

zh-hant/codes/typescript/chapter_backtracking/subset_sum_i.ts

@@ -51,4 +51,4 @@ const res = subsetSumI(nums, target);
 console.log(`輸入陣列 nums = ${JSON.stringify(nums)}, target = ${target}`);
 console.log(`所有和等於 ${target} 的子集 res = ${JSON.stringify(res)}`);
 
-export { };
+export {};

zh-hant/codes/typescript/chapter_backtracking/subset_sum_ii.ts

@@ -56,4 +56,4 @@ const res = subsetSumII(nums, target);
 console.log(`輸入陣列 nums = ${JSON.stringify(nums)}, target = ${target}`);
 console.log(`所有和等於 ${target} 的子集 res = ${JSON.stringify(res)}`);
 
-export { };
+export {};

zh-hant/codes/typescript/chapter_computational_complexity/recursion.ts

@@ -67,4 +67,4 @@ console.log(`尾遞迴函式的求和結果 res = ${res}`);
 res = fib(n);
 console.log(`費波那契數列的第 ${n} 項為 ${res}`);
 
-export { };
+export {};

zh-hant/codes/typescript/chapter_graph/graph_adjacency_list.ts

@@ -91,9 +91,8 @@ class GraphAdjList {
     }
 }
 
-// need to add the package @types/node contains type definitions for Node.js, npm i --save-dev @types/node
-if (require.main === module) {
-    /* Driver Code */
+/* Driver Code */
+if (import.meta.url.endsWith(process.argv[1])) {
     /* 初始化無向圖 */
     const v0 = new Vertex(1),
         v1 = new Vertex(3),

zh-hant/codes/typescript/chapter_heap/my_heap.ts

@@ -122,7 +122,7 @@ class MaxHeap {
 }
 
 /* Driver Code */
-if (require.main === module) {
+if (import.meta.url.endsWith(process.argv[1])) {
     /* 初始化大頂堆積 */
     const maxHeap = new MaxHeap([9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2]);
     console.log('\n輸入串列並建堆積後');

zh-hant/codes/typescript/chapter_tree/array_binary_tree.ts

@@ -4,8 +4,8 @@
  * Author: yuan0221 (yl1452491917@gmail.com)
  */
 
-const { arrToTree } = require('../modules/TreeNode');
-const { printTree } = require('../modules/PrintUtil');
+import { arrToTree } from '../modules/TreeNode';
+import { printTree } from '../modules/PrintUtil';
 
 type Order = 'pre' | 'in' | 'post';
 
@@ -148,4 +148,4 @@ console.log('中序走訪為：' + res);
 res = abt.postOrder();
 console.log('後序走訪為：' + res);
 
-export { };
+export {};

zh-hant/codes/typescript/modules/PrintUtil.ts

@@ -79,9 +79,6 @@ function showTrunks(p: Trunk | null) {
 
     showTrunks(p.prev);
     process.stdout.write(p.str);
-    // ts-node to execute, we need to install type definitions for node
-    // solve: npm i --save-dev @types/node
-    // restart the vscode
 }
 
 /* 列印堆積 */

zh-hant/codes/typescript/tsconfig.json

@@ -1,8 +1,12 @@
 {
     "compilerOptions": {
-        "target": "ES6",
-        "module": "CommonJS",
-        "outDir": "out",
-        "sourceMap": true
-    }
+        "baseUrl": ".",
+        "module": "esnext",
+        "moduleResolution": "node",
+        "types": ["@types/node"],
+        "noEmit": true,
+        "target": "esnext",
+    },
+    "include": ["chapter_*/*.ts"],
+    "exclude": ["node_modules"]
 }