CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-05-16 14:14:03 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2024-09-28 09:26:54 +08:00
parent 03a6cd27ca
commit 4ac4f94628
25 changed files with 119 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
zh-Hant/docs/chapter_array_and_linkedlist/linked_list.md
View File

@@ -1443,8 +1443,8 @@ comments: true
/* 雙向鏈結串列節點類別 */
class ListNode {
int val; // 節點值
ListNode next; // 指向後繼節點的引用
ListNode prev; // 指向前驅節點的引用
ListNode? next; // 指向後繼節點的引用
ListNode? prev; // 指向前驅節點的引用
ListNode(this.val, [this.next, this.prev]); // 建構子
}
```

2
zh-Hant/docs/chapter_array_and_linkedlist/list.md
View File

@@ -1721,7 +1721,7 @@ comments: true
remove(index) {
if (index < 0 || index >= this.#size) throw new Error('索引越界');
let num = this.#arr[index];
// 將將索引 index 之後的元素都向前移動一位
// 將索引 index 之後的元素都向前移動一位
for (let j = index; j < this.#size - 1; j++) {
this.#arr[j] = this.#arr[j + 1];
}

2
zh-Hant/docs/chapter_array_and_linkedlist/summary.md
View File

@@ -29,7 +29,7 @@ comments: true
鏈結串列由節點組成，節點之間透過引用（指標）連線，各個節點可以儲存不同型別的資料，例如 `int`、`double`、`string`、`object` 等。
相對地，陣列元素則必須是相同型別的，這樣才能透過計算偏移量來獲取對應元素位置。例如，陣列同時包含 `int` 和 `long` 兩種型別，單個元素分別佔用 4 位元組 和 8 位元組 ，此時就不能用以下公式計算偏移量了，因為陣列中包含了兩種“元素長度”。
相對地，陣列元素則必須是相同型別的，這樣才能透過計算偏移量來獲取對應元素位置。例如，陣列同時包含 `int` 和 `long` 兩種型別，單個元素分別佔用 4 位元組和 8 位元組 ，此時就不能用以下公式計算偏移量了，因為陣列中包含了兩種“元素長度”。
```shell
# 元素記憶體位址 = 陣列記憶體位址（首元素記憶體位址） + 元素長度 * 元素索引

19
zh-Hant/docs/chapter_backtracking/n_queens_problem.md
View File

@@ -532,11 +532,7 @@ comments: true
) {
// 當放置完所有行時，記錄解
if row == n {
let mut copy_state: Vec<Vec<String>> = Vec::new();
for s_row in state.clone() {
copy_state.push(s_row);
}
res.push(copy_state);
res.push(state.clone());
return;
}
// 走訪所有列
@@ -547,12 +543,12 @@ comments: true
// 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后
if !cols[col] && !diags1[diag1] && !diags2[diag2] {
// 嘗試：將皇后放置在該格子
state.get_mut(row).unwrap()[col] = "Q".into();
state[row][col] = "Q".into();
(cols[col], diags1[diag1], diags2[diag2]) = (true, true, true);
// 放置下一行
backtrack(row + 1, n, state, res, cols, diags1, diags2);
// 回退：將該格子恢復為空位
state.get_mut(row).unwrap()[col] = "#".into();
state[row][col] = "#".into();
(cols[col], diags1[diag1], diags2[diag2]) = (false, false, false);
}
}
@@ -561,14 +557,7 @@ comments: true
/* 求解 n 皇后 */
fn n_queens(n: usize) -> Vec<Vec<Vec<String>>> {
// 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位
let mut state: Vec<Vec<String>> = Vec::new();
for _ in 0..n {
let mut row: Vec<String> = Vec::new();
for _ in 0..n {
row.push("#".into());
}
state.push(row);
}
let mut state: Vec<Vec<String>> = vec![vec!["#".to_string(); n]; n];
let mut cols = vec![false; n]; // 記錄列是否有皇后
let mut diags1 = vec![false; 2 * n - 1]; // 記錄主對角線上是否有皇后
let mut diags2 = vec![false; 2 * n - 1]; // 記錄次對角線上是否有皇后

30
zh-Hant/docs/chapter_backtracking/subset_sum_problem.md
View File

@@ -355,7 +355,7 @@ comments: true
```rust title="subset_sum_i_naive.rs"
/* 回溯演算法：子集和 I */
fn backtrack(
mut state: Vec<i32>,
state: &mut Vec<i32>,
target: i32,
total: i32,
choices: &[i32],
@@ -363,7 +363,7 @@ comments: true
) {
// 子集和等於 target 時，記錄解
if total == target {
res.push(state);
res.push(state.clone());
return;
}
// 走訪所有選擇
@@ -375,7 +375,7 @@ comments: true
// 嘗試：做出選擇，更新元素和 total
state.push(choices[i]);
// 進行下一輪選擇
backtrack(state.clone(), target, total + choices[i], choices, res);
backtrack(state, target, total + choices[i], choices, res);
// 回退：撤銷選擇，恢復到之前的狀態
state.pop();
}
@@ -383,10 +383,10 @@ comments: true
/* 求解子集和 I（包含重複子集） */
fn subset_sum_i_naive(nums: &[i32], target: i32) -> Vec<Vec<i32>> {
let state = Vec::new(); // 狀態（子集）
let mut state = Vec::new(); // 狀態（子集）
let total = 0; // 子集和
let mut res = Vec::new(); // 結果串列（子集串列）
backtrack(state, target, total, nums, &mut res);
backtrack(&mut state, target, total, nums, &mut res);
res
}
```
@@ -912,7 +912,7 @@ comments: true
```rust title="subset_sum_i.rs"
/* 回溯演算法：子集和 I */
fn backtrack(
mut state: Vec<i32>,
state: &mut Vec<i32>,
target: i32,
choices: &[i32],
start: usize,
@@ -920,7 +920,7 @@ comments: true
) {
// 子集和等於 target 時，記錄解
if target == 0 {
res.push(state);
res.push(state.clone());
return;
}
// 走訪所有選擇
@@ -934,7 +934,7 @@ comments: true
// 嘗試：做出選擇，更新 target, start
state.push(choices[i]);
// 進行下一輪選擇
backtrack(state.clone(), target - choices[i], choices, i, res);
backtrack(state, target - choices[i], choices, i, res);
// 回退：撤銷選擇，恢復到之前的狀態
state.pop();
}
@@ -942,11 +942,11 @@ comments: true
/* 求解子集和 I */
fn subset_sum_i(nums: &mut [i32], target: i32) -> Vec<Vec<i32>> {
let state = Vec::new(); // 狀態（子集）
let mut state = Vec::new(); // 狀態（子集）
nums.sort(); // 對 nums 進行排序
let start = 0; // 走訪起始點
let mut res = Vec::new(); // 結果串列（子集串列）
backtrack(state, target, nums, start, &mut res);
backtrack(&mut state, target, nums, start, &mut res);
res
}
```
@@ -1512,7 +1512,7 @@ comments: true
```rust title="subset_sum_ii.rs"
/* 回溯演算法：子集和 II */
fn backtrack(
mut state: Vec<i32>,
state: &mut Vec<i32>,
target: i32,
choices: &[i32],
start: usize,
@@ -1520,7 +1520,7 @@ comments: true
) {
// 子集和等於 target 時，記錄解
if target == 0 {
res.push(state);
res.push(state.clone());
return;
}
// 走訪所有選擇
@@ -1539,7 +1539,7 @@ comments: true
// 嘗試：做出選擇，更新 target, start
state.push(choices[i]);
// 進行下一輪選擇
backtrack(state.clone(), target - choices[i], choices, i, res);
backtrack(state, target - choices[i], choices, i + 1, res);
// 回退：撤銷選擇，恢復到之前的狀態
state.pop();
}
@@ -1547,11 +1547,11 @@ comments: true
/* 求解子集和 II */
fn subset_sum_ii(nums: &mut [i32], target: i32) -> Vec<Vec<i32>> {
let state = Vec::new(); // 狀態（子集）
let mut state = Vec::new(); // 狀態（子集）
nums.sort(); // 對 nums 進行排序
let start = 0; // 走訪起始點
let mut res = Vec::new(); // 結果串列（子集串列）
backtrack(state, target, nums, start, &mut res);
backtrack(&mut state, target, nums, start, &mut res);
res
}
```

2
zh-Hant/docs/chapter_greedy/max_capacity_problem.md
View File

@@ -54,7 +54,7 @@ $$
1. 初始狀態下，指標 $i$ 和 $j$ 分列陣列兩端。
2. 計算當前狀態的容量 $cap[i, j]$ ，並更新最大容量。
3. 比較板 $i$ 和 板 $j$ 的高度，並將短板向內移動一格。
3. 比較板 $i$ 和板 $j$ 的高度，並將短板向內移動一格。
4. 迴圈執行第 `2.` 步和第 `3.` 步，直至 $i$ 和 $j$ 相遇時結束。
=== "<1>"

2
zh-Hant/docs/chapter_introduction/algorithms_are_everywhere.md
View File

@@ -12,7 +12,7 @@ comments: true
1. 翻開字典約一半的頁數，檢視該頁的首字母是什麼，假設首字母為 $m$ 。
2. 由於在拼音字母表中 $r$ 位於 $m$ 之後，所以排除字典前半部分，查詢範圍縮小到後半部分。
3. 不斷重複步驟 `1.` 和 步驟 `2.` ，直至找到拼音首字母為 $r$ 的頁碼為止。
3. 不斷重複步驟 `1.` 和步驟 `2.` ，直至找到拼音首字母為 $r$ 的頁碼為止。
=== "<1>"
![查字典步驟](algorithms_are_everywhere.assets/binary_search_dictionary_step1.png){ class="animation-figure" }

29
zh-Hant/docs/chapter_sorting/quick_sort.md
View File

@@ -69,26 +69,19 @@ comments: true
=== "C++"
```cpp title="quick_sort.cpp"
/* 元素交換 */
void swap(vector<int> &nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 哨兵劃分 */
int partition(vector<int> &nums, int left, int right) {
// 以 nums[left] 為基準數
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left])
j--; // 從右向左找首個小於基準數的元素
j--; // 從右向左找首個小於基準數的元素
while (i < j && nums[i] <= nums[left])
i++; // 從左向右找首個大於基準數的元素
swap(nums, i, j); // 交換這兩個元素
i++; // 從左向右找首個大於基準數的元素
swap(nums[i], nums[j]); // 交換這兩個元素
}
swap(nums, i, left); // 將基準數交換至兩子陣列的分界線
return i; // 返回基準數的索引
swap(nums[i], nums[left]); // 將基準數交換至兩子陣列的分界線
return i; // 返回基準數的索引
}
```
@@ -721,18 +714,18 @@ comments: true
// 選取三個候選元素的中位數
int med = medianThree(nums, left, (left + right) / 2, right);
// 將中位數交換至陣列最左端
swap(nums, left, med);
swap(nums[left], nums[med]);
// 以 nums[left] 為基準數
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left])
j--; // 從右向左找首個小於基準數的元素
j--; // 從右向左找首個小於基準數的元素
while (i < j && nums[i] <= nums[left])
i++; // 從左向右找首個大於基準數的元素
swap(nums, i, j); // 交換這兩個元素
i++; // 從左向右找首個大於基準數的元素
swap(nums[i], nums[j]); // 交換這兩個元素
}
swap(nums, i, left); // 將基準數交換至兩子陣列的分界線
return i; // 返回基準數的索引
swap(nums[i], nums[left]); // 將基準數交換至兩子陣列的分界線
return i; // 返回基準數的索引
}
```

2
zh-Hant/docs/chapter_tree/binary_tree.md
View File

@@ -665,7 +665,7 @@ comments: true
### 2. &nbsp; 完全二元樹
如圖 7-5 所示，<u>完全二元樹（complete binary tree）</u>只有最底層的節點未被填滿，且最底層節點儘量靠左填充。
如圖 7-5 所示，<u>完全二元樹（complete binary tree）</u>只有最底層的節點未被填滿，且最底層節點儘量靠左填充。請注意，完美二元樹也是一棵完全二元樹。
![完全二元樹](binary_tree.assets/complete_binary_tree.png){ class="animation-figure" }