feat: Traditional Chinese version (#1163)

* First commit

* Update mkdocs.yml

* Translate all the docs to traditional Chinese

* Translate the code files.

* Translate the docker file

* Fix mkdocs.yml

* Translate all the figures from SC to TC

* 二叉搜尋樹 -> 二元搜尋樹

* Update terminology.

* Update terminology

* 构造函数/构造方法 -> 建構子
异或 -> 互斥或

* 擴充套件 -> 擴展

* constant - 常量 - 常數

* 類	-> 類別

* AVL -> AVL 樹

* 數組 -> 陣列

* 係統 -> 系統
斐波那契數列 -> 費波那契數列
運算元量 -> 運算量
引數 -> 參數

* 聯絡 -> 關聯

* 麵試 -> 面試

* 面向物件 -> 物件導向
歸併排序 -> 合併排序
范式 -> 範式

* Fix 算法 -> 演算法

* 錶示 -> 表示
反碼 -> 一補數
補碼 -> 二補數
列列尾部 -> 佇列尾部
區域性性 -> 區域性
一摞 -> 一疊

* Synchronize with main branch

* 賬號 -> 帳號
推匯 -> 推導

* Sync with main branch

* First commit

* Update mkdocs.yml

* Translate all the docs to traditional Chinese

* Translate the code files.

* Translate the docker file

* Fix mkdocs.yml

* Translate all the figures from SC to TC

* 二叉搜尋樹 -> 二元搜尋樹

* Update terminology

* 构造函数/构造方法 -> 建構子
异或 -> 互斥或

* 擴充套件 -> 擴展

* constant - 常量 - 常數

* 類	-> 類別

* AVL -> AVL 樹

* 數組 -> 陣列

* 係統 -> 系統
斐波那契數列 -> 費波那契數列
運算元量 -> 運算量
引數 -> 參數

* 聯絡 -> 關聯

* 麵試 -> 面試

* 面向物件 -> 物件導向
歸併排序 -> 合併排序
范式 -> 範式

* Fix 算法 -> 演算法

* 錶示 -> 表示
反碼 -> 一補數
補碼 -> 二補數
列列尾部 -> 佇列尾部
區域性性 -> 區域性
一摞 -> 一疊

* Synchronize with main branch

* 賬號 -> 帳號
推匯 -> 推導

* Sync with main branch

* Update terminology.md

* 操作数量(num. of operations)-> 操作數量

* 字首和->前綴和

* Update figures

* 歸 -> 迴
記憶體洩漏 -> 記憶體流失

* Fix the bug of the file filter

* 支援 -> 支持
Add zh-Hant/README.md

* Add the zh-Hant chapter covers.
Bug fixes.

* 外掛 -> 擴充功能

* Add the landing page for zh-Hant version

* Unify the font of the chapter covers for the zh, en, and zh-Hant version

* Move zh-Hant/ to zh-hant/

* Translate terminology.md to traditional Chinese
This commit is contained in:
Yudong Jin
2024-04-06 02:30:11 +08:00
committed by GitHub
parent 33d7f8a2e5
commit 5f7385c8a3
1875 changed files with 102923 additions and 18 deletions
@@ -0,0 +1,134 @@
/**
* File: array_hash_map.cs
* Created Time: 2022-12-23
* Author: haptear (haptear@hotmail.com)
*/
namespace hello_algo.chapter_hashing;
/* 鍵值對 int->string */
class Pair(int key, string val) {
public int key = key;
public string val = val;
}
/* 基於陣列實現的雜湊表 */
class ArrayHashMap {
List<Pair?> buckets;
public ArrayHashMap() {
// 初始化陣列,包含 100 個桶
buckets = [];
for (int i = 0; i < 100; i++) {
buckets.Add(null);
}
}
/* 雜湊函式 */
int HashFunc(int key) {
int index = key % 100;
return index;
}
/* 查詢操作 */
public string? Get(int key) {
int index = HashFunc(key);
Pair? pair = buckets[index];
if (pair == null) return null;
return pair.val;
}
/* 新增操作 */
public void Put(int key, string val) {
Pair pair = new(key, val);
int index = HashFunc(key);
buckets[index] = pair;
}
/* 刪除操作 */
public void Remove(int key) {
int index = HashFunc(key);
// 置為 null ,代表刪除
buckets[index] = null;
}
/* 獲取所有鍵值對 */
public List<Pair> PairSet() {
List<Pair> pairSet = [];
foreach (Pair? pair in buckets) {
if (pair != null)
pairSet.Add(pair);
}
return pairSet;
}
/* 獲取所有鍵 */
public List<int> KeySet() {
List<int> keySet = [];
foreach (Pair? pair in buckets) {
if (pair != null)
keySet.Add(pair.key);
}
return keySet;
}
/* 獲取所有值 */
public List<string> ValueSet() {
List<string> valueSet = [];
foreach (Pair? pair in buckets) {
if (pair != null)
valueSet.Add(pair.val);
}
return valueSet;
}
/* 列印雜湊表 */
public void Print() {
foreach (Pair kv in PairSet()) {
Console.WriteLine(kv.key + " -> " + kv.val);
}
}
}
public class array_hash_map {
[Test]
public void Test() {
/* 初始化雜湊表 */
ArrayHashMap map = new();
/* 新增操作 */
// 在雜湊表中新增鍵值對 (key, value)
map.Put(12836, "小哈");
map.Put(15937, "小囉");
map.Put(16750, "小算");
map.Put(13276, "小法");
map.Put(10583, "小鴨");
Console.WriteLine("\n新增完成後,雜湊表為\nKey -> Value");
map.Print();
/* 查詢操作 */
// 向雜湊表中輸入鍵 key ,得到值 value
string? name = map.Get(15937);
Console.WriteLine("\n輸入學號 15937 ,查詢到姓名 " + name);
/* 刪除操作 */
// 在雜湊表中刪除鍵值對 (key, value)
map.Remove(10583);
Console.WriteLine("\n刪除 10583 後,雜湊表為\nKey -> Value");
map.Print();
/* 走訪雜湊表 */
Console.WriteLine("\n走訪鍵值對 Key->Value");
foreach (Pair kv in map.PairSet()) {
Console.WriteLine(kv.key + " -> " + kv.val);
}
Console.WriteLine("\n單獨走訪鍵 Key");
foreach (int key in map.KeySet()) {
Console.WriteLine(key);
}
Console.WriteLine("\n單獨走訪值 Value");
foreach (string val in map.ValueSet()) {
Console.WriteLine(val);
}
}
}
@@ -0,0 +1,36 @@
/**
* File: built_in_hash.cs
* Created Time: 2023-06-26
* Author: hpstory (hpstory1024@163.com)
*/
namespace hello_algo.chapter_hashing;
public class built_in_hash {
[Test]
public void Test() {
int num = 3;
int hashNum = num.GetHashCode();
Console.WriteLine("整數 " + num + " 的雜湊值為 " + hashNum);
bool bol = true;
int hashBol = bol.GetHashCode();
Console.WriteLine("布林量 " + bol + " 的雜湊值為 " + hashBol);
double dec = 3.14159;
int hashDec = dec.GetHashCode();
Console.WriteLine("小數 " + dec + " 的雜湊值為 " + hashDec);
string str = "Hello 演算法";
int hashStr = str.GetHashCode();
Console.WriteLine("字串 " + str + " 的雜湊值為 " + hashStr);
object[] arr = [12836, "小哈"];
int hashTup = arr.GetHashCode();
Console.WriteLine("陣列 [" + string.Join(", ", arr) + "] 的雜湊值為 " + hashTup);
ListNode obj = new(0);
int hashObj = obj.GetHashCode();
Console.WriteLine("節點物件 " + obj + " 的雜湊值為 " + hashObj);
}
}
@@ -0,0 +1,51 @@
/**
* File: hash_map.cs
* Created Time: 2022-12-23
* Author: haptear (haptear@hotmail.com)
*/
namespace hello_algo.chapter_hashing;
public class hash_map {
[Test]
public void Test() {
/* 初始化雜湊表 */
Dictionary<int, string> map = new() {
/* 新增操作 */
// 在雜湊表中新增鍵值對 (key, value)
{ 12836, "小哈" },
{ 15937, "小囉" },
{ 16750, "小算" },
{ 13276, "小法" },
{ 10583, "小鴨" }
};
Console.WriteLine("\n新增完成後,雜湊表為\nKey -> Value");
PrintUtil.PrintHashMap(map);
/* 查詢操作 */
// 向雜湊表中輸入鍵 key ,得到值 value
string name = map[15937];
Console.WriteLine("\n輸入學號 15937 ,查詢到姓名 " + name);
/* 刪除操作 */
// 在雜湊表中刪除鍵值對 (key, value)
map.Remove(10583);
Console.WriteLine("\n刪除 10583 後,雜湊表為\nKey -> Value");
PrintUtil.PrintHashMap(map);
/* 走訪雜湊表 */
Console.WriteLine("\n走訪鍵值對 Key->Value");
foreach (var kv in map) {
Console.WriteLine(kv.Key + " -> " + kv.Value);
}
Console.WriteLine("\n單獨走訪鍵 Key");
foreach (int key in map.Keys) {
Console.WriteLine(key);
}
Console.WriteLine("\n單獨走訪值 Value");
foreach (string val in map.Values) {
Console.WriteLine(val);
}
}
}
@@ -0,0 +1,144 @@
/**
* File: hash_map_chaining.cs
* Created Time: 2023-06-26
* Author: hpstory (hpstory1024@163.com)
*/
namespace hello_algo.chapter_hashing;
/* 鏈式位址雜湊表 */
class HashMapChaining {
int size; // 鍵值對數量
int capacity; // 雜湊表容量
double loadThres; // 觸發擴容的負載因子閾值
int extendRatio; // 擴容倍數
List<List<Pair>> buckets; // 桶陣列
/* 建構子 */
public HashMapChaining() {
size = 0;
capacity = 4;
loadThres = 2.0 / 3.0;
extendRatio = 2;
buckets = new List<List<Pair>>(capacity);
for (int i = 0; i < capacity; i++) {
buckets.Add([]);
}
}
/* 雜湊函式 */
int HashFunc(int key) {
return key % capacity;
}
/* 負載因子 */
double LoadFactor() {
return (double)size / capacity;
}
/* 查詢操作 */
public string? Get(int key) {
int index = HashFunc(key);
// 走訪桶,若找到 key ,則返回對應 val
foreach (Pair pair in buckets[index]) {
if (pair.key == key) {
return pair.val;
}
}
// 若未找到 key ,則返回 null
return null;
}
/* 新增操作 */
public void Put(int key, string val) {
// 當負載因子超過閾值時,執行擴容
if (LoadFactor() > loadThres) {
Extend();
}
int index = HashFunc(key);
// 走訪桶,若遇到指定 key ,則更新對應 val 並返回
foreach (Pair pair in buckets[index]) {
if (pair.key == key) {
pair.val = val;
return;
}
}
// 若無該 key ,則將鍵值對新增至尾部
buckets[index].Add(new Pair(key, val));
size++;
}
/* 刪除操作 */
public void Remove(int key) {
int index = HashFunc(key);
// 走訪桶,從中刪除鍵值對
foreach (Pair pair in buckets[index].ToList()) {
if (pair.key == key) {
buckets[index].Remove(pair);
size--;
break;
}
}
}
/* 擴容雜湊表 */
void Extend() {
// 暫存原雜湊表
List<List<Pair>> bucketsTmp = buckets;
// 初始化擴容後的新雜湊表
capacity *= extendRatio;
buckets = new List<List<Pair>>(capacity);
for (int i = 0; i < capacity; i++) {
buckets.Add([]);
}
size = 0;
// 將鍵值對從原雜湊表搬運至新雜湊表
foreach (List<Pair> bucket in bucketsTmp) {
foreach (Pair pair in bucket) {
Put(pair.key, pair.val);
}
}
}
/* 列印雜湊表 */
public void Print() {
foreach (List<Pair> bucket in buckets) {
List<string> res = [];
foreach (Pair pair in bucket) {
res.Add(pair.key + " -> " + pair.val);
}
foreach (string kv in res) {
Console.WriteLine(kv);
}
}
}
}
public class hash_map_chaining {
[Test]
public void Test() {
/* 初始化雜湊表 */
HashMapChaining map = new();
/* 新增操作 */
// 在雜湊表中新增鍵值對 (key, value)
map.Put(12836, "小哈");
map.Put(15937, "小囉");
map.Put(16750, "小算");
map.Put(13276, "小法");
map.Put(10583, "小鴨");
Console.WriteLine("\n新增完成後,雜湊表為\nKey -> Value");
map.Print();
/* 查詢操作 */
// 向雜湊表中輸入鍵 key ,得到值 value
string? name = map.Get(13276);
Console.WriteLine("\n輸入學號 13276 ,查詢到姓名 " + name);
/* 刪除操作 */
// 在雜湊表中刪除鍵值對 (key, value)
map.Remove(12836);
Console.WriteLine("\n刪除 12836 後,雜湊表為\nKey -> Value");
map.Print();
}
}
@@ -0,0 +1,159 @@
/**
* File: hash_map_open_addressing.cs
* Created Time: 2023-06-26
* Author: hpstory (hpstory1024@163.com)
*/
namespace hello_algo.chapter_hashing;
/* 開放定址雜湊表 */
class HashMapOpenAddressing {
int size; // 鍵值對數量
int capacity = 4; // 雜湊表容量
double loadThres = 2.0 / 3.0; // 觸發擴容的負載因子閾值
int extendRatio = 2; // 擴容倍數
Pair[] buckets; // 桶陣列
Pair TOMBSTONE = new(-1, "-1"); // 刪除標記
/* 建構子 */
public HashMapOpenAddressing() {
size = 0;
buckets = new Pair[capacity];
}
/* 雜湊函式 */
int HashFunc(int key) {
return key % capacity;
}
/* 負載因子 */
double LoadFactor() {
return (double)size / capacity;
}
/* 搜尋 key 對應的桶索引 */
int FindBucket(int key) {
int index = HashFunc(key);
int 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 firstTombstone == -1 ? index : firstTombstone;
}
/* 查詢操作 */
public string? Get(int key) {
// 搜尋 key 對應的桶索引
int index = FindBucket(key);
// 若找到鍵值對,則返回對應 val
if (buckets[index] != null && buckets[index] != TOMBSTONE) {
return buckets[index].val;
}
// 若鍵值對不存在,則返回 null
return null;
}
/* 新增操作 */
public void Put(int key, string val) {
// 當負載因子超過閾值時,執行擴容
if (LoadFactor() > loadThres) {
Extend();
}
// 搜尋 key 對應的桶索引
int index = FindBucket(key);
// 若找到鍵值對,則覆蓋 val 並返回
if (buckets[index] != null && buckets[index] != TOMBSTONE) {
buckets[index].val = val;
return;
}
// 若鍵值對不存在,則新增該鍵值對
buckets[index] = new Pair(key, val);
size++;
}
/* 刪除操作 */
public void Remove(int key) {
// 搜尋 key 對應的桶索引
int index = FindBucket(key);
// 若找到鍵值對,則用刪除標記覆蓋它
if (buckets[index] != null && buckets[index] != TOMBSTONE) {
buckets[index] = TOMBSTONE;
size--;
}
}
/* 擴容雜湊表 */
void Extend() {
// 暫存原雜湊表
Pair[] bucketsTmp = buckets;
// 初始化擴容後的新雜湊表
capacity *= extendRatio;
buckets = new Pair[capacity];
size = 0;
// 將鍵值對從原雜湊表搬運至新雜湊表
foreach (Pair pair in bucketsTmp) {
if (pair != null && pair != TOMBSTONE) {
Put(pair.key, pair.val);
}
}
}
/* 列印雜湊表 */
public void Print() {
foreach (Pair pair in buckets) {
if (pair == null) {
Console.WriteLine("null");
} else if (pair == TOMBSTONE) {
Console.WriteLine("TOMBSTONE");
} else {
Console.WriteLine(pair.key + " -> " + pair.val);
}
}
}
}
public class hash_map_open_addressing {
[Test]
public void Test() {
/* 初始化雜湊表 */
HashMapOpenAddressing map = new();
/* 新增操作 */
// 在雜湊表中新增鍵值對 (key, value)
map.Put(12836, "小哈");
map.Put(15937, "小囉");
map.Put(16750, "小算");
map.Put(13276, "小法");
map.Put(10583, "小鴨");
Console.WriteLine("\n新增完成後,雜湊表為\nKey -> Value");
map.Print();
/* 查詢操作 */
// 向雜湊表中輸入鍵 key ,得到值 value
string? name = map.Get(13276);
Console.WriteLine("\n輸入學號 13276 ,查詢到姓名 " + name);
/* 刪除操作 */
// 在雜湊表中刪除鍵值對 (key, value)
map.Remove(16750);
Console.WriteLine("\n刪除 16750 後,雜湊表為\nKey -> Value");
map.Print();
}
}
@@ -0,0 +1,66 @@
/**
* File: simple_hash.cs
* Created Time: 2023-06-26
* Author: hpstory (hpstory1024@163.com)
*/
namespace hello_algo.chapter_hashing;
public class simple_hash {
/* 加法雜湊 */
int AddHash(string key) {
long hash = 0;
const int MODULUS = 1000000007;
foreach (char c in key) {
hash = (hash + c) % MODULUS;
}
return (int)hash;
}
/* 乘法雜湊 */
int MulHash(string key) {
long hash = 0;
const int MODULUS = 1000000007;
foreach (char c in key) {
hash = (31 * hash + c) % MODULUS;
}
return (int)hash;
}
/* 互斥或雜湊 */
int XorHash(string key) {
int hash = 0;
const int MODULUS = 1000000007;
foreach (char c in key) {
hash ^= c;
}
return hash & MODULUS;
}
/* 旋轉雜湊 */
int RotHash(string key) {
long hash = 0;
const int MODULUS = 1000000007;
foreach (char c in key) {
hash = ((hash << 4) ^ (hash >> 28) ^ c) % MODULUS;
}
return (int)hash;
}
[Test]
public void Test() {
string key = "Hello 演算法";
int hash = AddHash(key);
Console.WriteLine("加法雜湊值為 " + hash);
hash = MulHash(key);
Console.WriteLine("乘法雜湊值為 " + hash);
hash = XorHash(key);
Console.WriteLine("互斥或雜湊值為 " + hash);
hash = RotHash(key);
Console.WriteLine("旋轉雜湊值為 " + hash);
}
}