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,144 @@
/**
* File: array_deque.kt
* Created Time: 2024-01-25
* Author: curtishd (1023632660@qq.com)
*/
package chapter_stack_and_queue
/* 基於環形陣列實現的雙向佇列 */
class ArrayDeque(capacity: Int) {
private var nums = IntArray(capacity) // 用於儲存雙向佇列元素的陣列
private var front = 0 // 佇列首指標,指向佇列首元素
private var queSize = 0 // 雙向佇列長度
/* 獲取雙向佇列的容量 */
fun capacity(): Int {
return nums.size
}
/* 獲取雙向佇列的長度 */
fun size(): Int {
return queSize
}
/* 判斷雙向佇列是否為空 */
fun isEmpty(): Boolean {
return queSize == 0
}
/* 計算環形陣列索引 */
private fun index(i: Int): Int {
// 透過取餘操作實現陣列首尾相連
// 當 i 越過陣列尾部後,回到頭部
// 當 i 越過陣列頭部後,回到尾部
return (i + capacity()) % capacity()
}
/* 佇列首入列 */
fun pushFirst(num: Int) {
if (queSize == capacity()) {
println("雙向佇列已滿")
return
}
// 佇列首指標向左移動一位
// 透過取餘操作實現 front 越過陣列頭部後回到尾部
front = index(front - 1)
// 將 num 新增至佇列首
nums[front] = num
queSize++
}
/* 佇列尾入列 */
fun pushLast(num: Int) {
if (queSize == capacity()) {
println("雙向佇列已滿")
return
}
// 計算佇列尾指標,指向佇列尾索引 + 1
val rear = index(front + queSize)
// 將 num 新增至佇列尾
nums[rear] = num
queSize++
}
/* 佇列首出列 */
fun popFirst(): Int {
val num = peekFirst()
// 佇列首指標向後移動一位
front = index(front + 1)
queSize--
return num
}
/* 訪問佇列尾元素 */
fun popLast(): Int {
val num = peekLast()
queSize--
return num
}
/* 訪問佇列首元素 */
fun peekFirst(): Int {
if (isEmpty()) throw IndexOutOfBoundsException()
return nums[front]
}
/* 訪問佇列尾元素 */
fun peekLast(): Int {
if (isEmpty()) throw IndexOutOfBoundsException()
// 計算尾元素索引
val last = index(front + queSize - 1)
return nums[last]
}
/* 返回陣列用於列印 */
fun toArray(): IntArray {
// 僅轉換有效長度範圍內的串列元素
val res = IntArray(queSize)
var i = 0
var j = front
while (i < queSize) {
res[i] = nums[index(j)]
i++
j++
}
return res
}
}
/* Driver Code */
fun main() {
/* 初始化雙向佇列 */
val deque = ArrayDeque(10)
deque.pushLast(3)
deque.pushLast(2)
deque.pushLast(5)
println("雙向佇列 deque = ${deque.toArray().contentToString()}")
/* 訪問元素 */
val peekFirst = deque.peekFirst()
println("佇列首元素 peekFirst = $peekFirst")
val peekLast = deque.peekLast()
println("佇列尾元素 peekLast = $peekLast")
/* 元素入列 */
deque.pushLast(4)
println("元素 4 佇列尾入列後 deque = ${deque.toArray().contentToString()}")
deque.pushFirst(1)
println("元素 1 佇列首入列後 deque = ${deque.toArray().contentToString()}")
/* 元素出列 */
val popLast = deque.popLast()
println("佇列尾出列元素 = ${popLast},佇列尾出列後 deque = ${deque.toArray().contentToString()}")
val popFirst = deque.popFirst()
println("佇列首出列元素 = ${popFirst},佇列首出列後 deque = ${deque.toArray().contentToString()}")
/* 獲取雙向佇列的長度 */
val size = deque.size()
println("雙向佇列長度 size = $size")
/* 判斷雙向佇列是否為空 */
val isEmpty = deque.isEmpty()
println("雙向佇列是否為空 = $isEmpty")
}
@@ -0,0 +1,110 @@
/**
* File: array_queue.kt
* Created Time: 2024-01-25
* Author: curtishd (1023632660@qq.com)
*/
package chapter_stack_and_queue
/* 基於環形陣列實現的佇列 */
class ArrayQueue(capacity: Int) {
private val nums = IntArray(capacity) // 用於儲存佇列元素的陣列
private var front = 0 // 佇列首指標,指向佇列首元素
private var queSize = 0 // 佇列長度
/* 獲取佇列的容量 */
fun capacity(): Int {
return nums.size
}
/* 獲取佇列的長度 */
fun size(): Int {
return queSize
}
/* 判斷佇列是否為空 */
fun isEmpty(): Boolean {
return queSize == 0
}
/* 入列 */
fun push(num: Int) {
if (queSize == capacity()) {
println("佇列已滿")
return
}
// 計算佇列尾指標,指向佇列尾索引 + 1
// 透過取餘操作實現 rear 越過陣列尾部後回到頭部
val rear = (front + queSize) % capacity()
// 將 num 新增至佇列尾
nums[rear] = num
queSize++
}
/* 出列 */
fun pop(): Int {
val num = peek()
// 佇列首指標向後移動一位,若越過尾部,則返回到陣列頭部
front = (front + 1) % capacity()
queSize--
return num
}
/* 訪問佇列首元素 */
fun peek(): Int {
if (isEmpty()) throw IndexOutOfBoundsException()
return nums[front]
}
/* 返回陣列 */
fun toArray(): IntArray {
// 僅轉換有效長度範圍內的串列元素
val res = IntArray(queSize)
var i = 0
var j = front
while (i < queSize) {
res[i] = nums[j % capacity()]
i++
j++
}
return res
}
}
/* Driver Code */
fun main() {
/* 初始化佇列 */
val capacity = 10
val queue = ArrayQueue(capacity)
/* 元素入列 */
queue.push(1)
queue.push(3)
queue.push(2)
queue.push(5)
queue.push(4)
println("佇列 queue = ${queue.toArray().contentToString()}")
/* 訪問佇列首元素 */
val peek = queue.peek()
println("佇列首元素 peek = $peek")
/* 元素出列 */
val pop = queue.pop()
println("出列元素 pop = ${pop},出列後 queue = ${queue.toArray().contentToString()}")
/* 獲取佇列的長度 */
val size = queue.size()
println("佇列長度 size = $size")
/* 判斷佇列是否為空 */
val isEmpty = queue.isEmpty()
println("佇列是否為空 = $isEmpty")
/* 測試環形陣列 */
for (i in 0..9) {
queue.push(i)
queue.pop()
println("$i 輪入列 + 出列後 queue = ${queue.toArray().contentToString()}")
}
}
@@ -0,0 +1,75 @@
/**
* File: array_stack.kt
* Created Time: 2024-01-25
* Author: curtishd (1023632660@qq.com)
*/
package chapter_stack_and_queue
/* 基於陣列實現的堆疊 */
class ArrayStack {
// 初始化串列(動態陣列)
private val stack = ArrayList<Int>()
/* 獲取堆疊的長度 */
fun size(): Int {
return stack.size
}
/* 判斷堆疊是否為空 */
fun isEmpty(): Boolean {
return size() == 0
}
/* 入堆疊 */
fun push(num: Int) {
stack.add(num)
}
/* 出堆疊 */
fun pop(): Int {
if (isEmpty()) throw IndexOutOfBoundsException()
return stack.removeAt(size() - 1)
}
/* 訪問堆疊頂元素 */
fun peek(): Int {
if (isEmpty()) throw IndexOutOfBoundsException()
return stack[size() - 1]
}
/* 將 List 轉化為 Array 並返回 */
fun toArray(): Array<Any> {
return stack.toArray()
}
}
/* Driver Code */
fun main() {
/* 初始化堆疊 */
val stack = ArrayStack()
/* 元素入堆疊 */
stack.push(1)
stack.push(3)
stack.push(2)
stack.push(5)
stack.push(4)
println("堆疊 stack = ${stack.toArray().contentToString()}")
/* 訪問堆疊頂元素 */
val peek = stack.peek()
println("堆疊頂元素 peek = $peek")
/* 元素出堆疊 */
val pop = stack.pop()
println("出堆疊元素 pop = ${pop},出堆疊後 stack = ${stack.toArray().contentToString()}")
/* 獲取堆疊的長度 */
val size = stack.size()
println("堆疊的長度 size = $size")
/* 判斷是否為空 */
val isEmpty = stack.isEmpty()
println("堆疊是否為空 = $isEmpty")
}
@@ -0,0 +1,45 @@
/**
* File: deque.kt
* Created Time: 2024-01-25
* Author: curtishd (1023632660@qq.com)
*/
package chapter_stack_and_queue
import java.util.*
/* Driver Code */
fun main() {
/* 初始化雙向佇列 */
val deque = LinkedList<Int>()
deque.offerLast(3)
deque.offerLast(2)
deque.offerLast(5)
println("雙向佇列 deque = $deque")
/* 訪問元素 */
val peekFirst = deque.peekFirst()
println("佇列首元素 peekFirst = $peekFirst")
val peekLast = deque.peekLast()
println("佇列尾元素 peekLast = $peekLast")
/* 元素入列 */
deque.offerLast(4)
println("元素 4 佇列尾入列後 deque = $deque")
deque.offerFirst(1)
println("元素 1 佇列首入列後 deque = $deque")
/* 元素出列 */
val popLast = deque.pollLast()
println("佇列尾出列元素 = $popLast,佇列尾出列後 deque = $deque")
val popFirst = deque.pollFirst()
println("佇列首出列元素 = $popFirst,佇列首出列後 deque = $deque")
/* 獲取雙向佇列的長度 */
val size = deque.size
println("雙向佇列長度 size = $size")
/* 判斷雙向佇列是否為空 */
val isEmpty = deque.isEmpty()
println("雙向佇列是否為空 = $isEmpty")
}
@@ -0,0 +1,166 @@
/**
* File: linkedlist_deque.kt
* Created Time: 2024-01-25
* Author: curtishd (1023632660@qq.com)
*/
package chapter_stack_and_queue
/* 雙向鏈結串列節點 */
class ListNode(var value: Int) {
// 節點值
var next: ListNode? = null // 後繼節點引用
var prev: ListNode? = null // 前驅節點引用
}
/* 基於雙向鏈結串列實現的雙向佇列 */
class LinkedListDeque {
private var front: ListNode? = null // 頭節點 front ,尾節點 rear
private var rear: ListNode? = null
private var queSize = 0 // 雙向佇列的長度
/* 獲取雙向佇列的長度 */
fun size(): Int {
return queSize
}
/* 判斷雙向佇列是否為空 */
fun isEmpty(): Boolean {
return size() == 0
}
/* 入列操作 */
fun push(num: Int, isFront: Boolean) {
val node = ListNode(num)
// 若鏈結串列為空,則令 front 和 rear 都指向 node
if (isEmpty()) {
rear = node
front = rear
// 佇列首入列操作
} else if (isFront) {
// 將 node 新增至鏈結串列頭部
front?.prev = node
node.next = front
front = node // 更新頭節點
// 佇列尾入列操作
} else {
// 將 node 新增至鏈結串列尾部
rear?.next = node
node.prev = rear
rear = node // 更新尾節點
}
queSize++ // 更新佇列長度
}
/* 佇列首入列 */
fun pushFirst(num: Int) {
push(num, true)
}
/* 佇列尾入列 */
fun pushLast(num: Int) {
push(num, false)
}
/* 出列操作 */
fun pop(isFront: Boolean): Int {
if (isEmpty()) throw IndexOutOfBoundsException()
val value: Int
// 佇列首出列操作
if (isFront) {
value = front!!.value // 暫存頭節點值
// 刪除頭節點
val fNext = front!!.next
if (fNext != null) {
fNext.prev = null
front!!.next = null
}
front = fNext // 更新頭節點
// 佇列尾出列操作
} else {
value = rear!!.value // 暫存尾節點值
// 刪除尾節點
val rPrev = rear!!.prev
if (rPrev != null) {
rPrev.next = null
rear!!.prev = null
}
rear = rPrev // 更新尾節點
}
queSize-- // 更新佇列長度
return value
}
/* 佇列首出列 */
fun popFirst(): Int {
return pop(true)
}
/* 佇列尾出列 */
fun popLast(): Int {
return pop(false)
}
/* 訪問佇列首元素 */
fun peekFirst(): Int {
if (isEmpty()) {
throw IndexOutOfBoundsException()
}
return front!!.value
}
/* 訪問佇列尾元素 */
fun peekLast(): Int {
if (isEmpty()) throw IndexOutOfBoundsException()
return rear!!.value
}
/* 返回陣列用於列印 */
fun toArray(): IntArray {
var node = front
val res = IntArray(size())
for (i in res.indices) {
res[i] = node!!.value
node = node.next
}
return res
}
}
/* Driver Code */
fun main() {
/* 初始化雙向佇列 */
val deque = LinkedListDeque()
deque.pushLast(3)
deque.pushLast(2)
deque.pushLast(5)
println("雙向佇列 deque = ${deque.toArray().contentToString()}")
/* 訪問元素 */
val peekFirst = deque.peekFirst()
println("佇列首元素 peekFirst = $peekFirst")
val peekLast = deque.peekLast()
println("佇列尾元素 peekLast = $peekLast")
/* 元素入列 */
deque.pushLast(4)
println("元素 4 佇列尾入列後 deque = ${deque.toArray().contentToString()}")
deque.pushFirst(1)
println("元素 1 佇列首入列後 deque = ${deque.toArray().contentToString()}")
/* 元素出列 */
val popLast = deque.popLast()
println("佇列尾出列元素 = ${popLast},佇列尾出列後 deque = ${deque.toArray().contentToString()}")
val popFirst = deque.popFirst()
println("佇列首出列元素 = ${popFirst},佇列首出列後 deque = ${deque.toArray().contentToString()}")
/* 獲取雙向佇列的長度 */
val size = deque.size()
println("雙向佇列長度 size = $size")
/* 判斷雙向佇列是否為空 */
val isEmpty = deque.isEmpty()
println("雙向佇列是否為空 = $isEmpty")
}
@@ -0,0 +1,98 @@
/**
* File: linkedlist_queue.kt
* Created Time: 2024-01-25
* Author: curtishd (1023632660@qq.com)
*/
package chapter_stack_and_queue
/* 基於鏈結串列實現的佇列 */
class LinkedListQueue(
// 頭節點 front ,尾節點 rear
private var front: ListNode? = null,
private var rear: ListNode? = null,
private var queSize: Int = 0
) {
/* 獲取佇列的長度 */
fun size(): Int {
return queSize
}
/* 判斷佇列是否為空 */
fun isEmpty(): Boolean {
return size() == 0
}
/* 入列 */
fun push(num: Int) {
// 在尾節點後新增 num
val node = ListNode(num)
// 如果佇列為空,則令頭、尾節點都指向該節點
if (front == null) {
front = node
rear = node
// 如果佇列不為空,則將該節點新增到尾節點後
} else {
rear?.next = node
rear = node
}
queSize++
}
/* 出列 */
fun pop(): Int {
val num = peek()
// 刪除頭節點
front = front?.next
queSize--
return num
}
/* 訪問佇列首元素 */
fun peek(): Int {
if (isEmpty()) throw IndexOutOfBoundsException()
return front!!.value
}
/* 將鏈結串列轉化為 Array 並返回 */
fun toArray(): IntArray {
var node = front
val res = IntArray(size())
for (i in res.indices) {
res[i] = node!!.value
node = node.next
}
return res
}
}
/* Driver Code */
fun main() {
/* 初始化佇列 */
val queue = LinkedListQueue()
/* 元素入列 */
queue.push(1)
queue.push(3)
queue.push(2)
queue.push(5)
queue.push(4)
println("佇列 queue = ${queue.toArray().contentToString()}")
/* 訪問佇列首元素 */
val peek = queue.peek()
println("佇列首元素 peek = $peek")
/* 元素出列 */
val pop = queue.pop()
println("出列元素 pop = $pop,出列後 queue = ${queue.toArray().contentToString()}")
/* 獲取佇列的長度 */
val size = queue.size()
println("佇列長度 size = $size")
/* 判斷佇列是否為空 */
val isEmpty = queue.isEmpty()
println("佇列是否為空 = $isEmpty")
}
@@ -0,0 +1,87 @@
/**
* File: linkedlist_stack.kt
* Created Time: 2024-01-25
* Author: curtishd (1023632660@qq.com)
*/
package chapter_stack_and_queue
/* 基於鏈結串列實現的堆疊 */
class LinkedListStack(
private var stackPeek: ListNode? = null, // 將頭節點作為堆疊頂
private var stkSize: Int = 0 // 堆疊的長度
) {
/* 獲取堆疊的長度 */
fun size(): Int {
return stkSize
}
/* 判斷堆疊是否為空 */
fun isEmpty(): Boolean {
return size() == 0
}
/* 入堆疊 */
fun push(num: Int) {
val node = ListNode(num)
node.next = stackPeek
stackPeek = node
stkSize++
}
/* 出堆疊 */
fun pop(): Int? {
val num = peek()
stackPeek = stackPeek?.next
stkSize--;
return num
}
/* 訪問堆疊頂元素 */
fun peek(): Int? {
if (isEmpty()) throw IndexOutOfBoundsException()
return stackPeek?.value
}
/* 將 List 轉化為 Array 並返回 */
fun toArray(): IntArray {
var node = stackPeek
val res = IntArray(size())
for (i in res.size - 1 downTo 0) {
res[i] = node?.value!!
node = node.next
}
return res
}
}
/* Driver Code */
fun main() {
/* 初始化堆疊 */
val stack = LinkedListStack()
/* 元素入堆疊 */
stack.push(1)
stack.push(3)
stack.push(2)
stack.push(5)
stack.push(4)
println("堆疊 stack = ${stack.toArray().contentToString()}")
/* 訪問堆疊頂元素 */
val peek = stack.peek()!!
println("堆疊頂元素 peek = $peek")
/* 元素出堆疊 */
val pop = stack.pop()!!
println("出堆疊元素 pop = $pop,出堆疊後 stack = ${stack.toArray().contentToString()}")
/* 獲取堆疊的長度 */
val size = stack.size()
println("堆疊的長度 size = $size")
/* 判斷是否為空 */
val isEmpty = stack.isEmpty()
println("堆疊是否為空 = $isEmpty")
}
@@ -0,0 +1,39 @@
/**
* File: queue.kt
* Created Time: 2024-01-25
* Author: curtishd (1023632660@qq.com)
*/
package chapter_stack_and_queue
import java.util.*
/* Driver Code */
fun main() {
/* 初始化佇列 */
val queue = LinkedList<Int>()
/* 元素入列 */
queue.offer(1)
queue.offer(3)
queue.offer(2)
queue.offer(5)
queue.offer(4)
println("佇列 queue = $queue")
/* 訪問佇列首元素 */
val peek = queue.peek()
println("佇列首元素 peek = $peek")
/* 元素出列 */
val pop = queue.poll()
println("出列元素 pop = $pop,出列後 queue = $queue")
/* 獲取佇列的長度 */
val size = queue.size
println("佇列長度 size = $size")
/* 判斷佇列是否為空 */
val isEmpty = queue.isEmpty()
println("佇列是否為空 = $isEmpty")
}
@@ -0,0 +1,39 @@
/**
* File: stack.kt
* Created Time: 2024-01-25
* Author: curtishd (1023632660@qq.com)
*/
package chapter_stack_and_queue
import java.util.*
/* Driver Code */
fun main() {
/* 初始化堆疊 */
val stack = Stack<Int>()
/* 元素入堆疊 */
stack.push(1)
stack.push(3)
stack.push(2)
stack.push(5)
stack.push(4)
println("堆疊 stack = $stack")
/* 訪問堆疊頂元素 */
val peek = stack.peek()
println("堆疊頂元素 peek = $peek")
/* 元素出堆疊 */
val pop = stack.pop()
println("出堆疊元素 pop = $pop,出堆疊後 stack = $stack")
/* 獲取堆疊的長度 */
val size = stack.size
println("堆疊的長度 size = $size")
/* 判斷是否為空 */
val isEmpty = stack.isEmpty()
println("堆疊是否為空 = $isEmpty")
}