CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-23 18:11:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: Traditional Chinese version (#1163)

Browse Source 
* 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
Download Patch File Download Diff File Expand all files Collapse all files

6
zh-hant/codes/javascript/.prettierrc Normal file
View File

@@ -0,0 +1,6 @@
{
"tabWidth": 4,
"useTabs": false,
"semi": true,
"singleQuote": true
}

97
zh-hant/codes/javascript/chapter_array_and_linkedlist/array.js Normal file
View File

@@ -0,0 +1,97 @@
/**
* File: array.js
* Created Time: 2022-11-27
* Author: IsChristina (christinaxia77@foxmail.com)
*/
/* 隨機訪問元素 */
function randomAccess(nums) {
// 在區間 [0, nums.length) 中隨機抽取一個數字
const random_index = Math.floor(Math.random() * nums.length);
// 獲取並返回隨機元素
const random_num = nums[random_index];
return random_num;
}
/* 擴展陣列長度 */
// 請注意，JavaScript 的 Array 是動態陣列，可以直接擴展
// 為了方便學習，本函式將 Array 看作長度不可變的陣列
function extend(nums, enlarge) {
// 初始化一個擴展長度後的陣列
const res = new Array(nums.length + enlarge).fill(0);
// 將原陣列中的所有元素複製到新陣列
for (let i = 0; i < nums.length; i++) {
res[i] = nums[i];
}
// 返回擴展後的新陣列
return res;
}
/* 在陣列的索引 index 處插入元素 num */
function insert(nums, num, index) {
// 把索引 index 以及之後的所有元素向後移動一位
for (let i = nums.length - 1; i > index; i--) {
nums[i] = nums[i - 1];
}
// 將 num 賦給 index 處的元素
nums[index] = num;
}
/* 刪除索引 index 處的元素 */
function remove(nums, index) {
// 把索引 index 之後的所有元素向前移動一位
for (let i = index; i < nums.length - 1; i++) {
nums[i] = nums[i + 1];
}
}
/* 走訪陣列 */
function traverse(nums) {
let count = 0;
// 透過索引走訪陣列
for (let i = 0; i < nums.length; i++) {
count += nums[i];
}
// 直接走訪陣列元素
for (const num of nums) {
count += num;
}
}
/* 在陣列中查詢指定元素 */
function find(nums, target) {
for (let i = 0; i < nums.length; i++) {
if (nums[i] === target) return i;
}
return -1;
}
/* Driver Code */
/* 初始化陣列 */
const arr = new Array(5).fill(0);
console.log('陣列 arr =', arr);
let nums = [1, 3, 2, 5, 4];
console.log('陣列 nums =', nums);
/* 隨機訪問 */
let random_num = randomAccess(nums);
console.log('在 nums 中獲取隨機元素', random_num);
/* 長度擴展 */
nums = extend(nums, 3);
console.log('將陣列長度擴展至 8 ，得到 nums =', nums);
/* 插入元素 */
insert(nums, 6, 3);
console.log('在索引 3 處插入數字 6 ，得到 nums =', nums);
/* 刪除元素 */
remove(nums, 2);
console.log('刪除索引 2 處的元素，得到 nums =', nums);
/* 走訪陣列 */
traverse(nums);
/* 查詢元素 */
let index = find(nums, 3);
console.log('在 nums 中查詢元素 3 ，得到索引 =', index);

82
zh-hant/codes/javascript/chapter_array_and_linkedlist/linked_list.js Normal file
View File

@@ -0,0 +1,82 @@
/**
* File: linked_list.js
* Created Time: 2022-12-12
* Author: IsChristina (christinaxia77@foxmail.com), Justin (xiefahit@gmail.com)
*/
const { printLinkedList } = require('../modules/PrintUtil');
const { ListNode } = require('../modules/ListNode');
/* 在鏈結串列的節點 n0 之後插入節點 P */
function insert(n0, P) {
const n1 = n0.next;
P.next = n1;
n0.next = P;
}
/* 刪除鏈結串列的節點 n0 之後的首個節點 */
function remove(n0) {
if (!n0.next) return;
// n0 -> P -> n1
const P = n0.next;
const n1 = P.next;
n0.next = n1;
}
/* 訪問鏈結串列中索引為 index 的節點 */
function access(head, index) {
for (let i = 0; i < index; i++) {
if (!head) {
return null;
}
head = head.next;
}
return head;
}
/* 在鏈結串列中查詢值為 target 的首個節點 */
function find(head, target) {
let index = 0;
while (head !== null) {
if (head.val === target) {
return index;
}
head = head.next;
index += 1;
}
return -1;
}
/* Driver Code */
/* 初始化鏈結串列 */
// 初始化各個節點
const n0 = new ListNode(1);
const n1 = new ListNode(3);
const n2 = new ListNode(2);
const n3 = new ListNode(5);
const n4 = new ListNode(4);
// 構建節點之間的引用
n0.next = n1;
n1.next = n2;
n2.next = n3;
n3.next = n4;
console.log('初始化的鏈結串列為');
printLinkedList(n0);
/* 插入節點 */
insert(n0, new ListNode(0));
console.log('插入節點後的鏈結串列為');
printLinkedList(n0);
/* 刪除節點 */
remove(n0);
console.log('刪除節點後的鏈結串列為');
printLinkedList(n0);
/* 訪問節點 */
const node = access(n0, 3);
console.log('鏈結串列中索引 3 處的節點的值 = ' + node.val);
/* 查詢節點 */
const index = find(n0, 2);
console.log('鏈結串列中值為 2 的節點的索引 = ' + index);

57
zh-hant/codes/javascript/chapter_array_and_linkedlist/list.js Normal file
View File

@@ -0,0 +1,57 @@
/**
* File: list.js
* Created Time: 2022-12-12
* Author: Justin (xiefahit@gmail.com)
*/
/* 初始化串列 */
const nums = [1, 3, 2, 5, 4];
console.log(`串列 nums = ${nums}`);
/* 訪問元素 */
const num = nums[1];
console.log(`訪問索引 1 處的元素，得到 num = ${num}`);
/* 更新元素 */
nums[1] = 0;
console.log(`將索引 1 處的元素更新為 0 ，得到 nums = ${nums}`);
/* 清空串列 */
nums.length = 0;
console.log(`清空串列後 nums = ${nums}`);
/* 在尾部新增元素 */
nums.push(1);
nums.push(3);
nums.push(2);
nums.push(5);
nums.push(4);
console.log(`新增元素後 nums = ${nums}`);
/* 在中間插入元素 */
nums.splice(3, 0, 6);
console.log(`在索引 3 處插入數字 6 ，得到 nums = ${nums}`);
/* 刪除元素 */
nums.splice(3, 1);
console.log(`刪除索引 3 處的元素，得到 nums = ${nums}`);
/* 透過索引走訪串列 */
let count = 0;
for (let i = 0; i < nums.length; i++) {
count += nums[i];
}
/* 直接走訪串列元素 */
count = 0;
for (const x of nums) {
count += x;
}
/* 拼接兩個串列 */
const nums1 = [6, 8, 7, 10, 9];
nums.push(...nums1);
console.log(`將串列 nums1 拼接到 nums 之後，得到 nums = ${nums}`);
/* 排序串列 */
nums.sort((a, b) => a - b);
console.log(`排序串列後 nums = ${nums}`);

141
zh-hant/codes/javascript/chapter_array_and_linkedlist/my_list.js Normal file
View File

@@ -0,0 +1,141 @@
/**
* File: my_list.js
* Created Time: 2022-12-12
* Author: Justin (xiefahit@gmail.com)
*/
/* 串列類別 */
class MyList {
#arr = new Array(); // 陣列（儲存串列元素）
#capacity = 10; // 串列容量
#size = 0; // 串列長度（當前元素數量）
#extendRatio = 2; // 每次串列擴容的倍數
/* 建構子 */
constructor() {
this.#arr = new Array(this.#capacity);
}
/* 獲取串列長度（當前元素數量）*/
size() {
return this.#size;
}
/* 獲取串列容量 */
capacity() {
return this.#capacity;
}
/* 訪問元素 */
get(index) {
// 索引如果越界，則丟擲異常，下同
if (index < 0 || index >= this.#size) throw new Error('索引越界');
return this.#arr[index];
}
/* 更新元素 */
set(index, num) {
if (index < 0 || index >= this.#size) throw new Error('索引越界');
this.#arr[index] = num;
}
/* 在尾部新增元素 */
add(num) {
// 如果長度等於容量，則需要擴容
if (this.#size === this.#capacity) {
this.extendCapacity();
}
// 將新元素新增到串列尾部
this.#arr[this.#size] = num;
this.#size++;
}
/* 在中間插入元素 */
insert(index, num) {
if (index < 0 || index >= this.#size) throw new Error('索引越界');
// 元素數量超出容量時，觸發擴容機制
if (this.#size === this.#capacity) {
this.extendCapacity();
}
// 將索引 index 以及之後的元素都向後移動一位
for (let j = this.#size - 1; j >= index; j--) {
this.#arr[j + 1] = this.#arr[j];
}
// 更新元素數量
this.#arr[index] = num;
this.#size++;
}
/* 刪除元素 */
remove(index) {
if (index < 0 || index >= this.#size) throw new Error('索引越界');
let num = this.#arr[index];
// 將將索引 index 之後的元素都向前移動一位
for (let j = index; j < this.#size - 1; j++) {
this.#arr[j] = this.#arr[j + 1];
}
// 更新元素數量
this.#size--;
// 返回被刪除的元素
return num;
}
/* 串列擴容 */
extendCapacity() {
// 新建一個長度為原陣列 extendRatio 倍的新陣列，並將原陣列複製到新陣列
this.#arr = this.#arr.concat(
new Array(this.capacity() * (this.#extendRatio - 1))
);
// 更新串列容量
this.#capacity = this.#arr.length;
}
/* 將串列轉換為陣列 */
toArray() {
let size = this.size();
// 僅轉換有效長度範圍內的串列元素
const arr = new Array(size);
for (let i = 0; i < size; i++) {
arr[i] = this.get(i);
}
return arr;
}
}
/* Driver Code */
/* 初始化串列 */
const nums = new MyList();
/* 在尾部新增元素 */
nums.add(1);
nums.add(3);
nums.add(2);
nums.add(5);
nums.add(4);
console.log(
`串列 nums = ${nums.toArray()} ，容量 = ${nums.capacity()} ，長度 = ${nums.size()}`
);
/* 在中間插入元素 */
nums.insert(3, 6);
console.log(`在索引 3 處插入數字 6 ，得到 nums = ${nums.toArray()}`);
/* 刪除元素 */
nums.remove(3);
console.log(`刪除索引 3 處的元素，得到 nums = ${nums.toArray()}`);
/* 訪問元素 */
const num = nums.get(1);
console.log(`訪問索引 1 處的元素，得到 num = ${num}`);
/* 更新元素 */
nums.set(1, 0);
console.log(`將索引 1 處的元素更新為 0 ，得到 nums = ${nums.toArray()}`);
/* 測試擴容機制 */
for (let i = 0; i < 10; i++) {
// 在 i = 5 時，串列長度將超出串列容量，此時觸發擴容機制
nums.add(i);
}
console.log(
`擴容後的串列 nums = ${nums.toArray()} ，容量 = ${nums.capacity()} ，長度 = ${nums.size()}`
);

55
zh-hant/codes/javascript/chapter_backtracking/n_queens.js Normal file
View File

@@ -0,0 +1,55 @@
/**
* File: n_queens.js
* Created Time: 2023-05-13
* Author: Justin (xiefahit@gmail.com)
*/
/* 回溯演算法：n 皇后 */
function backtrack(row, n, state, res, cols, diags1, diags2) {
// 當放置完所有行時，記錄解
if (row === n) {
res.push(state.map((row) => row.slice()));
return;
}
// 走訪所有列
for (let col = 0; col < n; col++) {
// 計算該格子對應的主對角線和次對角線
const diag1 = row - col + n - 1;
const diag2 = row + col;
// 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后
if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
// 嘗試：將皇后放置在該格子
state[row][col] = 'Q';
cols[col] = diags1[diag1] = diags2[diag2] = true;
// 放置下一行
backtrack(row + 1, n, state, res, cols, diags1, diags2);
// 回退：將該格子恢復為空位
state[row][col] = '#';
cols[col] = diags1[diag1] = diags2[diag2] = false;
}
}
}
/* 求解 n 皇后 */
function nQueens(n) {
// 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位
const state = Array.from({ length: n }, () => Array(n).fill('#'));
const cols = Array(n).fill(false); // 記錄列是否有皇后
const diags1 = Array(2 * n - 1).fill(false); // 記錄主對角線上是否有皇后
const diags2 = Array(2 * n - 1).fill(false); // 記錄次對角線上是否有皇后
const res = [];
backtrack(0, n, state, res, cols, diags1, diags2);
return res;
}
// Driver Code
const n = 4;
const res = nQueens(n);
console.log(`輸入棋盤長寬為 ${n}`);
console.log(`皇后放置方案共有 ${res.length} 種`);
res.forEach((state) => {
console.log('--------------------');
state.forEach((row) => console.log(row));
});

42
zh-hant/codes/javascript/chapter_backtracking/permutations_i.js Normal file
View File

@@ -0,0 +1,42 @@
/**
* File: permutations_i.js
* Created Time: 2023-05-13
* Author: Justin (xiefahit@gmail.com)
*/
/* 回溯演算法：全排列 I */
function backtrack(state, choices, selected, res) {
// 當狀態長度等於元素數量時，記錄解
if (state.length === choices.length) {
res.push([...state]);
return;
}
// 走訪所有選擇
choices.forEach((choice, i) => {
// 剪枝：不允許重複選擇元素
if (!selected[i]) {
// 嘗試：做出選擇，更新狀態
selected[i] = true;
state.push(choice);
// 進行下一輪選擇
backtrack(state, choices, selected, res);
// 回退：撤銷選擇，恢復到之前的狀態
selected[i] = false;
state.pop();
}
});
}
/* 全排列 I */
function permutationsI(nums) {
const res = [];
backtrack([], nums, Array(nums.length).fill(false), res);
return res;
}
// Driver Code
const nums = [1, 2, 3];
const res = permutationsI(nums);
console.log(`輸入陣列 nums = ${JSON.stringify(nums)}`);
console.log(`所有排列 res = ${JSON.stringify(res)}`);

44
zh-hant/codes/javascript/chapter_backtracking/permutations_ii.js Normal file
View File

@@ -0,0 +1,44 @@
/**
* File: permutations_ii.js
* Created Time: 2023-05-13
* Author: Justin (xiefahit@gmail.com)
*/
/* 回溯演算法：全排列 II */
function backtrack(state, choices, selected, res) {
// 當狀態長度等於元素數量時，記錄解
if (state.length === choices.length) {
res.push([...state]);
return;
}
// 走訪所有選擇
const duplicated = new Set();
choices.forEach((choice, i) => {
// 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素
if (!selected[i] && !duplicated.has(choice)) {
// 嘗試：做出選擇，更新狀態
duplicated.add(choice); // 記錄選擇過的元素值
selected[i] = true;
state.push(choice);
// 進行下一輪選擇
backtrack(state, choices, selected, res);
// 回退：撤銷選擇，恢復到之前的狀態
selected[i] = false;
state.pop();
}
});
}
/* 全排列 II */
function permutationsII(nums) {
const res = [];
backtrack([], nums, Array(nums.length).fill(false), res);
return res;
}
// Driver Code
const nums = [1, 2, 2];
const res = permutationsII(nums);
console.log(`輸入陣列 nums = ${JSON.stringify(nums)}`);
console.log(`所有排列 res = ${JSON.stringify(res)}`);

33
zh-hant/codes/javascript/chapter_backtracking/preorder_traversal_i_compact.js Normal file
View File

@@ -0,0 +1,33 @@
/**
* File: preorder_traversal_i_compact.js
* Created Time: 2023-05-09
* Author: Justin (xiefahit@gmail.com)
*/
const { arrToTree } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
/* 前序走訪：例題一 */
function preOrder(root, res) {
if (root === null) {
return;
}
if (root.val === 7) {
// 記錄解
res.push(root);
}
preOrder(root.left, res);
preOrder(root.right, res);
}
// Driver Code
const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
console.log('\n初始化二元樹');
printTree(root);
// 前序走訪
const res = [];
preOrder(root, res);
console.log('\n輸出所有值為 7 的節點');
console.log(res.map((node) => node.val));

40
zh-hant/codes/javascript/chapter_backtracking/preorder_traversal_ii_compact.js Normal file
View File

@@ -0,0 +1,40 @@
/**
* File: preorder_traversal_ii_compact.js
* Created Time: 2023-05-09
* Author: Justin (xiefahit@gmail.com)
*/
const { arrToTree } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
/* 前序走訪：例題二 */
function preOrder(root, path, res) {
if (root === null) {
return;
}
// 嘗試
path.push(root);
if (root.val === 7) {
// 記錄解
res.push([...path]);
}
preOrder(root.left, path, res);
preOrder(root.right, path, res);
// 回退
path.pop();
}
// Driver Code
const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
console.log('\n初始化二元樹');
printTree(root);
// 前序走訪
const path = [];
const res = [];
preOrder(root, path, res);
console.log('\n輸出所有根節點到節點 7 的路徑');
res.forEach((path) => {
console.log(path.map((node) => node.val));
});

41
zh-hant/codes/javascript/chapter_backtracking/preorder_traversal_iii_compact.js Normal file
View File

@@ -0,0 +1,41 @@
/**
* File: preorder_traversal_iii_compact.js
* Created Time: 2023-05-09
* Author: Justin (xiefahit@gmail.com)
*/
const { arrToTree } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
/* 前序走訪：例題三 */
function preOrder(root, path, res) {
// 剪枝
if (root === null || root.val === 3) {
return;
}
// 嘗試
path.push(root);
if (root.val === 7) {
// 記錄解
res.push([...path]);
}
preOrder(root.left, path, res);
preOrder(root.right, path, res);
// 回退
path.pop();
}
// Driver Code
const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
console.log('\n初始化二元樹');
printTree(root);
// 前序走訪
const path = [];
const res = [];
preOrder(root, path, res);
console.log('\n輸出所有根節點到節點 7 的路徑，路徑中不包含值為 3 的節點');
res.forEach((path) => {
console.log(path.map((node) => node.val));
});

68
zh-hant/codes/javascript/chapter_backtracking/preorder_traversal_iii_template.js Normal file
View File

@@ -0,0 +1,68 @@
/**
* File: preorder_traversal_iii_template.js
* Created Time: 2023-05-09
* Author: Justin (xiefahit@gmail.com)
*/
const { arrToTree } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
/* 判斷當前狀態是否為解 */
function isSolution(state) {
return state && state[state.length - 1]?.val === 7;
}
/* 記錄解 */
function recordSolution(state, res) {
res.push([...state]);
}
/* 判斷在當前狀態下，該選擇是否合法 */
function isValid(state, choice) {
return choice !== null && choice.val !== 3;
}
/* 更新狀態 */
function makeChoice(state, choice) {
state.push(choice);
}
/* 恢復狀態 */
function undoChoice(state) {
state.pop();
}
/* 回溯演算法：例題三 */
function backtrack(state, choices, res) {
// 檢查是否為解
if (isSolution(state)) {
// 記錄解
recordSolution(state, res);
}
// 走訪所有選擇
for (const choice of choices) {
// 剪枝：檢查選擇是否合法
if (isValid(state, choice)) {
// 嘗試：做出選擇，更新狀態
makeChoice(state, choice);
// 進行下一輪選擇
backtrack(state, [choice.left, choice.right], res);
// 回退：撤銷選擇，恢復到之前的狀態
undoChoice(state);
}
}
}
// Driver Code
const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
console.log('\n初始化二元樹');
printTree(root);
// 回溯演算法
const res = [];
backtrack([], [root], res);
console.log('\n輸出所有根節點到節點 7 的路徑，要求路徑中不包含值為 3 的節點');
res.forEach((path) => {
console.log(path.map((node) => node.val));
});

46
zh-hant/codes/javascript/chapter_backtracking/subset_sum_i.js Normal file
View File

@@ -0,0 +1,46 @@
/**
* File: subset_sum_i.js
* Created Time: 2023-07-30
* Author: yuan0221 (yl1452491917@gmail.com)
*/
/* 回溯演算法：子集和 I */
function backtrack(state, target, choices, start, res) {
// 子集和等於 target 時，記錄解
if (target === 0) {
res.push([...state]);
return;
}
// 走訪所有選擇
// 剪枝二：從 start 開始走訪，避免生成重複子集
for (let i = start; i < choices.length; i++) {
// 剪枝一：若子集和超過 target ，則直接結束迴圈
// 這是因為陣列已排序，後邊元素更大，子集和一定超過 target
if (target - choices[i] < 0) {
break;
}
// 嘗試：做出選擇，更新 target, start
state.push(choices[i]);
// 進行下一輪選擇
backtrack(state, target - choices[i], choices, i, res);
// 回退：撤銷選擇，恢復到之前的狀態
state.pop();
}
}
/* 求解子集和 I */
function subsetSumI(nums, target) {
const state = []; // 狀態（子集）
nums.sort((a, b) => a - b); // 對 nums 進行排序
const start = 0; // 走訪起始點
const res = []; // 結果串列（子集串列）
backtrack(state, target, nums, start, res);
return res;
}
/* Driver Code */
const nums = [3, 4, 5];
const target = 9;
const res = subsetSumI(nums, target);
console.log(`輸入陣列 nums = ${JSON.stringify(nums)}, target = ${target}`);
console.log(`所有和等於 ${target} 的子集 res = ${JSON.stringify(res)}`);

44
zh-hant/codes/javascript/chapter_backtracking/subset_sum_i_naive.js Normal file
View File

@@ -0,0 +1,44 @@
/**
* File: subset_sum_i_naive.js
* Created Time: 2023-07-30
* Author: yuan0221 (yl1452491917@gmail.com)
*/
/* 回溯演算法：子集和 I */
function backtrack(state, target, total, choices, res) {
// 子集和等於 target 時，記錄解
if (total === target) {
res.push([...state]);
return;
}
// 走訪所有選擇
for (let i = 0; i < choices.length; i++) {
// 剪枝：若子集和超過 target ，則跳過該選擇
if (total + choices[i] > target) {
continue;
}
// 嘗試：做出選擇，更新元素和 total
state.push(choices[i]);
// 進行下一輪選擇
backtrack(state, target, total + choices[i], choices, res);
// 回退：撤銷選擇，恢復到之前的狀態
state.pop();
}
}
/* 求解子集和 I（包含重複子集） */
function subsetSumINaive(nums, target) {
const state = []; // 狀態（子集）
const total = 0; // 子集和
const res = []; // 結果串列（子集串列）
backtrack(state, target, total, nums, res);
return res;
}
/* Driver Code */
const nums = [3, 4, 5];
const target = 9;
const res = subsetSumINaive(nums, target);
console.log(`輸入陣列 nums = ${JSON.stringify(nums)}, target = ${target}`);
console.log(`所有和等於 ${target} 的子集 res = ${JSON.stringify(res)}`);
console.log('請注意，該方法輸出的結果包含重複集合');

51
zh-hant/codes/javascript/chapter_backtracking/subset_sum_ii.js Normal file
View File

@@ -0,0 +1,51 @@
/**
* File: subset_sum_ii.js
* Created Time: 2023-07-30
* Author: yuan0221 (yl1452491917@gmail.com)
*/
/* 回溯演算法：子集和 II */
function backtrack(state, target, choices, start, res) {
// 子集和等於 target 時，記錄解
if (target === 0) {
res.push([...state]);
return;
}
// 走訪所有選擇
// 剪枝二：從 start 開始走訪，避免生成重複子集
// 剪枝三：從 start 開始走訪，避免重複選擇同一元素
for (let i = start; i < choices.length; i++) {
// 剪枝一：若子集和超過 target ，則直接結束迴圈
// 這是因為陣列已排序，後邊元素更大，子集和一定超過 target
if (target - choices[i] < 0) {
break;
}
// 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過
if (i > start && choices[i] === choices[i - 1]) {
continue;
}
// 嘗試：做出選擇，更新 target, start
state.push(choices[i]);
// 進行下一輪選擇
backtrack(state, target - choices[i], choices, i + 1, res);
// 回退：撤銷選擇，恢復到之前的狀態
state.pop();
}
}
/* 求解子集和 II */
function subsetSumII(nums, target) {
const state = []; // 狀態（子集）
nums.sort((a, b) => a - b); // 對 nums 進行排序
const start = 0; // 走訪起始點
const res = []; // 結果串列（子集串列）
backtrack(state, target, nums, start, res);
return res;
}
/* Driver Code */
const nums = [4, 4, 5];
const target = 9;
const res = subsetSumII(nums, target);
console.log(`輸入陣列 nums = ${JSON.stringify(nums)}, target = ${target}`);
console.log(`所有和等於 ${target} 的子集 res = ${JSON.stringify(res)}`);

70
zh-hant/codes/javascript/chapter_computational_complexity/iteration.js Normal file
View File

@@ -0,0 +1,70 @@
/**
* File: iteration.js
* Created Time: 2023-08-28
* Author: Gaofer Chou (gaofer-chou@qq.com)
*/
/* for 迴圈 */
function forLoop(n) {
let res = 0;
// 迴圈求和 1, 2, ..., n-1, n
for (let i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* while 迴圈 */
function whileLoop(n) {
let res = 0;
let i = 1; // 初始化條件變數
// 迴圈求和 1, 2, ..., n-1, n
while (i <= n) {
res += i;
i++; // 更新條件變數
}
return res;
}
/* while 迴圈（兩次更新） */
function whileLoopII(n) {
let res = 0;
let i = 1; // 初始化條件變數
// 迴圈求和 1, 4, 10, ...
while (i <= n) {
res += i;
// 更新條件變數
i++;
i *= 2;
}
return res;
}
/* 雙層 for 迴圈 */
function nestedForLoop(n) {
let res = '';
// 迴圈 i = 1, 2, ..., n-1, n
for (let i = 1; i <= n; i++) {
// 迴圈 j = 1, 2, ..., n-1, n
for (let j = 1; j <= n; j++) {
res += `(${i}, ${j}), `;
}
}
return res;
}
/* Driver Code */
const n = 5;
let res;
res = forLoop(n);
console.log(`for 迴圈的求和結果 res = ${res}`);
res = whileLoop(n);
console.log(`while 迴圈的求和結果 res = ${res}`);
res = whileLoopII(n);
console.log(`while 迴圈（兩次更新）求和結果 res = ${res}`);
const resStr = nestedForLoop(n);
console.log(`雙層 for 迴圈的走訪結果 ${resStr}`);

69
zh-hant/codes/javascript/chapter_computational_complexity/recursion.js Normal file
View File

@@ -0,0 +1,69 @@
/**
* File: recursion.js
* Created Time: 2023-08-28
* Author: Gaofer Chou (gaofer-chou@qq.com)
*/
/* 遞迴 */
function recur(n) {
// 終止條件
if (n === 1) return 1;
// 遞：遞迴呼叫
const res = recur(n - 1);
// 迴：返回結果
return n + res;
}
/* 使用迭代模擬遞迴 */
function forLoopRecur(n) {
// 使用一個顯式的堆疊來模擬系統呼叫堆疊
const stack = [];
let res = 0;
// 遞：遞迴呼叫
for (let i = n; i > 0; i--) {
// 透過“入堆疊操作”模擬“遞”
stack.push(i);
}
// 迴：返回結果
while (stack.length) {
// 透過“出堆疊操作”模擬“迴”
res += stack.pop();
}
// res = 1+2+3+...+n
return res;
}
/* 尾遞迴 */
function tailRecur(n, res) {
// 終止條件
if (n === 0) return res;
// 尾遞迴呼叫
return tailRecur(n - 1, res + n);
}
/* 費波那契數列：遞迴 */
function fib(n) {
// 終止條件 f(1) = 0, f(2) = 1
if (n === 1 || n === 2) return n - 1;
// 遞迴呼叫 f(n) = f(n-1) + f(n-2)
const res = fib(n - 1) + fib(n - 2);
// 返回結果 f(n)
return res;
}
/* Driver Code */
const n = 5;
let res;
res = recur(n);
console.log(`遞迴函式的求和結果 res = ${res}`);
res = forLoopRecur(n);
console.log(`使用迭代模擬遞迴的求和結果 res = ${res}`);
res = tailRecur(n, 0);
console.log(`尾遞迴函式的求和結果 res = ${res}`);
res = fib(n);
console.log(`費波那契數列的第 ${n} 項為 ${res}`);

103
zh-hant/codes/javascript/chapter_computational_complexity/space_complexity.js Normal file
View File

@@ -0,0 +1,103 @@
/**
* File: space_complexity.js
* Created Time: 2023-02-05
* Author: Justin (xiefahit@gmail.com)
*/
const { ListNode } = require('../modules/ListNode');
const { TreeNode } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
/* 函式 */
function constFunc() {
// 執行某些操作
return 0;
}
/* 常數階 */
function constant(n) {
// 常數、變數、物件佔用 O(1) 空間
const a = 0;
const b = 0;
const nums = new Array(10000);
const node = new ListNode(0);
// 迴圈中的變數佔用 O(1) 空間
for (let i = 0; i < n; i++) {
const c = 0;
}
// 迴圈中的函式佔用 O(1) 空間
for (let i = 0; i < n; i++) {
constFunc();
}
}
/* 線性階 */
function linear(n) {
// 長度為 n 的陣列佔用 O(n) 空間
const nums = new Array(n);
// 長度為 n 的串列佔用 O(n) 空間
const nodes = [];
for (let i = 0; i < n; i++) {
nodes.push(new ListNode(i));
}
// 長度為 n 的雜湊表佔用 O(n) 空間
const map = new Map();
for (let i = 0; i < n; i++) {
map.set(i, i.toString());
}
}
/* 線性階（遞迴實現） */
function linearRecur(n) {
console.log(`遞迴 n = ${n}`);
if (n === 1) return;
linearRecur(n - 1);
}
/* 平方階 */
function quadratic(n) {
// 矩陣佔用 O(n^2) 空間
const numMatrix = Array(n)
.fill(null)
.map(() => Array(n).fill(null));
// 二維串列佔用 O(n^2) 空間
const numList = [];
for (let i = 0; i < n; i++) {
const tmp = [];
for (let j = 0; j < n; j++) {
tmp.push(0);
}
numList.push(tmp);
}
}
/* 平方階（遞迴實現） */
function quadraticRecur(n) {
if (n <= 0) return 0;
const nums = new Array(n);
console.log(`遞迴 n = ${n} 中的 nums 長度 = ${nums.length}`);
return quadraticRecur(n - 1);
}
/* 指數階（建立滿二元樹） */
function buildTree(n) {
if (n === 0) return null;
const root = new TreeNode(0);
root.left = buildTree(n - 1);
root.right = buildTree(n - 1);
return root;
}
/* Driver Code */
const n = 5;
// 常數階
constant(n);
// 線性階
linear(n);
linearRecur(n);
// 平方階
quadratic(n);
quadraticRecur(n);
// 指數階
const root = buildTree(n);
printTree(root);

155
zh-hant/codes/javascript/chapter_computational_complexity/time_complexity.js Normal file
View File

@@ -0,0 +1,155 @@
/**
* File: time_complexity.js
* Created Time: 2023-01-02
* Author: RiverTwilight (contact@rene.wang)
*/
/* 常數階 */
function constant(n) {
let count = 0;
const size = 100000;
for (let i = 0; i < size; i++) count++;
return count;
}
/* 線性階 */
function linear(n) {
let count = 0;
for (let i = 0; i < n; i++) count++;
return count;
}
/* 線性階（走訪陣列） */
function arrayTraversal(nums) {
let count = 0;
// 迴圈次數與陣列長度成正比
for (let i = 0; i < nums.length; i++) {
count++;
}
return count;
}
/* 平方階 */
function quadratic(n) {
let count = 0;
// 迴圈次數與資料大小 n 成平方關係
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
count++;
}
}
return count;
}
/* 平方階（泡沫排序） */
function bubbleSort(nums) {
let count = 0; // 計數器
// 外迴圈：未排序區間為 [0, i]
for (let i = nums.length - 1; i > 0; i--) {
// 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交換 nums[j] 與 nums[j + 1]
let tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
count += 3; // 元素交換包含 3 個單元操作
}
}
}
return count;
}
/* 指數階（迴圈實現） */
function exponential(n) {
let count = 0,
base = 1;
// 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)
for (let i = 0; i < n; i++) {
for (let j = 0; j < base; j++) {
count++;
}
base *= 2;
}
// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
return count;
}
/* 指數階（遞迴實現） */
function expRecur(n) {
if (n === 1) return 1;
return expRecur(n - 1) + expRecur(n - 1) + 1;
}
/* 對數階（迴圈實現） */
function logarithmic(n) {
let count = 0;
while (n > 1) {
n = n / 2;
count++;
}
return count;
}
/* 對數階（遞迴實現） */
function logRecur(n) {
if (n <= 1) return 0;
return logRecur(n / 2) + 1;
}
/* 線性對數階 */
function linearLogRecur(n) {
if (n <= 1) return 1;
let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
for (let i = 0; i < n; i++) {
count++;
}
return count;
}
/* 階乘階（遞迴實現） */
function factorialRecur(n) {
if (n === 0) return 1;
let count = 0;
// 從 1 個分裂出 n 個
for (let i = 0; i < n; i++) {
count += factorialRecur(n - 1);
}
return count;
}
/* Driver Code */
// 可以修改 n 執行，體會一下各種複雜度的操作數量變化趨勢
const n = 8;
console.log('輸入資料大小 n = ' + n);
let count = constant(n);
console.log('常數階的操作數量 = ' + count);
count = linear(n);
console.log('線性階的操作數量 = ' + count);
count = arrayTraversal(new Array(n));
console.log('線性階（走訪陣列）的操作數量 = ' + count);
count = quadratic(n);
console.log('平方階的操作數量 = ' + count);
let nums = new Array(n);
for (let i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
count = bubbleSort(nums);
console.log('平方階（泡沫排序）的操作數量 = ' + count);
count = exponential(n);
console.log('指數階（迴圈實現）的操作數量 = ' + count);
count = expRecur(n);
console.log('指數階（遞迴實現）的操作數量 = ' + count);
count = logarithmic(n);
console.log('對數階（迴圈實現）的操作數量 = ' + count);
count = logRecur(n);
console.log('對數階（遞迴實現）的操作數量 = ' + count);
count = linearLogRecur(n);
console.log('線性對數階（遞迴實現）的操作數量 = ' + count);
count = factorialRecur(n);
console.log('階乘階（遞迴實現）的操作數量 = ' + count);

43
zh-hant/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js Normal file
View File

@@ -0,0 +1,43 @@
/**
* File: worst_best_time_complexity.js
* Created Time: 2023-01-05
* Author: RiverTwilight (contact@rene.wang)
*/
/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */
function randomNumbers(n) {
const nums = Array(n);
// 生成陣列 nums = { 1, 2, 3, ..., n }
for (let i = 0; i < n; i++) {
nums[i] = i + 1;
}
// 隨機打亂陣列元素
for (let i = 0; i < n; i++) {
const r = Math.floor(Math.random() * (i + 1));
const temp = nums[i];
nums[i] = nums[r];
nums[r] = temp;
}
return nums;
}
/* 查詢陣列 nums 中數字 1 所在索引 */
function findOne(nums) {
for (let i = 0; i < nums.length; i++) {
// 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)
// 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)
if (nums[i] === 1) {
return i;
}
}
return -1;
}
/* Driver Code */
for (let i = 0; i < 10; i++) {
const n = 100;
const nums = randomNumbers(n);
const index = findOne(nums);
console.log('\n陣列 [ 1, 2, ..., n ] 被打亂後 = [' + nums.join(', ') + ']');
console.log('數字 1 的索引為 ' + index);
}

39
zh-hant/codes/javascript/chapter_divide_and_conquer/binary_search_recur.js Normal file
View File

@@ -0,0 +1,39 @@
/**
* File: binary_search_recur.js
* Created Time: 2023-07-30
* Author: yuan0221 (yl1452491917@gmail.com)
*/
/* 二分搜尋：問題 f(i, j) */
function dfs(nums, target, i, j) {
// 若區間為空，代表無目標元素，則返回 -1
if (i > j) {
return -1;
}
// 計算中點索引 m
const m = i + ((j - i) >> 1);
if (nums[m] < target) {
// 遞迴子問題 f(m+1, j)
return dfs(nums, target, m + 1, j);
} else if (nums[m] > target) {
// 遞迴子問題 f(i, m-1)
return dfs(nums, target, i, m - 1);
} else {
// 找到目標元素，返回其索引
return m;
}
}
/* 二分搜尋 */
function binarySearch(nums, target) {
const n = nums.length;
// 求解問題 f(0, n-1)
return dfs(nums, target, 0, n - 1);
}
/* Driver Code */
const target = 6;
const nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
// 二分搜尋（雙閉區間）
const index = binarySearch(nums, target);
console.log(`目標元素 6 的索引 = ${index}`);

44
zh-hant/codes/javascript/chapter_divide_and_conquer/build_tree.js Normal file
View File

@@ -0,0 +1,44 @@
/**
* File: build_tree.js
* Created Time: 2023-07-30
* Author: yuan0221 (yl1452491917@gmail.com)
*/
const { printTree } = require('../modules/PrintUtil');
const { TreeNode } = require('../modules/TreeNode');
/* 構建二元樹：分治 */
function dfs(preorder, inorderMap, i, l, r) {
// 子樹區間為空時終止
if (r - l < 0) return null;
// 初始化根節點
const root = new TreeNode(preorder[i]);
// 查詢 m ，從而劃分左右子樹
const m = inorderMap.get(preorder[i]);
// 子問題：構建左子樹
root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
// 子問題：構建右子樹
root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
// 返回根節點
return root;
}
/* 構建二元樹 */
function buildTree(preorder, inorder) {
// 初始化雜湊表，儲存 inorder 元素到索引的對映
let inorderMap = new Map();
for (let i = 0; i < inorder.length; i++) {
inorderMap.set(inorder[i], i);
}
const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
return root;
}
/* Driver Code */
const preorder = [3, 9, 2, 1, 7];
const inorder = [9, 3, 1, 2, 7];
console.log('前序走訪 = ' + JSON.stringify(preorder));
console.log('中序走訪 = ' + JSON.stringify(inorder));
const root = buildTree(preorder, inorder);
console.log('構建的二元樹為：');
printTree(root);

52
zh-hant/codes/javascript/chapter_divide_and_conquer/hanota.js Normal file
View File

@@ -0,0 +1,52 @@
/**
* File: hanota.js
* Created Time: 2023-07-30
* Author: yuan0221 (yl1452491917@gmail.com)
*/
/* 移動一個圓盤 */
function move(src, tar) {
// 從 src 頂部拿出一個圓盤
const pan = src.pop();
// 將圓盤放入 tar 頂部
tar.push(pan);
}
/* 求解河內塔問題 f(i) */
function dfs(i, src, buf, tar) {
// 若 src 只剩下一個圓盤，則直接將其移到 tar
if (i === 1) {
move(src, tar);
return;
}
// 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf
dfs(i - 1, src, tar, buf);
// 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar
move(src, tar);
// 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar
dfs(i - 1, buf, src, tar);
}
/* 求解河內塔問題 */
function solveHanota(A, B, C) {
const n = A.length;
// 將 A 頂部 n 個圓盤藉助 B 移到 C
dfs(n, A, B, C);
}
/* Driver Code */
// 串列尾部是柱子頂部
const A = [5, 4, 3, 2, 1];
const B = [];
const C = [];
console.log('初始狀態下：');
console.log(`A = ${JSON.stringify(A)}`);
console.log(`B = ${JSON.stringify(B)}`);
console.log(`C = ${JSON.stringify(C)}`);
solveHanota(A, B, C);
console.log('圓盤移動完成後：');
console.log(`A = ${JSON.stringify(A)}`);
console.log(`B = ${JSON.stringify(B)}`);
console.log(`C = ${JSON.stringify(C)}`);

34
zh-hant/codes/javascript/chapter_dynamic_programming/climbing_stairs_backtrack.js Normal file
View File

@@ -0,0 +1,34 @@
/**
* File: climbing_stairs_backtrack.js
* Created Time: 2023-07-26
* Author: yuan0221 (yl1452491917@gmail.com)
*/
/* 回溯 */
function backtrack(choices, state, n, res) {
// 當爬到第 n 階時，方案數量加 1
if (state === n) res.set(0, res.get(0) + 1);
// 走訪所有選擇
for (const choice of choices) {
// 剪枝：不允許越過第 n 階
if (state + choice > n) continue;
// 嘗試：做出選擇，更新狀態
backtrack(choices, state + choice, n, res);
// 回退
}
}
/* 爬樓梯：回溯 */
function climbingStairsBacktrack(n) {
const choices = [1, 2]; // 可選擇向上爬 1 階或 2 階
const state = 0; // 從第 0 階開始爬
const res = new Map();
res.set(0, 0); // 使用 res[0] 記錄方案數量
backtrack(choices, state, n, res);
return res.get(0);
}
/* Driver Code */
const n = 9;
const res = climbingStairsBacktrack(n);
console.log(`爬 ${n} 階樓梯共有 ${res} 種方案`);

30
zh-hant/codes/javascript/chapter_dynamic_programming/climbing_stairs_constraint_dp.js Normal file
View File

@@ -0,0 +1,30 @@
/**
* File: climbing_stairs_constraint_dp.js
* Created Time: 2023-08-23
* Author: Gaofer Chou (gaofer-chou@qq.com)
*/
/* 帶約束爬樓梯：動態規劃 */
function climbingStairsConstraintDP(n) {
if (n === 1 || n === 2) {
return 1;
}
// 初始化 dp 表，用於儲存子問題的解
const dp = Array.from(new Array(n + 1), () => new Array(3));
// 初始狀態：預設最小子問題的解
dp[1][1] = 1;
dp[1][2] = 0;
dp[2][1] = 0;
dp[2][2] = 1;
// 狀態轉移：從較小子問題逐步求解較大子問題
for (let i = 3; i <= n; i++) {
dp[i][1] = dp[i - 1][2];
dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
}
return dp[n][1] + dp[n][2];
}
/* Driver Code */
const n = 9;
const res = climbingStairsConstraintDP(n);
console.log(`爬 ${n} 階樓梯共有 ${res} 種方案`);

24
zh-hant/codes/javascript/chapter_dynamic_programming/climbing_stairs_dfs.js Normal file
View File

@@ -0,0 +1,24 @@
/**
* File: climbing_stairs_dfs.js
* Created Time: 2023-07-26
* Author: yuan0221 (yl1452491917@gmail.com)
*/
/* 搜尋 */
function dfs(i) {
// 已知 dp[1] 和 dp[2] ，返回之
if (i === 1 || i === 2) return i;
// dp[i] = dp[i-1] + dp[i-2]
const count = dfs(i - 1) + dfs(i - 2);
return count;
}
/* 爬樓梯：搜尋 */
function climbingStairsDFS(n) {
return dfs(n);
}
/* Driver Code */
const n = 9;
const res = climbingStairsDFS(n);
console.log(`爬 ${n} 階樓梯共有 ${res} 種方案`);

30
zh-hant/codes/javascript/chapter_dynamic_programming/climbing_stairs_dfs_mem.js Normal file
View File

@@ -0,0 +1,30 @@
/**
* File: climbing_stairs_dfs_mem.js
* Created Time: 2023-07-26
* Author: yuan0221 (yl1452491917@gmail.com)
*/
/* 記憶化搜尋 */
function dfs(i, mem) {
// 已知 dp[1] 和 dp[2] ，返回之
if (i === 1 || i === 2) return i;
// 若存在記錄 dp[i] ，則直接返回之
if (mem[i] != -1) return mem[i];
// dp[i] = dp[i-1] + dp[i-2]
const count = dfs(i - 1, mem) + dfs(i - 2, mem);
// 記錄 dp[i]
mem[i] = count;
return count;
}
/* 爬樓梯：記憶化搜尋 */
function climbingStairsDFSMem(n) {
// mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄
const mem = new Array(n + 1).fill(-1);
return dfs(n, mem);
}
/* Driver Code */
const n = 9;
const res = climbingStairsDFSMem(n);
console.log(`爬 ${n} 階樓梯共有 ${res} 種方案`);

40
zh-hant/codes/javascript/chapter_dynamic_programming/climbing_stairs_dp.js Normal file
View File

@@ -0,0 +1,40 @@
/**
* File: climbing_stairs_dp.js
* Created Time: 2023-07-26
* Author: yuan0221 (yl1452491917@gmail.com)
*/
/* 爬樓梯：動態規劃 */
function climbingStairsDP(n) {
if (n === 1 || n === 2) return n;
// 初始化 dp 表，用於儲存子問題的解
const dp = new Array(n + 1).fill(-1);
// 初始狀態：預設最小子問題的解
dp[1] = 1;
dp[2] = 2;
// 狀態轉移：從較小子問題逐步求解較大子問題
for (let i = 3; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}
/* 爬樓梯：空間最佳化後的動態規劃 */
function climbingStairsDPComp(n) {
if (n === 1 || n === 2) return n;
let a = 1,
b = 2;
for (let i = 3; i <= n; i++) {
const tmp = b;
b = a + b;
a = tmp;
}
return b;
}
/* Driver Code */
const n = 9;
let res = climbingStairsDP(n);
console.log(`爬 ${n} 階樓梯共有 ${res} 種方案`);
res = climbingStairsDPComp(n);
console.log(`爬 ${n} 階樓梯共有 ${res} 種方案`);

66
zh-hant/codes/javascript/chapter_dynamic_programming/coin_change.js Normal file
View File

@@ -0,0 +1,66 @@
/**
* File: coin_change.js
* Created Time: 2023-08-23
* Author: Gaofer Chou (gaofer-chou@qq.com)
*/
/* 零錢兌換：動態規劃 */
function coinChangeDP(coins, amt) {
const n = coins.length;
const MAX = amt + 1;
// 初始化 dp 表
const dp = Array.from({ length: n + 1 }, () =>
Array.from({ length: amt + 1 }, () => 0)
);
// 狀態轉移：首行首列
for (let a = 1; a <= amt; a++) {
dp[0][a] = MAX;
}
// 狀態轉移：其餘行和列
for (let i = 1; i <= n; i++) {
for (let a = 1; a <= amt; a++) {
if (coins[i - 1] > a) {
// 若超過目標金額，則不選硬幣 i
dp[i][a] = dp[i - 1][a];
} else {
// 不選和選硬幣 i 這兩種方案的較小值
dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
}
}
}
return dp[n][amt] !== MAX ? dp[n][amt] : -1;
}
/* 零錢兌換：狀態壓縮後的動態規劃 */
function coinChangeDPComp(coins, amt) {
const n = coins.length;
const MAX = amt + 1;
// 初始化 dp 表
const dp = Array.from({ length: amt + 1 }, () => MAX);
dp[0] = 0;
// 狀態轉移
for (let i = 1; i <= n; i++) {
for (let a = 1; a <= amt; a++) {
if (coins[i - 1] > a) {
// 若超過目標金額，則不選硬幣 i
dp[a] = dp[a];
} else {
// 不選和選硬幣 i 這兩種方案的較小值
dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);
}
}
}
return dp[amt] !== MAX ? dp[amt] : -1;
}
/* Driver Code */
const coins = [1, 2, 5];
const amt = 4;
// 動態規劃
let res = coinChangeDP(coins, amt);
console.log(`湊到目標金額所需的最少硬幣數量為 ${res}`);
// 狀態壓縮後的動態規劃
res = coinChangeDPComp(coins, amt);
console.log(`湊到目標金額所需的最少硬幣數量為 ${res}`);

64
zh-hant/codes/javascript/chapter_dynamic_programming/coin_change_ii.js Normal file
View File

@@ -0,0 +1,64 @@
/**
* File: coin_change_ii.js
* Created Time: 2023-08-23
* Author: Gaofer Chou (gaofer-chou@qq.com)
*/
/* 零錢兌換 II：動態規劃 */
function coinChangeIIDP(coins, amt) {
const n = coins.length;
// 初始化 dp 表
const dp = Array.from({ length: n + 1 }, () =>
Array.from({ length: amt + 1 }, () => 0)
);
// 初始化首列
for (let i = 0; i <= n; i++) {
dp[i][0] = 1;
}
// 狀態轉移
for (let i = 1; i <= n; i++) {
for (let a = 1; a <= amt; a++) {
if (coins[i - 1] > a) {
// 若超過目標金額，則不選硬幣 i
dp[i][a] = dp[i - 1][a];
} else {
// 不選和選硬幣 i 這兩種方案之和
dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];
}
}
}
return dp[n][amt];
}
/* 零錢兌換 II：狀態壓縮後的動態規劃 */
function coinChangeIIDPComp(coins, amt) {
const n = coins.length;
// 初始化 dp 表
const dp = Array.from({ length: amt + 1 }, () => 0);
dp[0] = 1;
// 狀態轉移
for (let i = 1; i <= n; i++) {
for (let a = 1; a <= amt; a++) {
if (coins[i - 1] > a) {
// 若超過目標金額，則不選硬幣 i
dp[a] = dp[a];
} else {
// 不選和選硬幣 i 這兩種方案之和
dp[a] = dp[a] + dp[a - coins[i - 1]];
}
}
}
return dp[amt];
}
/* Driver Code */
const coins = [1, 2, 5];
const amt = 5;
// 動態規劃
let res = coinChangeIIDP(coins, amt);
console.log(`湊出目標金額的硬幣組合數量為 ${res}`);
// 狀態壓縮後的動態規劃
res = coinChangeIIDPComp(coins, amt);
console.log(`湊出目標金額的硬幣組合數量為 ${res}`);

135
zh-hant/codes/javascript/chapter_dynamic_programming/edit_distance.js Normal file
View File

@@ -0,0 +1,135 @@
/**
* File: edit_distance.js
* Created Time: 2023-08-23
* Author: Gaofer Chou (gaofer-chou@qq.com)
*/
/* 編輯距離：暴力搜尋 */
function editDistanceDFS(s, t, i, j) {
// 若 s 和 t 都為空，則返回 0
if (i === 0 && j === 0) return 0;
// 若 s 為空，則返回 t 長度
if (i === 0) return j;
// 若 t 為空，則返回 s 長度
if (j === 0) return i;
// 若兩字元相等，則直接跳過此兩字元
if (s.charAt(i - 1) === t.charAt(j - 1))
return editDistanceDFS(s, t, i - 1, j - 1);
// 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1
const insert = editDistanceDFS(s, t, i, j - 1);
const del = editDistanceDFS(s, t, i - 1, j);
const replace = editDistanceDFS(s, t, i - 1, j - 1);
// 返回最少編輯步數
return Math.min(insert, del, replace) + 1;
}
/* 編輯距離：記憶化搜尋 */
function editDistanceDFSMem(s, t, mem, i, j) {
// 若 s 和 t 都為空，則返回 0
if (i === 0 && j === 0) return 0;
// 若 s 為空，則返回 t 長度
if (i === 0) return j;
// 若 t 為空，則返回 s 長度
if (j === 0) return i;
// 若已有記錄，則直接返回之
if (mem[i][j] !== -1) return mem[i][j];
// 若兩字元相等，則直接跳過此兩字元
if (s.charAt(i - 1) === t.charAt(j - 1))
return editDistanceDFSMem(s, t, mem, i - 1, j - 1);
// 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1
const insert = editDistanceDFSMem(s, t, mem, i, j - 1);
const del = editDistanceDFSMem(s, t, mem, i - 1, j);
const replace = editDistanceDFSMem(s, t, mem, i - 1, j - 1);
// 記錄並返回最少編輯步數
mem[i][j] = Math.min(insert, del, replace) + 1;
return mem[i][j];
}
/* 編輯距離：動態規劃 */
function editDistanceDP(s, t) {
const n = s.length,
m = t.length;
const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
// 狀態轉移：首行首列
for (let i = 1; i <= n; i++) {
dp[i][0] = i;
}
for (let j = 1; j <= m; j++) {
dp[0][j] = j;
}
// 狀態轉移：其餘行和列
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= m; j++) {
if (s.charAt(i - 1) === t.charAt(j - 1)) {
// 若兩字元相等，則直接跳過此兩字元
dp[i][j] = dp[i - 1][j - 1];
} else {
// 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1
dp[i][j] =
Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;
}
}
}
return dp[n][m];
}
/* 編輯距離：狀態壓縮後的動態規劃 */
function editDistanceDPComp(s, t) {
const n = s.length,
m = t.length;
const dp = new Array(m + 1).fill(0);
// 狀態轉移：首行
for (let j = 1; j <= m; j++) {
dp[j] = j;
}
// 狀態轉移：其餘行
for (let i = 1; i <= n; i++) {
// 狀態轉移：首列
let leftup = dp[0]; // 暫存 dp[i-1, j-1]
dp[0] = i;
// 狀態轉移：其餘列
for (let j = 1; j <= m; j++) {
const temp = dp[j];
if (s.charAt(i - 1) === t.charAt(j - 1)) {
// 若兩字元相等，則直接跳過此兩字元
dp[j] = leftup;
} else {
// 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1
dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;
}
leftup = temp; // 更新為下一輪的 dp[i-1, j-1]
}
}
return dp[m];
}
const s = 'bag';
const t = 'pack';
const n = s.length,
m = t.length;
// 暴力搜尋
let res = editDistanceDFS(s, t, n, m);
console.log(`將 ${s} 更改為 ${t} 最少需要編輯 ${res} 步`);
// 記憶化搜尋
const mem = Array.from(new Array(n + 1), () => new Array(m + 1).fill(-1));
res = editDistanceDFSMem(s, t, mem, n, m);
console.log(`將 ${s} 更改為 ${t} 最少需要編輯 ${res} 步`);
// 動態規劃
res = editDistanceDP(s, t);
console.log(`將 ${s} 更改為 ${t} 最少需要編輯 ${res} 步`);
// 狀態壓縮後的動態規劃
res = editDistanceDPComp(s, t);
console.log(`將 ${s} 更改為 ${t} 最少需要編輯 ${res} 步`);

113
zh-hant/codes/javascript/chapter_dynamic_programming/knapsack.js Normal file
View File

@@ -0,0 +1,113 @@
/**
* File: knapsack.js
* Created Time: 2023-08-23
* Author: Gaofer Chou (gaofer-chou@qq.com)
*/
/* 0-1 背包：暴力搜尋 */
function knapsackDFS(wgt, val, i, c) {
// 若已選完所有物品或背包無剩餘容量，則返回價值 0
if (i === 0 || c === 0) {
return 0;
}
// 若超過背包容量，則只能選擇不放入背包
if (wgt[i - 1] > c) {
return knapsackDFS(wgt, val, i - 1, c);
}
// 計算不放入和放入物品 i 的最大價值
const no = knapsackDFS(wgt, val, i - 1, c);
const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];
// 返回兩種方案中價值更大的那一個
return Math.max(no, yes);
}
/* 0-1 背包：記憶化搜尋 */
function knapsackDFSMem(wgt, val, mem, i, c) {
// 若已選完所有物品或背包無剩餘容量，則返回價值 0
if (i === 0 || c === 0) {
return 0;
}
// 若已有記錄，則直接返回
if (mem[i][c] !== -1) {
return mem[i][c];
}
// 若超過背包容量，則只能選擇不放入背包
if (wgt[i - 1] > c) {
return knapsackDFSMem(wgt, val, mem, i - 1, c);
}
// 計算不放入和放入物品 i 的最大價值
const no = knapsackDFSMem(wgt, val, mem, i - 1, c);
const yes =
knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];
// 記錄並返回兩種方案中價值更大的那一個
mem[i][c] = Math.max(no, yes);
return mem[i][c];
}
/* 0-1 背包：動態規劃 */
function knapsackDP(wgt, val, cap) {
const n = wgt.length;
// 初始化 dp 表
const dp = Array(n + 1)
.fill(0)
.map(() => Array(cap + 1).fill(0));
// 狀態轉移
for (let i = 1; i <= n; i++) {
for (let c = 1; c <= cap; c++) {
if (wgt[i - 1] > c) {
// 若超過背包容量，則不選物品 i
dp[i][c] = dp[i - 1][c];
} else {
// 不選和選物品 i 這兩種方案的較大值
dp[i][c] = Math.max(
dp[i - 1][c],
dp[i - 1][c - wgt[i - 1]] + val[i - 1]
);
}
}
}
return dp[n][cap];
}
/* 0-1 背包：狀態壓縮後的動態規劃 */
function knapsackDPComp(wgt, val, cap) {
const n = wgt.length;
// 初始化 dp 表
const dp = Array(cap + 1).fill(0);
// 狀態轉移
for (let i = 1; i <= n; i++) {
// 倒序走訪
for (let c = cap; c >= 1; c--) {
if (wgt[i - 1] <= c) {
// 不選和選物品 i 這兩種方案的較大值
dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
}
}
}
return dp[cap];
}
/* Driver Code */
const wgt = [10, 20, 30, 40, 50];
const val = [50, 120, 150, 210, 240];
const cap = 50;
const n = wgt.length;
// 暴力搜尋
let res = knapsackDFS(wgt, val, n, cap);
console.log(`不超過背包容量的最大物品價值為 ${res}`);
// 記憶化搜尋
const mem = Array.from({ length: n + 1 }, () =>
Array.from({ length: cap + 1 }, () => -1)
);
res = knapsackDFSMem(wgt, val, mem, n, cap);
console.log(`不超過背包容量的最大物品價值為 ${res}`);
// 動態規劃
res = knapsackDP(wgt, val, cap);
console.log(`不超過背包容量的最大物品價值為 ${res}`);
// 狀態壓縮後的動態規劃
res = knapsackDPComp(wgt, val, cap);
console.log(`不超過背包容量的最大物品價值為 ${res}`);

49
zh-hant/codes/javascript/chapter_dynamic_programming/min_cost_climbing_stairs_dp.js Normal file
View File

@@ -0,0 +1,49 @@
/**
* File: min_cost_climbing_stairs_dp.js
* Created Time: 2023-08-23
* Author: Gaofer Chou (gaofer-chou@qq.com)
*/
/* 爬樓梯最小代價：動態規劃 */
function minCostClimbingStairsDP(cost) {
const n = cost.length - 1;
if (n === 1 || n === 2) {
return cost[n];
}
// 初始化 dp 表，用於儲存子問題的解
const dp = new Array(n + 1);
// 初始狀態：預設最小子問題的解
dp[1] = cost[1];
dp[2] = cost[2];
// 狀態轉移：從較小子問題逐步求解較大子問題
for (let i = 3; i <= n; i++) {
dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
}
return dp[n];
}
/* 爬樓梯最小代價：狀態壓縮後的動態規劃 */
function minCostClimbingStairsDPComp(cost) {
const n = cost.length - 1;
if (n === 1 || n === 2) {
return cost[n];
}
let a = cost[1],
b = cost[2];
for (let i = 3; i <= n; i++) {
const tmp = b;
b = Math.min(a, tmp) + cost[i];
a = tmp;
}
return b;
}
/* Driver Code */
const cost = [0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1];
console.log('輸入樓梯的代價串列為：', cost);
let res = minCostClimbingStairsDP(cost);
console.log(`爬完樓梯的最低代價為：${res}`);
res = minCostClimbingStairsDPComp(cost);
console.log(`爬完樓梯的最低代價為：${res}`);

121
zh-hant/codes/javascript/chapter_dynamic_programming/min_path_sum.js Normal file
View File

@@ -0,0 +1,121 @@
/**
* File: min_path_sum.js
* Created Time: 2023-08-23
* Author: Gaofer Chou (gaofer-chou@qq.com)
*/
/* 最小路徑和：暴力搜尋 */
function minPathSumDFS(grid, i, j) {
// 若為左上角單元格，則終止搜尋
if (i === 0 && j === 0) {
return grid[0][0];
}
// 若行列索引越界，則返回 +∞ 代價
if (i < 0 || j < 0) {
return Infinity;
}
// 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價
const up = minPathSumDFS(grid, i - 1, j);
const left = minPathSumDFS(grid, i, j - 1);
// 返回從左上角到 (i, j) 的最小路徑代價
return Math.min(left, up) + grid[i][j];
}
/* 最小路徑和：記憶化搜尋 */
function minPathSumDFSMem(grid, mem, i, j) {
// 若為左上角單元格，則終止搜尋
if (i === 0 && j === 0) {
return grid[0][0];
}
// 若行列索引越界，則返回 +∞ 代價
if (i < 0 || j < 0) {
return Infinity;
}
// 若已有記錄，則直接返回
if (mem[i][j] !== -1) {
return mem[i][j];
}
// 左邊和上邊單元格的最小路徑代價
const up = minPathSumDFSMem(grid, mem, i - 1, j);
const left = minPathSumDFSMem(grid, mem, i, j - 1);
// 記錄並返回左上角到 (i, j) 的最小路徑代價
mem[i][j] = Math.min(left, up) + grid[i][j];
return mem[i][j];
}
/* 最小路徑和：動態規劃 */
function minPathSumDP(grid) {
const n = grid.length,
m = grid[0].length;
// 初始化 dp 表
const dp = Array.from({ length: n }, () =>
Array.from({ length: m }, () => 0)
);
dp[0][0] = grid[0][0];
// 狀態轉移：首行
for (let j = 1; j < m; j++) {
dp[0][j] = dp[0][j - 1] + grid[0][j];
}
// 狀態轉移：首列
for (let i = 1; i < n; i++) {
dp[i][0] = dp[i - 1][0] + grid[i][0];
}
// 狀態轉移：其餘行和列
for (let i = 1; i < n; i++) {
for (let j = 1; j < m; j++) {
dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
}
}
return dp[n - 1][m - 1];
}
/* 最小路徑和：狀態壓縮後的動態規劃 */
function minPathSumDPComp(grid) {
const n = grid.length,
m = grid[0].length;
// 初始化 dp 表
const dp = new Array(m);
// 狀態轉移：首行
dp[0] = grid[0][0];
for (let j = 1; j < m; j++) {
dp[j] = dp[j - 1] + grid[0][j];
}
// 狀態轉移：其餘行
for (let i = 1; i < n; i++) {
// 狀態轉移：首列
dp[0] = dp[0] + grid[i][0];
// 狀態轉移：其餘列
for (let j = 1; j < m; j++) {
dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];
}
}
return dp[m - 1];
}
/* Driver Code */
const grid = [
[1, 3, 1, 5],
[2, 2, 4, 2],
[5, 3, 2, 1],
[4, 3, 5, 2],
];
const n = grid.length,
m = grid[0].length;
// 暴力搜尋
let res = minPathSumDFS(grid, n - 1, m - 1);
console.log(`從左上角到右下角的最小路徑和為 ${res}`);
// 記憶化搜尋
const mem = Array.from({ length: n }, () =>
Array.from({ length: m }, () => -1)
);
res = minPathSumDFSMem(grid, mem, n - 1, m - 1);
console.log(`從左上角到右下角的最小路徑和為 ${res}`);
// 動態規劃
res = minPathSumDP(grid);
console.log(`從左上角到右下角的最小路徑和為 ${res}`);
// 狀態壓縮後的動態規劃
res = minPathSumDPComp(grid);
console.log(`從左上角到右下角的最小路徑和為 ${res}`);

63
zh-hant/codes/javascript/chapter_dynamic_programming/unbounded_knapsack.js Normal file
View File

@@ -0,0 +1,63 @@
/**
* File: unbounded_knapsack.js
* Created Time: 2023-08-23
* Author: Gaofer Chou (gaofer-chou@qq.com)
*/
/* 完全背包：動態規劃 */
function unboundedKnapsackDP(wgt, val, cap) {
const n = wgt.length;
// 初始化 dp 表
const dp = Array.from({ length: n + 1 }, () =>
Array.from({ length: cap + 1 }, () => 0)
);
// 狀態轉移
for (let i = 1; i <= n; i++) {
for (let c = 1; c <= cap; c++) {
if (wgt[i - 1] > c) {
// 若超過背包容量，則不選物品 i
dp[i][c] = dp[i - 1][c];
} else {
// 不選和選物品 i 這兩種方案的較大值
dp[i][c] = Math.max(
dp[i - 1][c],
dp[i][c - wgt[i - 1]] + val[i - 1]
);
}
}
}
return dp[n][cap];
}
/* 完全背包：狀態壓縮後的動態規劃 */
function unboundedKnapsackDPComp(wgt, val, cap) {
const n = wgt.length;
// 初始化 dp 表
const dp = Array.from({ length: cap + 1 }, () => 0);
// 狀態轉移
for (let i = 1; i <= n; i++) {
for (let c = 1; c <= cap; c++) {
if (wgt[i - 1] > c) {
// 若超過背包容量，則不選物品 i
dp[c] = dp[c];
} else {
// 不選和選物品 i 這兩種方案的較大值
dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
}
}
}
return dp[cap];
}
/* Driver Code */
const wgt = [1, 2, 3];
const val = [5, 11, 15];
const cap = 4;
// 動態規劃
let res = unboundedKnapsackDP(wgt, val, cap);
console.log(`不超過背包容量的最大物品價值為 ${res}`);
// 狀態壓縮後的動態規劃
res = unboundedKnapsackDPComp(wgt, val, cap);
console.log(`不超過背包容量的最大物品價值為 ${res}`);

141
zh-hant/codes/javascript/chapter_graph/graph_adjacency_list.js Normal file
View File

@@ -0,0 +1,141 @@
/**
* File: graph_adjacency_list.js
* Created Time: 2023-02-09
* Author: Justin (xiefahit@gmail.com)
*/
const { Vertex } = require('../modules/Vertex');
/* 基於鄰接表實現的無向圖類別 */
class GraphAdjList {
// 鄰接表，key：頂點，value：該頂點的所有鄰接頂點
adjList;
/* 建構子 */
constructor(edges) {
this.adjList = new Map();
// 新增所有頂點和邊
for (const edge of edges) {
this.addVertex(edge[0]);
this.addVertex(edge[1]);
this.addEdge(edge[0], edge[1]);
}
}
/* 獲取頂點數量 */
size() {
return this.adjList.size;
}
/* 新增邊 */
addEdge(vet1, vet2) {
if (
!this.adjList.has(vet1) ||
!this.adjList.has(vet2) ||
vet1 === vet2
) {
throw new Error('Illegal Argument Exception');
}
// 新增邊 vet1 - vet2
this.adjList.get(vet1).push(vet2);
this.adjList.get(vet2).push(vet1);
}
/* 刪除邊 */
removeEdge(vet1, vet2) {
if (
!this.adjList.has(vet1) ||
!this.adjList.has(vet2) ||
vet1 === vet2
) {
throw new Error('Illegal Argument Exception');
}
// 刪除邊 vet1 - vet2
this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);
this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);
}
/* 新增頂點 */
addVertex(vet) {
if (this.adjList.has(vet)) return;
// 在鄰接表中新增一個新鏈結串列
this.adjList.set(vet, []);
}
/* 刪除頂點 */
removeVertex(vet) {
if (!this.adjList.has(vet)) {
throw new Error('Illegal Argument Exception');
}
// 在鄰接表中刪除頂點 vet 對應的鏈結串列
this.adjList.delete(vet);
// 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊
for (const set of this.adjList.values()) {
const index = set.indexOf(vet);
if (index > -1) {
set.splice(index, 1);
}
}
}
/* 列印鄰接表 */
print() {
console.log('鄰接表 =');
for (const [key, value] of this.adjList) {
const tmp = [];
for (const vertex of value) {
tmp.push(vertex.val);
}
console.log(key.val + ': ' + tmp.join());
}
}
}
if (require.main === module) {
/* Driver Code */
/* 初始化無向圖 */
const v0 = new Vertex(1),
v1 = new Vertex(3),
v2 = new Vertex(2),
v3 = new Vertex(5),
v4 = new Vertex(4);
const edges = [
[v0, v1],
[v1, v2],
[v2, v3],
[v0, v3],
[v2, v4],
[v3, v4],
];
const graph = new GraphAdjList(edges);
console.log('\n初始化後，圖為');
graph.print();
/* 新增邊 */
// 頂點 1, 2 即 v0, v2
graph.addEdge(v0, v2);
console.log('\n新增邊 1-2 後，圖為');
graph.print();
/* 刪除邊 */
// 頂點 1, 3 即 v0, v1
graph.removeEdge(v0, v1);
console.log('\n刪除邊 1-3 後，圖為');
graph.print();
/* 新增頂點 */
const v5 = new Vertex(6);
graph.addVertex(v5);
console.log('\n新增頂點 6 後，圖為');
graph.print();
/* 刪除頂點 */
// 頂點 3 即 v1
graph.removeVertex(v1);
console.log('\n刪除頂點 3 後，圖為');
graph.print();
}
module.exports = {
GraphAdjList,
};

132
zh-hant/codes/javascript/chapter_graph/graph_adjacency_matrix.js Normal file
View File

@@ -0,0 +1,132 @@
/**
* File: graph_adjacency_matrix.js
* Created Time: 2023-02-09
* Author: Zhuo Qinyue (1403450829@qq.com)
*/
/* 基於鄰接矩陣實現的無向圖類別 */
class GraphAdjMat {
vertices; // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”
adjMat; // 鄰接矩陣，行列索引對應“頂點索引”
/* 建構子 */
constructor(vertices, edges) {
this.vertices = [];
this.adjMat = [];
// 新增頂點
for (const val of vertices) {
this.addVertex(val);
}
// 新增邊
// 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引
for (const e of edges) {
this.addEdge(e[0], e[1]);
}
}
/* 獲取頂點數量 */
size() {
return this.vertices.length;
}
/* 新增頂點 */
addVertex(val) {
const n = this.size();
// 向頂點串列中新增新頂點的值
this.vertices.push(val);
// 在鄰接矩陣中新增一行
const newRow = [];
for (let j = 0; j < n; j++) {
newRow.push(0);
}
this.adjMat.push(newRow);
// 在鄰接矩陣中新增一列
for (const row of this.adjMat) {
row.push(0);
}
}
/* 刪除頂點 */
removeVertex(index) {
if (index >= this.size()) {
throw new RangeError('Index Out Of Bounds Exception');
}
// 在頂點串列中移除索引 index 的頂點
this.vertices.splice(index, 1);
// 在鄰接矩陣中刪除索引 index 的行
this.adjMat.splice(index, 1);
// 在鄰接矩陣中刪除索引 index 的列
for (const row of this.adjMat) {
row.splice(index, 1);
}
}
/* 新增邊 */
// 參數 i, j 對應 vertices 元素索引
addEdge(i, j) {
// 索引越界與相等處理
if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
throw new RangeError('Index Out Of Bounds Exception');
}
// 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) === (j, i)
this.adjMat[i][j] = 1;
this.adjMat[j][i] = 1;
}
/* 刪除邊 */
// 參數 i, j 對應 vertices 元素索引
removeEdge(i, j) {
// 索引越界與相等處理
if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
throw new RangeError('Index Out Of Bounds Exception');
}
this.adjMat[i][j] = 0;
this.adjMat[j][i] = 0;
}
/* 列印鄰接矩陣 */
print() {
console.log('頂點串列 = ', this.vertices);
console.log('鄰接矩陣 =', this.adjMat);
}
}
/* Driver Code */
/* 初始化無向圖 */
// 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引
const vertices = [1, 3, 2, 5, 4];
const edges = [
[0, 1],
[1, 2],
[2, 3],
[0, 3],
[2, 4],
[3, 4],
];
const graph = new GraphAdjMat(vertices, edges);
console.log('\n初始化後，圖為');
graph.print();
/* 新增邊 */
// 頂點 1, 2 的索引分別為 0, 2
graph.addEdge(0, 2);
console.log('\n新增邊 1-2 後，圖為');
graph.print();
/* 刪除邊 */
// 頂點 1, 3 的索引分別為 0, 1
graph.removeEdge(0, 1);
console.log('\n刪除邊 1-3 後，圖為');
graph.print();
/* 新增頂點 */
graph.addVertex(6);
console.log('\n新增頂點 6 後，圖為');
graph.print();
/* 刪除頂點 */
// 頂點 3 的索引為 1
graph.removeVertex(1);
console.log('\n刪除頂點 3 後，圖為');
graph.print();

61
zh-hant/codes/javascript/chapter_graph/graph_bfs.js Normal file
View File

@@ -0,0 +1,61 @@
/**
* File: graph_bfs.js
* Created Time: 2023-02-21
* Author: Zhuo Qinyue (1403450829@qq.com)
*/
const { GraphAdjList } = require('./graph_adjacency_list');
const { Vertex } = require('../modules/Vertex');
/* 廣度優先走訪 */
// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點
function graphBFS(graph, startVet) {
// 頂點走訪序列
const res = [];
// 雜湊表，用於記錄已被訪問過的頂點
const visited = new Set();
visited.add(startVet);
// 佇列用於實現 BFS
const que = [startVet];
// 以頂點 vet 為起點，迴圈直至訪問完所有頂點
while (que.length) {
const vet = que.shift(); // 佇列首頂點出隊
res.push(vet); // 記錄訪問頂點
// 走訪該頂點的所有鄰接頂點
for (const adjVet of graph.adjList.get(vet) ?? []) {
if (visited.has(adjVet)) {
continue; // 跳過已被訪問的頂點
}
que.push(adjVet); // 只入列未訪問的頂點
visited.add(adjVet); // 標記該頂點已被訪問
}
}
// 返回頂點走訪序列
return res;
}
/* Driver Code */
/* 初始化無向圖 */
const v = Vertex.valsToVets([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
const edges = [
[v[0], v[1]],
[v[0], v[3]],
[v[1], v[2]],
[v[1], v[4]],
[v[2], v[5]],
[v[3], v[4]],
[v[3], v[6]],
[v[4], v[5]],
[v[4], v[7]],
[v[5], v[8]],
[v[6], v[7]],
[v[7], v[8]],
];
const graph = new GraphAdjList(edges);
console.log('\n初始化後，圖為');
graph.print();
/* 廣度優先走訪 */
const res = graphBFS(graph, v[0]);
console.log('\n廣度優先走訪（BFS）頂點序列為');
console.log(Vertex.vetsToVals(res));

54
zh-hant/codes/javascript/chapter_graph/graph_dfs.js Normal file
View File

@@ -0,0 +1,54 @@
/**
* File: graph_dfs.js
* Created Time: 2023-02-21
* Author: Zhuo Qinyue (1403450829@qq.com)
*/
const { Vertex } = require('../modules/Vertex');
const { GraphAdjList } = require('./graph_adjacency_list');
/* 深度優先走訪 */
// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點
function dfs(graph, visited, res, vet) {
res.push(vet); // 記錄訪問頂點
visited.add(vet); // 標記該頂點已被訪問
// 走訪該頂點的所有鄰接頂點
for (const adjVet of graph.adjList.get(vet)) {
if (visited.has(adjVet)) {
continue; // 跳過已被訪問的頂點
}
// 遞迴訪問鄰接頂點
dfs(graph, visited, res, adjVet);
}
}
/* 深度優先走訪 */
// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點
function graphDFS(graph, startVet) {
// 頂點走訪序列
const res = [];
// 雜湊表，用於記錄已被訪問過的頂點
const visited = new Set();
dfs(graph, visited, res, startVet);
return res;
}
/* Driver Code */
/* 初始化無向圖 */
const v = Vertex.valsToVets([0, 1, 2, 3, 4, 5, 6]);
const edges = [
[v[0], v[1]],
[v[0], v[3]],
[v[1], v[2]],
[v[2], v[5]],
[v[4], v[5]],
[v[5], v[6]],
];
const graph = new GraphAdjList(edges);
console.log('\n初始化後，圖為');
graph.print();
/* 深度優先走訪 */
const res = graphDFS(graph, v[0]);
console.log('\n深度優先走訪（DFS）頂點序列為');
console.log(Vertex.vetsToVals(res));

48
zh-hant/codes/javascript/chapter_greedy/coin_change_greedy.js Normal file
View File

@@ -0,0 +1,48 @@
/**
* File: coin_change_greedy.js
* Created Time: 2023-09-02
* Author: Justin (xiefahit@gmail.com)
*/
/* 零錢兌換：貪婪 */
function coinChangeGreedy(coins, amt) {
// 假設 coins 陣列有序
let i = coins.length - 1;
let count = 0;
// 迴圈進行貪婪選擇，直到無剩餘金額
while (amt > 0) {
// 找到小於且最接近剩餘金額的硬幣
while (i > 0 && coins[i] > amt) {
i--;
}
// 選擇 coins[i]
amt -= coins[i];
count++;
}
// 若未找到可行方案，則返回 -1
return amt === 0 ? count : -1;
}
/* Driver Code */
// 貪婪：能夠保證找到全域性最優解
let coins = [1, 5, 10, 20, 50, 100];
let amt = 186;
let res = coinChangeGreedy(coins, amt);
console.log(`\ncoins = ${coins}, amt = ${amt}`);
console.log(`湊到 ${amt} 所需的最少硬幣數量為 ${res}`);
// 貪婪：無法保證找到全域性最優解
coins = [1, 20, 50];
amt = 60;
res = coinChangeGreedy(coins, amt);
console.log(`\ncoins = ${coins}, amt = ${amt}`);
console.log(`湊到 ${amt} 所需的最少硬幣數量為 ${res}`);
console.log('實際上需要的最少數量為 3 ，即 20 + 20 + 20');
// 貪婪：無法保證找到全域性最優解
coins = [1, 49, 50];
amt = 98;
res = coinChangeGreedy(coins, amt);
console.log(`\ncoins = ${coins}, amt = ${amt}`);
console.log(`湊到 ${amt} 所需的最少硬幣數量為 ${res}`);
console.log('實際上需要的最少數量為 2 ，即 49 + 49');

46
zh-hant/codes/javascript/chapter_greedy/fractional_knapsack.js Normal file
View File

@@ -0,0 +1,46 @@
/**
* File: fractional_knapsack.js
* Created Time: 2023-09-02
* Author: Justin (xiefahit@gmail.com)
*/
/* 物品 */
class Item {
constructor(w, v) {
this.w = w; // 物品重量
this.v = v; // 物品價值
}
}
/* 分數背包：貪婪 */
function fractionalKnapsack(wgt, val, cap) {
// 建立物品串列，包含兩個屬性：重量、價值
const items = wgt.map((w, i) => new Item(w, val[i]));
// 按照單位價值 item.v / item.w 從高到低進行排序
items.sort((a, b) => b.v / b.w - a.v / a.w);
// 迴圈貪婪選擇
let res = 0;
for (const item of items) {
if (item.w <= cap) {
// 若剩餘容量充足，則將當前物品整個裝進背包
res += item.v;
cap -= item.w;
} else {
// 若剩餘容量不足，則將當前物品的一部分裝進背包
res += (item.v / item.w) * cap;
// 已無剩餘容量，因此跳出迴圈
break;
}
}
return res;
}
/* Driver Code */
const wgt = [10, 20, 30, 40, 50];
const val = [50, 120, 150, 210, 240];
const cap = 50;
const n = wgt.length;
// 貪婪演算法
const res = fractionalKnapsack(wgt, val, cap);
console.log(`不超過背包容量的最大物品價值為 ${res}`);

34
zh-hant/codes/javascript/chapter_greedy/max_capacity.js Normal file
View File

@@ -0,0 +1,34 @@
/**
* File: max_capacity.js
* Created Time: 2023-09-02
* Author: Justin (xiefahit@gmail.com)
*/
/* 最大容量：貪婪 */
function maxCapacity(ht) {
// 初始化 i, j，使其分列陣列兩端
let i = 0,
j = ht.length - 1;
// 初始最大容量為 0
let res = 0;
// 迴圈貪婪選擇，直至兩板相遇
while (i < j) {
// 更新最大容量
const cap = Math.min(ht[i], ht[j]) * (j - i);
res = Math.max(res, cap);
// 向內移動短板
if (ht[i] < ht[j]) {
i += 1;
} else {
j -= 1;
}
}
return res;
}
/* Driver Code */
const ht = [3, 8, 5, 2, 7, 7, 3, 4];
// 貪婪演算法
const res = maxCapacity(ht);
console.log(`最大容量為 ${res}`);

33
zh-hant/codes/javascript/chapter_greedy/max_product_cutting.js Normal file
View File

@@ -0,0 +1,33 @@
/**
* File: max_product_cutting.js
* Created Time: 2023-09-02
* Author: Justin (xiefahit@gmail.com)
*/
/* 最大切分乘積：貪婪 */
function maxProductCutting(n) {
// 當 n <= 3 時，必須切分出一個 1
if (n <= 3) {
return 1 * (n - 1);
}
// 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數
let a = Math.floor(n / 3);
let b = n % 3;
if (b === 1) {
// 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2
return Math.pow(3, a - 1) * 2 * 2;
}
if (b === 2) {
// 當餘數為 2 時，不做處理
return Math.pow(3, a) * 2;
}
// 當餘數為 0 時，不做處理
return Math.pow(3, a);
}
/* Driver Code */
let n = 58;
// 貪婪演算法
let res = maxProductCutting(n);
console.log(`最大切分乘積為 ${res}`);

128
zh-hant/codes/javascript/chapter_hashing/array_hash_map.js Normal file
View File

@@ -0,0 +1,128 @@
/**
* File: array_hash_map.js
* Created Time: 2022-12-26
* Author: Justin (xiefahit@gmail.com)
*/
/* 鍵值對 Number -> String */
class Pair {
constructor(key, val) {
this.key = key;
this.val = val;
}
}
/* 基於陣列實現的雜湊表 */
class ArrayHashMap {
#buckets;
constructor() {
// 初始化陣列，包含 100 個桶
this.#buckets = new Array(100).fill(null);
}
/* 雜湊函式 */
#hashFunc(key) {
return key % 100;
}
/* 查詢操作 */
get(key) {
let index = this.#hashFunc(key);
let pair = this.#buckets[index];
if (pair === null) return null;
return pair.val;
}
/* 新增操作 */
set(key, val) {
let index = this.#hashFunc(key);
this.#buckets[index] = new Pair(key, val);
}
/* 刪除操作 */
delete(key) {
let index = this.#hashFunc(key);
// 置為 null ，代表刪除
this.#buckets[index] = null;
}
/* 獲取所有鍵值對 */
entries() {
let arr = [];
for (let i = 0; i < this.#buckets.length; i++) {
if (this.#buckets[i]) {
arr.push(this.#buckets[i]);
}
}
return arr;
}
/* 獲取所有鍵 */
keys() {
let arr = [];
for (let i = 0; i < this.#buckets.length; i++) {
if (this.#buckets[i]) {
arr.push(this.#buckets[i].key);
}
}
return arr;
}
/* 獲取所有值 */
values() {
let arr = [];
for (let i = 0; i < this.#buckets.length; i++) {
if (this.#buckets[i]) {
arr.push(this.#buckets[i].val);
}
}
return arr;
}
/* 列印雜湊表 */
print() {
let pairSet = this.entries();
for (const pair of pairSet) {
console.info(`${pair.key} -> ${pair.val}`);
}
}
}
/* Driver Code */
/* 初始化雜湊表 */
const map = new ArrayHashMap();
/* 新增操作 */
// 在雜湊表中新增鍵值對 (key, value)
map.set(12836, '小哈');
map.set(15937, '小囉');
map.set(16750, '小算');
map.set(13276, '小法');
map.set(10583, '小鴨');
console.info('\n新增完成後，雜湊表為\nKey -> Value');
map.print();
/* 查詢操作 */
// 向雜湊表中輸入鍵 key ，得到值 value
let name = map.get(15937);
console.info('\n輸入學號 15937 ，查詢到姓名 ' + name);
/* 刪除操作 */
// 在雜湊表中刪除鍵值對 (key, value)
map.delete(10583);
console.info('\n刪除 10583 後，雜湊表為\nKey -> Value');
map.print();
/* 走訪雜湊表 */
console.info('\n走訪鍵值對 Key->Value');
for (const pair of map.entries()) {
if (!pair) continue;
console.info(pair.key + ' -> ' + pair.val);
}
console.info('\n單獨走訪鍵 Key');
for (const key of map.keys()) {
console.info(key);
}
console.info('\n單獨走訪值 Value');
for (const val of map.values()) {
console.info(val);
}

44
zh-hant/codes/javascript/chapter_hashing/hash_map.js Normal file
View File

@@ -0,0 +1,44 @@
/**
* File: hash_map.js
* Created Time: 2022-12-26
* Author: Justin (xiefahit@gmail.com)
*/
/* Driver Code */
/* 初始化雜湊表 */
const map = new Map();
/* 新增操作 */
// 在雜湊表中新增鍵值對 (key, value)
map.set(12836, '小哈');
map.set(15937, '小囉');
map.set(16750, '小算');
map.set(13276, '小法');
map.set(10583, '小鴨');
console.info('\n新增完成後，雜湊表為\nKey -> Value');
console.info(map);
/* 查詢操作 */
// 向雜湊表中輸入鍵 key ，得到值 value
let name = map.get(15937);
console.info('\n輸入學號 15937 ，查詢到姓名 ' + name);
/* 刪除操作 */
// 在雜湊表中刪除鍵值對 (key, value)
map.delete(10583);
console.info('\n刪除 10583 後，雜湊表為\nKey -> Value');
console.info(map);
/* 走訪雜湊表 */
console.info('\n走訪鍵值對 Key->Value');
for (const [k, v] of map.entries()) {
console.info(k + ' -> ' + v);
}
console.info('\n單獨走訪鍵 Key');
for (const k of map.keys()) {
console.info(k);
}
console.info('\n單獨走訪值 Value');
for (const v of map.values()) {
console.info(v);
}

142
zh-hant/codes/javascript/chapter_hashing/hash_map_chaining.js Normal file
View File

@@ -0,0 +1,142 @@
/**
* File: hash_map_chaining.js
* Created Time: 2023-08-06
* Author: yuan0221 (yl1452491917@gmail.com)
*/
/* 鍵值對 Number -> String */
class Pair {
constructor(key, val) {
this.key = key;
this.val = val;
}
}
/* 鏈式位址雜湊表 */
class HashMapChaining {
#size; // 鍵值對數量
#capacity; // 雜湊表容量
#loadThres; // 觸發擴容的負載因子閾值
#extendRatio; // 擴容倍數
#buckets; // 桶陣列
/* 建構子 */
constructor() {
this.#size = 0;
this.#capacity = 4;
this.#loadThres = 2.0 / 3.0;
this.#extendRatio = 2;
this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);
}
/* 雜湊函式 */
#hashFunc(key) {
return key % this.#capacity;
}
/* 負載因子 */
#loadFactor() {
return this.#size / this.#capacity;
}
/* 查詢操作 */
get(key) {
const index = this.#hashFunc(key);
const bucket = this.#buckets[index];
// 走訪桶，若找到 key ，則返回對應 val
for (const pair of bucket) {
if (pair.key === key) {
return pair.val;
}
}
// 若未找到 key ，則返回 null
return null;
}
/* 新增操作 */
put(key, val) {
// 當負載因子超過閾值時，執行擴容
if (this.#loadFactor() > this.#loadThres) {
this.#extend();
}
const index = this.#hashFunc(key);
const bucket = this.#buckets[index];
// 走訪桶，若遇到指定 key ，則更新對應 val 並返回
for (const pair of bucket) {
if (pair.key === key) {
pair.val = val;
return;
}
}
// 若無該 key ，則將鍵值對新增至尾部
const pair = new Pair(key, val);
bucket.push(pair);
this.#size++;
}
/* 刪除操作 */
remove(key) {
const index = this.#hashFunc(key);
let bucket = this.#buckets[index];
// 走訪桶，從中刪除鍵值對
for (let i = 0; i < bucket.length; i++) {
if (bucket[i].key === key) {
bucket.splice(i, 1);
this.#size--;
break;
}
}
}
/* 擴容雜湊表 */
#extend() {
// 暫存原雜湊表
const bucketsTmp = this.#buckets;
// 初始化擴容後的新雜湊表
this.#capacity *= this.#extendRatio;
this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);
this.#size = 0;
// 將鍵值對從原雜湊表搬運至新雜湊表
for (const bucket of bucketsTmp) {
for (const pair of bucket) {
this.put(pair.key, pair.val);
}
}
}
/* 列印雜湊表 */
print() {
for (const bucket of this.#buckets) {
let res = [];
for (const pair of bucket) {
res.push(pair.key + ' -> ' + pair.val);
}
console.log(res);
}
}
}
/* Driver Code */
/* 初始化雜湊表 */
const map = new HashMapChaining();
/* 新增操作 */
// 在雜湊表中新增鍵值對 (key, value)
map.put(12836, '小哈');
map.put(15937, '小囉');
map.put(16750, '小算');
map.put(13276, '小法');
map.put(10583, '小鴨');
console.log('\n新增完成後，雜湊表為\nKey -> Value');
map.print();
/* 查詢操作 */
// 向雜湊表中輸入鍵 key ，得到值 value
const name = map.get(13276);
console.log('\n輸入學號 13276 ，查詢到姓名 ' + name);
/* 刪除操作 */
// 在雜湊表中刪除鍵值對 (key, value)
map.remove(12836);
console.log('\n刪除 12836 後，雜湊表為\nKey -> Value');
map.print();

177
zh-hant/codes/javascript/chapter_hashing/hash_map_open_addressing.js Normal file
View File

@@ -0,0 +1,177 @@
/**
* File: hashMapOpenAddressing.js
* Created Time: 2023-06-13
* Author: yuan0221 (yl1452491917@gmail.com), krahets (krahets@163.com)
*/
/* 鍵值對 Number -> String */
class Pair {
constructor(key, val) {
this.key = key;
this.val = val;
}
}
/* 開放定址雜湊表 */
class HashMapOpenAddressing {
#size; // 鍵值對數量
#capacity; // 雜湊表容量
#loadThres; // 觸發擴容的負載因子閾值
#extendRatio; // 擴容倍數
#buckets; // 桶陣列
#TOMBSTONE; // 刪除標記
/* 建構子 */
constructor() {
this.#size = 0; // 鍵值對數量
this.#capacity = 4; // 雜湊表容量
this.#loadThres = 2.0 / 3.0; // 觸發擴容的負載因子閾值
this.#extendRatio = 2; // 擴容倍數
this.#buckets = Array(this.#capacity).fill(null); // 桶陣列
this.#TOMBSTONE = new Pair(-1, '-1'); // 刪除標記
}
/* 雜湊函式 */
#hashFunc(key) {
return key % this.#capacity;
}
/* 負載因子 */
#loadFactor() {
return this.#size / this.#capacity;
}
/* 搜尋 key 對應的桶索引 */
#findBucket(key) {
let index = this.#hashFunc(key);
let firstTombstone = -1;
// 線性探查，當遇到空桶時跳出
while (this.#buckets[index] !== null) {
// 若遇到 key ，返回對應的桶索引
if (this.#buckets[index].key === key) {
// 若之前遇到了刪除標記，則將鍵值對移動至該索引處
if (firstTombstone !== -1) {
this.#buckets[firstTombstone] = this.#buckets[index];
this.#buckets[index] = this.#TOMBSTONE;
return firstTombstone; // 返回移動後的桶索引
}
return index; // 返回桶索引
}
// 記錄遇到的首個刪除標記
if (
firstTombstone === -1 &&
this.#buckets[index] === this.#TOMBSTONE
) {
firstTombstone = index;
}
// 計算桶索引，越過尾部則返回頭部
index = (index + 1) % this.#capacity;
}
// 若 key 不存在，則返回新增點的索引
return firstTombstone === -1 ? index : firstTombstone;
}
/* 查詢操作 */
get(key) {
// 搜尋 key 對應的桶索引
const index = this.#findBucket(key);
// 若找到鍵值對，則返回對應 val
if (
this.#buckets[index] !== null &&
this.#buckets[index] !== this.#TOMBSTONE
) {
return this.#buckets[index].val;
}
// 若鍵值對不存在，則返回 null
return null;
}
/* 新增操作 */
put(key, val) {
// 當負載因子超過閾值時，執行擴容
if (this.#loadFactor() > this.#loadThres) {
this.#extend();
}
// 搜尋 key 對應的桶索引
const index = this.#findBucket(key);
// 若找到鍵值對，則覆蓋 val 並返回
if (
this.#buckets[index] !== null &&
this.#buckets[index] !== this.#TOMBSTONE
) {
this.#buckets[index].val = val;
return;
}
// 若鍵值對不存在，則新增該鍵值對
this.#buckets[index] = new Pair(key, val);
this.#size++;
}
/* 刪除操作 */
remove(key) {
// 搜尋 key 對應的桶索引
const index = this.#findBucket(key);
// 若找到鍵值對，則用刪除標記覆蓋它
if (
this.#buckets[index] !== null &&
this.#buckets[index] !== this.#TOMBSTONE
) {
this.#buckets[index] = this.#TOMBSTONE;
this.#size--;
}
}
/* 擴容雜湊表 */
#extend() {
// 暫存原雜湊表
const bucketsTmp = this.#buckets;
// 初始化擴容後的新雜湊表
this.#capacity *= this.#extendRatio;
this.#buckets = Array(this.#capacity).fill(null);
this.#size = 0;
// 將鍵值對從原雜湊表搬運至新雜湊表
for (const pair of bucketsTmp) {
if (pair !== null && pair !== this.#TOMBSTONE) {
this.put(pair.key, pair.val);
}
}
}
/* 列印雜湊表 */
print() {
for (const pair of this.#buckets) {
if (pair === null) {
console.log('null');
} else if (pair === this.#TOMBSTONE) {
console.log('TOMBSTONE');
} else {
console.log(pair.key + ' -> ' + pair.val);
}
}
}
}
/* Driver Code */
// 初始化雜湊表
const hashmap = new HashMapOpenAddressing();
// 新增操作
// 在雜湊表中新增鍵值對 (key, val)
hashmap.put(12836, '小哈');
hashmap.put(15937, '小囉');
hashmap.put(16750, '小算');
hashmap.put(13276, '小法');
hashmap.put(10583, '小鴨');
console.log('\n新增完成後，雜湊表為\nKey -> Value');
hashmap.print();
// 查詢操作
// 向雜湊表中輸入鍵 key ，得到值 val
const name = hashmap.get(13276);
console.log('\n輸入學號 13276 ，查詢到姓名 ' + name);
// 刪除操作
// 在雜湊表中刪除鍵值對 (key, val)
hashmap.remove(16750);
console.log('\n刪除 16750 後，雜湊表為\nKey -> Value');
hashmap.print();

60
zh-hant/codes/javascript/chapter_hashing/simple_hash.js Normal file
View File

@@ -0,0 +1,60 @@
/**
* File: simple_hash.js
* Created Time: 2023-08-06
* Author: yuan0221 (yl1452491917@gmail.com)
*/
/* 加法雜湊 */
function addHash(key) {
let hash = 0;
const MODULUS = 1000000007;
for (const c of key) {
hash = (hash + c.charCodeAt(0)) % MODULUS;
}
return hash;
}
/* 乘法雜湊 */
function mulHash(key) {
let hash = 0;
const MODULUS = 1000000007;
for (const c of key) {
hash = (31 * hash + c.charCodeAt(0)) % MODULUS;
}
return hash;
}
/* 互斥或雜湊 */
function xorHash(key) {
let hash = 0;
const MODULUS = 1000000007;
for (const c of key) {
hash ^= c.charCodeAt(0);
}
return hash & MODULUS;
}
/* 旋轉雜湊 */
function rotHash(key) {
let hash = 0;
const MODULUS = 1000000007;
for (const c of key) {
hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;
}
return hash;
}
/* Driver Code */
const key = 'Hello 演算法';
let hash = addHash(key);
console.log('加法雜湊值為 ' + hash);
hash = mulHash(key);
console.log('乘法雜湊值為 ' + hash);
hash = xorHash(key);
console.log('互斥或雜湊值為 ' + hash);
hash = rotHash(key);
console.log('旋轉雜湊值為 ' + hash);

158
zh-hant/codes/javascript/chapter_heap/my_heap.js Normal file
View File

@@ -0,0 +1,158 @@
/**
* File: my_heap.js
* Created Time: 2023-02-06
* Author: what-is-me (whatisme@outlook.jp)
*/
const { printHeap } = require('../modules/PrintUtil');
/* 最大堆積類別 */
class MaxHeap {
#maxHeap;
/* 建構子，建立空堆積或根據輸入串列建堆積 */
constructor(nums) {
// 將串列元素原封不動新增進堆積
this.#maxHeap = nums === undefined ? [] : [...nums];
// 堆積化除葉節點以外的其他所有節點
for (let i = this.#parent(this.size() - 1); i >= 0; i--) {
this.#siftDown(i);
}
}
/* 獲取左子節點的索引 */
#left(i) {
return 2 * i + 1;
}
/* 獲取右子節點的索引 */
#right(i) {
return 2 * i + 2;
}
/* 獲取父節點的索引 */
#parent(i) {
return Math.floor((i - 1) / 2); // 向下整除
}
/* 交換元素 */
#swap(i, j) {
const tmp = this.#maxHeap[i];
this.#maxHeap[i] = this.#maxHeap[j];
this.#maxHeap[j] = tmp;
}
/* 獲取堆積大小 */
size() {
return this.#maxHeap.length;
}
/* 判斷堆積是否為空 */
isEmpty() {
return this.size() === 0;
}
/* 訪問堆積頂元素 */
peek() {
return this.#maxHeap[0];
}
/* 元素入堆積 */
push(val) {
// 新增節點
this.#maxHeap.push(val);
// 從底至頂堆積化
this.#siftUp(this.size() - 1);
}
/* 從節點 i 開始，從底至頂堆積化 */
#siftUp(i) {
while (true) {
// 獲取節點 i 的父節點
const p = this.#parent(i);
// 當“越過根節點”或“節點無須修復”時，結束堆積化
if (p < 0 || this.#maxHeap[i] <= this.#maxHeap[p]) break;
// 交換兩節點
this.#swap(i, p);
// 迴圈向上堆積化
i = p;
}
}
/* 元素出堆積 */
pop() {
// 判空處理
if (this.isEmpty()) throw new Error('堆積為空');
// 交換根節點與最右葉節點（交換首元素與尾元素）
this.#swap(0, this.size() - 1);
// 刪除節點
const val = this.#maxHeap.pop();
// 從頂至底堆積化
this.#siftDown(0);
// 返回堆積頂元素
return val;
}
/* 從節點 i 開始，從頂至底堆積化 */
#siftDown(i) {
while (true) {
// 判斷節點 i, l, r 中值最大的節點，記為 ma
const l = this.#left(i),
r = this.#right(i);
let ma = i;
if (l < this.size() && this.#maxHeap[l] > this.#maxHeap[ma]) ma = l;
if (r < this.size() && this.#maxHeap[r] > this.#maxHeap[ma]) ma = r;
// 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出
if (ma === i) break;
// 交換兩節點
this.#swap(i, ma);
// 迴圈向下堆積化
i = ma;
}
}
/* 列印堆積（二元樹） */
print() {
printHeap(this.#maxHeap);
}
/* 取出堆積中元素 */
getMaxHeap() {
return this.#maxHeap;
}
}
/* Driver Code */
if (require.main === module) {
/* 初始化大頂堆積 */
const maxHeap = new MaxHeap([9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2]);
console.log('\n輸入串列並建堆積後');
maxHeap.print();
/* 獲取堆積頂元素 */
let peek = maxHeap.peek();
console.log(`\n堆積頂元素為 ${peek}`);
/* 元素入堆積 */
let val = 7;
maxHeap.push(val);
console.log(`\n元素 ${val} 入堆積後`);
maxHeap.print();
/* 堆積頂元素出堆積 */
peek = maxHeap.pop();
console.log(`\n堆積頂元素 ${peek} 出堆積後`);
maxHeap.print();
/* 獲取堆積大小 */
let size = maxHeap.size();
console.log(`\n堆積元素數量為 ${size}`);
/* 判斷堆積是否為空 */
let isEmpty = maxHeap.isEmpty();
console.log(`\n堆積是否為空 ${isEmpty}`);
}
module.exports = {
MaxHeap,
};

58
zh-hant/codes/javascript/chapter_heap/top_k.js Normal file
View File

@@ -0,0 +1,58 @@
/**
* File: top_k.js
* Created Time: 2023-08-13
* Author: Justin (xiefahit@gmail.com)
*/
const { MaxHeap } = require('./my_heap');
/* 元素入堆積 */
function pushMinHeap(maxHeap, val) {
// 元素取反
maxHeap.push(-val);
}
/* 元素出堆積 */
function popMinHeap(maxHeap) {
// 元素取反
return -maxHeap.pop();
}
/* 訪問堆積頂元素 */
function peekMinHeap(maxHeap) {
// 元素取反
return -maxHeap.peek();
}
/* 取出堆積中元素 */
function getMinHeap(maxHeap) {
// 元素取反
return maxHeap.getMaxHeap().map((num) => -num);
}
/* 基於堆積查詢陣列中最大的 k 個元素 */
function topKHeap(nums, k) {
// 初始化小頂堆積
// 請注意：我們將堆積中所有元素取反，從而用大頂堆積來模擬小頂堆積
const maxHeap = new MaxHeap([]);
// 將陣列的前 k 個元素入堆積
for (let i = 0; i < k; i++) {
pushMinHeap(maxHeap, nums[i]);
}
// 從第 k+1 個元素開始，保持堆積的長度為 k
for (let i = k; i < nums.length; i++) {
// 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
if (nums[i] > peekMinHeap(maxHeap)) {
popMinHeap(maxHeap);
pushMinHeap(maxHeap, nums[i]);
}
}
// 返回堆積中元素
return getMinHeap(maxHeap);
}
/* Driver Code */
const nums = [1, 7, 6, 3, 2];
const k = 3;
const res = topKHeap(nums, k);
console.log(`最大的 ${k} 個元素為`, res);

60
zh-hant/codes/javascript/chapter_searching/binary_search.js Normal file
View File

@@ -0,0 +1,60 @@
/**
* File: binary_search.js
* Created Time: 2022-12-22
* Author: JoseHung (szhong@link.cuhk.edu.hk)
*/
/* 二分搜尋（雙閉區間） */
function binarySearch(nums, target) {
// 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素
let i = 0,
j = nums.length - 1;
// 迴圈，當搜尋區間為空時跳出（當 i > j 時為空）
while (i <= j) {
// 計算中點索引 m ，使用 parseInt() 向下取整
const m = parseInt(i + (j - i) / 2);
if (nums[m] < target)
// 此情況說明 target 在區間 [m+1, j] 中
i = m + 1;
else if (nums[m] > target)
// 此情況說明 target 在區間 [i, m-1] 中
j = m - 1;
else return m; // 找到目標元素，返回其索引
}
// 未找到目標元素，返回 -1
return -1;
}
/* 二分搜尋（左閉右開區間） */
function binarySearchLCRO(nums, target) {
// 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1
let i = 0,
j = nums.length;
// 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）
while (i < j) {
// 計算中點索引 m ，使用 parseInt() 向下取整
const m = parseInt(i + (j - i) / 2);
if (nums[m] < target)
// 此情況說明 target 在區間 [m+1, j) 中
i = m + 1;
else if (nums[m] > target)
// 此情況說明 target 在區間 [i, m) 中
j = m;
// 找到目標元素，返回其索引
else return m;
}
// 未找到目標元素，返回 -1
return -1;
}
/* Driver Code */
const target = 6;
const nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
/* 二分搜尋（雙閉區間） */
let index = binarySearch(nums, target);
console.log('目標元素 6 的索引 = ' + index);
/* 二分搜尋（左閉右開區間） */
index = binarySearchLCRO(nums, target);
console.log('目標元素 6 的索引 = ' + index);

45
zh-hant/codes/javascript/chapter_searching/binary_search_edge.js Normal file
View File

@@ -0,0 +1,45 @@
/**
* File: binary_search_edge.js
* Created Time: 2023-08-22
* Author: Gaofer Chou (gaofer-chou@qq.com)
*/
const { binarySearchInsertion } = require('./binary_search_insertion.js');
/* 二分搜尋最左一個 target */
function binarySearchLeftEdge(nums, target) {
// 等價於查詢 target 的插入點
const i = binarySearchInsertion(nums, target);
// 未找到 target ，返回 -1
if (i === nums.length || nums[i] !== target) {
return -1;
}
// 找到 target ，返回索引 i
return i;
}
/* 二分搜尋最右一個 target */
function binarySearchRightEdge(nums, target) {
// 轉化為查詢最左一個 target + 1
const i = binarySearchInsertion(nums, target + 1);
// j 指向最右一個 target ，i 指向首個大於 target 的元素
const j = i - 1;
// 未找到 target ，返回 -1
if (j === -1 || nums[j] !== target) {
return -1;
}
// 找到 target ，返回索引 j
return j;
}
/* Driver Code */
// 包含重複元素的陣列
const nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15];
console.log('\n陣列 nums = ' + nums);
// 二分搜尋左邊界和右邊界
for (const target of [6, 7]) {
let index = binarySearchLeftEdge(nums, target);
console.log('最左一個元素 ' + target + ' 的索引為 ' + index);
index = binarySearchRightEdge(nums, target);
console.log('最右一個元素 ' + target + ' 的索引為 ' + index);
}

64
zh-hant/codes/javascript/chapter_searching/binary_search_insertion.js Normal file
View File

@@ -0,0 +1,64 @@
/**
* File: binary_search_insertion.js
* Created Time: 2023-08-22
* Author: Gaofer Chou (gaofer-chou@qq.com)
*/
/* 二分搜尋插入點（無重複元素） */
function binarySearchInsertionSimple(nums, target) {
let i = 0,
j = nums.length - 1; // 初始化雙閉區間 [0, n-1]
while (i <= j) {
const m = Math.floor(i + (j - i) / 2); // 計算中點索引 m, 使用 Math.floor() 向下取整
if (nums[m] < target) {
i = m + 1; // target 在區間 [m+1, j] 中
} else if (nums[m] > target) {
j = m - 1; // target 在區間 [i, m-1] 中
} else {
return m; // 找到 target ，返回插入點 m
}
}
// 未找到 target ，返回插入點 i
return i;
}
/* 二分搜尋插入點（存在重複元素） */
function binarySearchInsertion(nums, target) {
let i = 0,
j = nums.length - 1; // 初始化雙閉區間 [0, n-1]
while (i <= j) {
const m = Math.floor(i + (j - i) / 2); // 計算中點索引 m, 使用 Math.floor() 向下取整
if (nums[m] < target) {
i = m + 1; // target 在區間 [m+1, j] 中
} else if (nums[m] > target) {
j = m - 1; // target 在區間 [i, m-1] 中
} else {
j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中
}
}
// 返回插入點 i
return i;
}
/* Driver Code */
// 無重複元素的陣列
let nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
console.log('\n陣列 nums = ' + nums);
// 二分搜尋插入點
for (const target of [6, 9]) {
const index = binarySearchInsertionSimple(nums, target);
console.log('元素 ' + target + ' 的插入點的索引為 ' + index);
}
// 包含重複元素的陣列
nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15];
console.log('\n陣列 nums = ' + nums);
// 二分搜尋插入點
for (const target of [2, 6, 20]) {
const index = binarySearchInsertion(nums, target);
console.log('元素 ' + target + ' 的插入點的索引為 ' + index);
}
module.exports = {
binarySearchInsertion,
};

45
zh-hant/codes/javascript/chapter_searching/hashing_search.js Normal file
View File

@@ -0,0 +1,45 @@
/**
* File: hashing_search.js
* Created Time: 2022-12-29
* Author: Zhuo Qinyue (1403450829@qq.com)
*/
const { arrToLinkedList } = require('../modules/ListNode');
/* 雜湊查詢（陣列） */
function hashingSearchArray(map, target) {
// 雜湊表的 key: 目標元素，value: 索引
// 若雜湊表中無此 key ，返回 -1
return map.has(target) ? map.get(target) : -1;
}
/* 雜湊查詢（鏈結串列） */
function hashingSearchLinkedList(map, target) {
// 雜湊表的 key: 目標節點值，value: 節點物件
// 若雜湊表中無此 key ，返回 null
return map.has(target) ? map.get(target) : null;
}
/* Driver Code */
const target = 3;
/* 雜湊查詢（陣列） */
const nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
// 初始化雜湊表
const map = new Map();
for (let i = 0; i < nums.length; i++) {
map.set(nums[i], i); // key: 元素，value: 索引
}
const index = hashingSearchArray(map, target);
console.log('目標元素 3 的索引 = ' + index);
/* 雜湊查詢（鏈結串列） */
let head = arrToLinkedList(nums);
// 初始化雜湊表
const map1 = new Map();
while (head != null) {
map1.set(head.val, head); // key: 節點值，value: 節點
head = head.next;
}
const node = hashingSearchLinkedList(map1, target);
console.log('目標節點值 3 的對應節點物件為', node);

47
zh-hant/codes/javascript/chapter_searching/linear_search.js Normal file
View File

@@ -0,0 +1,47 @@
/**
* File: linear_search.js
* Created Time: 2022-12-22
* Author: JoseHung (szhong@link.cuhk.edu.hk)
*/
const { ListNode, arrToLinkedList } = require('../modules/ListNode');
/* 線性查詢（陣列） */
function linearSearchArray(nums, target) {
// 走訪陣列
for (let i = 0; i < nums.length; i++) {
// 找到目標元素，返回其索引
if (nums[i] === target) {
return i;
}
}
// 未找到目標元素，返回 -1
return -1;
}
/* 線性查詢（鏈結串列）*/
function linearSearchLinkedList(head, target) {
// 走訪鏈結串列
while (head) {
// 找到目標節點，返回之
if (head.val === target) {
return head;
}
head = head.next;
}
// 未找到目標節點，返回 null
return null;
}
/* Driver Code */
const target = 3;
/* 在陣列中執行線性查詢 */
const nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
const index = linearSearchArray(nums, target);
console.log('目標元素 3 的索引 = ' + index);
/* 在鏈結串列中執行線性查詢 */
const head = arrToLinkedList(nums);
const node = linearSearchLinkedList(head, target);
console.log('目標節點值 3 的對應節點物件為 ', node);

46
zh-hant/codes/javascript/chapter_searching/two_sum.js Normal file
View File

@@ -0,0 +1,46 @@
/**
* File: two_sum.js
* Created Time: 2022-12-15
* Author: gyt95 (gytkwan@gmail.com)
*/
/* 方法一：暴力列舉 */
function twoSumBruteForce(nums, target) {
const n = nums.length;
// 兩層迴圈，時間複雜度為 O(n^2)
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i, j];
}
}
}
return [];
}
/* 方法二：輔助雜湊表 */
function twoSumHashTable(nums, target) {
// 輔助雜湊表，空間複雜度為 O(n)
let m = {};
// 單層迴圈，時間複雜度為 O(n)
for (let i = 0; i < nums.length; i++) {
if (m[target - nums[i]] !== undefined) {
return [m[target - nums[i]], i];
} else {
m[nums[i]] = i;
}
}
return [];
}
/* Driver Code */
// 方法一
const nums = [2, 7, 11, 15],
target = 13;
let res = twoSumBruteForce(nums, target);
console.log('方法一 res = ', res);
// 方法二
res = twoSumHashTable(nums, target);
console.log('方法二 res = ', res);

49
zh-hant/codes/javascript/chapter_sorting/bubble_sort.js Normal file
View File

@@ -0,0 +1,49 @@
/**
* File: bubble_sort.js
* Created Time: 2022-12-01
* Author: IsChristina (christinaxia77@foxmail.com)
*/
/* 泡沫排序 */
function bubbleSort(nums) {
// 外迴圈：未排序區間為 [0, i]
for (let i = nums.length - 1; i > 0; i--) {
// 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交換 nums[j] 與 nums[j + 1]
let tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
}
}
}
}
/* 泡沫排序（標誌最佳化）*/
function bubbleSortWithFlag(nums) {
// 外迴圈：未排序區間為 [0, i]
for (let i = nums.length - 1; i > 0; i--) {
let flag = false; // 初始化標誌位
// 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交換 nums[j] 與 nums[j + 1]
let tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
flag = true; // 記錄交換元素
}
}
if (!flag) break; // 此輪“冒泡”未交換任何元素，直接跳出
}
}
/* Driver Code */
const nums = [4, 1, 3, 1, 5, 2];
bubbleSort(nums);
console.log('泡沫排序完成後 nums =', nums);
const nums1 = [4, 1, 3, 1, 5, 2];
bubbleSortWithFlag(nums1);
console.log('泡沫排序完成後 nums =', nums1);

39
zh-hant/codes/javascript/chapter_sorting/bucket_sort.js Normal file
View File

@@ -0,0 +1,39 @@
/**
* File: bucket_sort.js
* Created Time: 2023-04-08
* Author: Justin (xiefahit@gmail.com)
*/
/* 桶排序 */
function bucketSort(nums) {
// 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素
const k = nums.length / 2;
const buckets = [];
for (let i = 0; i < k; i++) {
buckets.push([]);
}
// 1. 將陣列元素分配到各個桶中
for (const num of nums) {
// 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]
const i = Math.floor(num * k);
// 將 num 新增進桶 i
buckets[i].push(num);
}
// 2. 對各個桶執行排序
for (const bucket of buckets) {
// 使用內建排序函式，也可以替換成其他排序演算法
bucket.sort((a, b) => a - b);
}
// 3. 走訪桶合併結果
let i = 0;
for (const bucket of buckets) {
for (const num of bucket) {
nums[i++] = num;
}
}
}
/* Driver Code */
const nums = [0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37];
bucketSort(nums);
console.log('桶排序完成後 nums =', nums);

71
zh-hant/codes/javascript/chapter_sorting/counting_sort.js Normal file
View File

@@ -0,0 +1,71 @@
/**
* File: counting_sort.js
* Created Time: 2023-04-08
* Author: Justin (xiefahit@gmail.com)
*/
/* 計數排序 */
// 簡單實現，無法用於排序物件
function countingSortNaive(nums) {
// 1. 統計陣列最大元素 m
let m = 0;
for (const num of nums) {
m = Math.max(m, num);
}
// 2. 統計各數字的出現次數
// counter[num] 代表 num 的出現次數
const counter = new Array(m + 1).fill(0);
for (const num of nums) {
counter[num]++;
}
// 3. 走訪 counter ，將各元素填入原陣列 nums
let i = 0;
for (let num = 0; num < m + 1; num++) {
for (let j = 0; j < counter[num]; j++, i++) {
nums[i] = num;
}
}
}
/* 計數排序 */
// 完整實現，可排序物件，並且是穩定排序
function countingSort(nums) {
// 1. 統計陣列最大元素 m
let m = 0;
for (const num of nums) {
m = Math.max(m, num);
}
// 2. 統計各數字的出現次數
// counter[num] 代表 num 的出現次數
const counter = new Array(m + 1).fill(0);
for (const num of nums) {
counter[num]++;
}
// 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”
// 即 counter[num]-1 是 num 在 res 中最後一次出現的索引
for (let i = 0; i < m; i++) {
counter[i + 1] += counter[i];
}
// 4. 倒序走訪 nums ，將各元素填入結果陣列 res
// 初始化陣列 res 用於記錄結果
const n = nums.length;
const res = new Array(n);
for (let i = n - 1; i >= 0; i--) {
const num = nums[i];
res[counter[num] - 1] = num; // 將 num 放置到對應索引處
counter[num]--; // 令前綴和自減 1 ，得到下次放置 num 的索引
}
// 使用結果陣列 res 覆蓋原陣列 nums
for (let i = 0; i < n; i++) {
nums[i] = res[i];
}
}
/* Driver Code */
const nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
countingSortNaive(nums);
console.log('計數排序（無法排序物件）完成後 nums =', nums);
const nums1 = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
countingSort(nums1);
console.log('計數排序完成後 nums1 =', nums1);

49
zh-hant/codes/javascript/chapter_sorting/heap_sort.js Normal file
View File

@@ -0,0 +1,49 @@
/**
* File: heap_sort.js
* Created Time: 2023-06-04
* Author: Justin (xiefahit@gmail.com)
*/
/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */
function siftDown(nums, n, i) {
while (true) {
// 判斷節點 i, l, r 中值最大的節點，記為 ma
let l = 2 * i + 1;
let r = 2 * i + 2;
let ma = i;
if (l < n && nums[l] > nums[ma]) {
ma = l;
}
if (r < n && nums[r] > nums[ma]) {
ma = r;
}
// 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出
if (ma === i) {
break;
}
// 交換兩節點
[nums[i], nums[ma]] = [nums[ma], nums[i]];
// 迴圈向下堆積化
i = ma;
}
}
/* 堆積排序 */
function heapSort(nums) {
// 建堆積操作：堆積化除葉節點以外的其他所有節點
for (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {
siftDown(nums, nums.length, i);
}
// 從堆積中提取最大元素，迴圈 n-1 輪
for (let i = nums.length - 1; i > 0; i--) {
// 交換根節點與最右葉節點（交換首元素與尾元素）
[nums[0], nums[i]] = [nums[i], nums[0]];
// 以根節點為起點，從頂至底進行堆積化
siftDown(nums, i, 0);
}
}
/* Driver Code */
const nums = [4, 1, 3, 1, 5, 2];
heapSort(nums);
console.log('堆積排序完成後 nums =', nums);

25
zh-hant/codes/javascript/chapter_sorting/insertion_sort.js Normal file
View File

@@ -0,0 +1,25 @@
/**
* File: insertion_sort.js
* Created Time: 2022-12-01
* Author: IsChristina (christinaxia77@foxmail.com)
*/
/* 插入排序 */
function insertionSort(nums) {
// 外迴圈：已排序區間為 [0, i-1]
for (let i = 1; i < nums.length; i++) {
let base = nums[i],
j = i - 1;
// 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 將 nums[j] 向右移動一位
j--;
}
nums[j + 1] = base; // 將 base 賦值到正確位置
}
}
/* Driver Code */
const nums = [4, 1, 3, 1, 5, 2];
insertionSort(nums);
console.log('插入排序完成後 nums =', nums);

52
zh-hant/codes/javascript/chapter_sorting/merge_sort.js Normal file
View File

@@ -0,0 +1,52 @@
/**
* File: merge_sort.js
* Created Time: 2022-12-01
* Author: IsChristina (christinaxia77@foxmail.com)
*/
/* 合併左子陣列和右子陣列 */
function merge(nums, left, mid, right) {
// 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]
// 建立一個臨時陣列 tmp ，用於存放合併後的結果
const tmp = new Array(right - left + 1);
// 初始化左子陣列和右子陣列的起始索引
let i = left,
j = mid + 1,
k = 0;
// 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中
while (i <= mid && j <= right) {
if (nums[i] <= nums[j]) {
tmp[k++] = nums[i++];
} else {
tmp[k++] = nums[j++];
}
}
// 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中
while (i <= mid) {
tmp[k++] = nums[i++];
}
while (j <= right) {
tmp[k++] = nums[j++];
}
// 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間
for (k = 0; k < tmp.length; k++) {
nums[left + k] = tmp[k];
}
}
/* 合併排序 */
function mergeSort(nums, left, right) {
// 終止條件
if (left >= right) return; // 當子陣列長度為 1 時終止遞迴
// 劃分階段
let mid = Math.floor((left + right) / 2); // 計算中點
mergeSort(nums, left, mid); // 遞迴左子陣列
mergeSort(nums, mid + 1, right); // 遞迴右子陣列
// 合併階段
merge(nums, left, mid, right);
}
/* Driver Code */
const nums = [7, 3, 2, 6, 0, 1, 5, 4];
mergeSort(nums, 0, nums.length - 1);
console.log('合併排序完成後 nums =', nums);

161
zh-hant/codes/javascript/chapter_sorting/quick_sort.js Normal file
View File

@@ -0,0 +1,161 @@
/**
* File: quick_sort.js
* Created Time: 2022-12-01
* Author: IsChristina (christinaxia77@foxmail.com)
*/
/* 快速排序類別 */
class QuickSort {
/* 元素交換 */
swap(nums, i, j) {
let tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 哨兵劃分 */
partition(nums, left, right) {
// 以 nums[left] 為基準數
let i = left,
j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left]) {
j -= 1; // 從右向左找首個小於基準數的元素
}
while (i < j && nums[i] <= nums[left]) {
i += 1; // 從左向右找首個大於基準數的元素
}
// 元素交換
this.swap(nums, i, j); // 交換這兩個元素
}
this.swap(nums, i, left); // 將基準數交換至兩子陣列的分界線
return i; // 返回基準數的索引
}
/* 快速排序 */
quickSort(nums, left, right) {
// 子陣列長度為 1 時終止遞迴
if (left >= right) return;
// 哨兵劃分
const pivot = this.partition(nums, left, right);
// 遞迴左子陣列、右子陣列
this.quickSort(nums, left, pivot - 1);
this.quickSort(nums, pivot + 1, right);
}
}
/* 快速排序類別（中位基準數最佳化） */
class QuickSortMedian {
/* 元素交換 */
swap(nums, i, j) {
let tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 選取三個候選元素的中位數 */
medianThree(nums, left, mid, right) {
let l = nums[left],
m = nums[mid],
r = nums[right];
// m 在 l 和 r 之間
if ((l <= m && m <= r) || (r <= m && m <= l)) return mid;
// l 在 m 和 r 之間
if ((m <= l && l <= r) || (r <= l && l <= m)) return left;
return right;
}
/* 哨兵劃分（三數取中值） */
partition(nums, left, right) {
// 選取三個候選元素的中位數
let med = this.medianThree(
nums,
left,
Math.floor((left + right) / 2),
right
);
// 將中位數交換至陣列最左端
this.swap(nums, left, med);
// 以 nums[left] 為基準數
let i = left,
j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left]) j--; // 從右向左找首個小於基準數的元素
while (i < j && nums[i] <= nums[left]) i++; // 從左向右找首個大於基準數的元素
this.swap(nums, i, j); // 交換這兩個元素
}
this.swap(nums, i, left); // 將基準數交換至兩子陣列的分界線
return i; // 返回基準數的索引
}
/* 快速排序 */
quickSort(nums, left, right) {
// 子陣列長度為 1 時終止遞迴
if (left >= right) return;
// 哨兵劃分
const pivot = this.partition(nums, left, right);
// 遞迴左子陣列、右子陣列
this.quickSort(nums, left, pivot - 1);
this.quickSort(nums, pivot + 1, right);
}
}
/* 快速排序類別（尾遞迴最佳化） */
class QuickSortTailCall {
/* 元素交換 */
swap(nums, i, j) {
let tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 哨兵劃分 */
partition(nums, left, right) {
// 以 nums[left] 為基準數
let i = left,
j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left]) j--; // 從右向左找首個小於基準數的元素
while (i < j && nums[i] <= nums[left]) i++; // 從左向右找首個大於基準數的元素
this.swap(nums, i, j); // 交換這兩個元素
}
this.swap(nums, i, left); // 將基準數交換至兩子陣列的分界線
return i; // 返回基準數的索引
}
/* 快速排序（尾遞迴最佳化） */
quickSort(nums, left, right) {
// 子陣列長度為 1 時終止
while (left < right) {
// 哨兵劃分操作
let pivot = this.partition(nums, left, right);
// 對兩個子陣列中較短的那個執行快速排序
if (pivot - left < right - pivot) {
this.quickSort(nums, left, pivot - 1); // 遞迴排序左子陣列
left = pivot + 1; // 剩餘未排序區間為 [pivot + 1, right]
} else {
this.quickSort(nums, pivot + 1, right); // 遞迴排序右子陣列
right = pivot - 1; // 剩餘未排序區間為 [left, pivot - 1]
}
}
}
}
/* Driver Code */
/* 快速排序 */
const nums = [2, 4, 1, 0, 3, 5];
const quickSort = new QuickSort();
quickSort.quickSort(nums, 0, nums.length - 1);
console.log('快速排序完成後 nums =', nums);
/* 快速排序（中位基準數最佳化） */
const nums1 = [2, 4, 1, 0, 3, 5];
const quickSortMedian = new QuickSortMedian();
quickSortMedian.quickSort(nums1, 0, nums1.length - 1);
console.log('快速排序（中位基準數最佳化）完成後 nums =', nums1);
/* 快速排序（尾遞迴最佳化） */
const nums2 = [2, 4, 1, 0, 3, 5];
const quickSortTailCall = new QuickSortTailCall();
quickSortTailCall.quickSort(nums2, 0, nums2.length - 1);
console.log('快速排序（尾遞迴最佳化）完成後 nums =', nums2);

66
zh-hant/codes/javascript/chapter_sorting/radix_sort.js Normal file
View File

@@ -0,0 +1,66 @@
/**
* File: radix_sort.js
* Created Time: 2023-04-08
* Author: Justin (xiefahit@gmail.com)
*/
/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */
function digit(num, exp) {
// 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算
return Math.floor(num / exp) % 10;
}
/* 計數排序（根據 nums 第 k 位排序） */
function countingSortDigit(nums, exp) {
// 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列
const counter = new Array(10).fill(0);
const n = nums.length;
// 統計 0~9 各數字的出現次數
for (let i = 0; i < n; i++) {
const d = digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d
counter[d]++; // 統計數字 d 的出現次數
}
// 求前綴和，將“出現個數”轉換為“陣列索引”
for (let i = 1; i < 10; i++) {
counter[i] += counter[i - 1];
}
// 倒序走訪，根據桶內統計結果，將各元素填入 res
const res = new Array(n).fill(0);
for (let i = n - 1; i >= 0; i--) {
const d = digit(nums[i], exp);
const j = counter[d] - 1; // 獲取 d 在陣列中的索引 j
res[j] = nums[i]; // 將當前元素填入索引 j
counter[d]--; // 將 d 的數量減 1
}
// 使用結果覆蓋原陣列 nums
for (let i = 0; i < n; i++) {
nums[i] = res[i];
}
}
/* 基數排序 */
function radixSort(nums) {
// 獲取陣列的最大元素，用於判斷最大位數
let m = Number.MIN_VALUE;
for (const num of nums) {
if (num > m) {
m = num;
}
}
// 按照從低位到高位的順序走訪
for (let exp = 1; exp <= m; exp *= 10) {
// 對陣列元素的第 k 位執行計數排序
// k = 1 -> exp = 1
// k = 2 -> exp = 10
// 即 exp = 10^(k-1)
countingSortDigit(nums, exp);
}
}
/* Driver Code */
const nums = [
10546151, 35663510, 42865989, 34862445, 81883077, 88906420, 72429244,
30524779, 82060337, 63832996,
];
radixSort(nums);
console.log('基數排序完成後 nums =', nums);

27
zh-hant/codes/javascript/chapter_sorting/selection_sort.js Normal file
View File

@@ -0,0 +1,27 @@
/**
* File: selection_sort.js
* Created Time: 2023-06-04
* Author: Justin (xiefahit@gmail.com)
*/
/* 選擇排序 */
function selectionSort(nums) {
let n = nums.length;
// 外迴圈：未排序區間為 [i, n-1]
for (let i = 0; i < n - 1; i++) {
// 內迴圈：找到未排序區間內的最小元素
let k = i;
for (let j = i + 1; j < n; j++) {
if (nums[j] < nums[k]) {
k = j; // 記錄最小元素的索引
}
}
// 將該最小元素與未排序區間的首個元素交換
[nums[i], nums[k]] = [nums[k], nums[i]];
}
}
/* Driver Code */
const nums = [4, 1, 3, 1, 5, 2];
selectionSort(nums);
console.log('選擇排序完成後 nums =', nums);

156
zh-hant/codes/javascript/chapter_stack_and_queue/array_deque.js Normal file
View File

@@ -0,0 +1,156 @@
/**
* File: array_deque.js
* Created Time: 2023-02-28
* Author: Zhuo Qinyue (1403450829@qq.com)
*/
/* 基於環形陣列實現的雙向佇列 */
class ArrayDeque {
#nums; // 用於儲存雙向佇列元素的陣列
#front; // 佇列首指標，指向佇列首元素
#queSize; // 雙向佇列長度
/* 建構子 */
constructor(capacity) {
this.#nums = new Array(capacity);
this.#front = 0;
this.#queSize = 0;
}
/* 獲取雙向佇列的容量 */
capacity() {
return this.#nums.length;
}
/* 獲取雙向佇列的長度 */
size() {
return this.#queSize;
}
/* 判斷雙向佇列是否為空 */
isEmpty() {
return this.#queSize === 0;
}
/* 計算環形陣列索引 */
index(i) {
// 透過取餘操作實現陣列首尾相連
// 當 i 越過陣列尾部後，回到頭部
// 當 i 越過陣列頭部後，回到尾部
return (i + this.capacity()) % this.capacity();
}
/* 佇列首入列 */
pushFirst(num) {
if (this.#queSize === this.capacity()) {
console.log('雙向佇列已滿');
return;
}
// 佇列首指標向左移動一位
// 透過取餘操作實現 front 越過陣列頭部後回到尾部
this.#front = this.index(this.#front - 1);
// 將 num 新增至佇列首
this.#nums[this.#front] = num;
this.#queSize++;
}
/* 佇列尾入列 */
pushLast(num) {
if (this.#queSize === this.capacity()) {
console.log('雙向佇列已滿');
return;
}
// 計算佇列尾指標，指向佇列尾索引 + 1
const rear = this.index(this.#front + this.#queSize);
// 將 num 新增至佇列尾
this.#nums[rear] = num;
this.#queSize++;
}
/* 佇列首出列 */
popFirst() {
const num = this.peekFirst();
// 佇列首指標向後移動一位
this.#front = this.index(this.#front + 1);
this.#queSize--;
return num;
}
/* 佇列尾出列 */
popLast() {
const num = this.peekLast();
this.#queSize--;
return num;
}
/* 訪問佇列首元素 */
peekFirst() {
if (this.isEmpty()) throw new Error('The Deque Is Empty.');
return this.#nums[this.#front];
}
/* 訪問佇列尾元素 */
peekLast() {
if (this.isEmpty()) throw new Error('The Deque Is Empty.');
// 計算尾元素索引
const last = this.index(this.#front + this.#queSize - 1);
return this.#nums[last];
}
/* 返回陣列用於列印 */
toArray() {
// 僅轉換有效長度範圍內的串列元素
const res = [];
for (let i = 0, j = this.#front; i < this.#queSize; i++, j++) {
res[i] = this.#nums[this.index(j)];
}
return res;
}
}
/* Driver Code */
/* 初始化雙向佇列 */
const capacity = 5;
const deque = new ArrayDeque(capacity);
deque.pushLast(3);
deque.pushLast(2);
deque.pushLast(5);
console.log('雙向佇列 deque = [' + deque.toArray() + ']');
/* 訪問元素 */
const peekFirst = deque.peekFirst();
console.log('佇列首元素 peekFirst = ' + peekFirst);
const peekLast = deque.peekLast();
console.log('佇列尾元素 peekLast = ' + peekLast);
/* 元素入列 */
deque.pushLast(4);
console.log('元素 4 佇列尾入列後 deque = [' + deque.toArray() + ']');
deque.pushFirst(1);
console.log('元素 1 佇列首入列後 deque = [' + deque.toArray() + ']');
/* 元素出列 */
const popLast = deque.popLast();
console.log(
'佇列尾出列元素 = ' +
popLast +
'，佇列尾出列後 deque = [' +
deque.toArray() +
']'
);
const popFirst = deque.popFirst();
console.log(
'佇列首出列元素 = ' +
popFirst +
'，佇列首出列後 deque = [' +
deque.toArray() +
']'
);
/* 獲取雙向佇列的長度 */
const size = deque.size();
console.log('雙向佇列長度 size = ' + size);
/* 判斷雙向佇列是否為空 */
const isEmpty = deque.isEmpty();
console.log('雙向佇列是否為空 = ' + isEmpty);

106
zh-hant/codes/javascript/chapter_stack_and_queue/array_queue.js Normal file
View File

@@ -0,0 +1,106 @@
/**
* File: array_queue.js
* Created Time: 2022-12-13
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
*/
/* 基於環形陣列實現的佇列 */
class ArrayQueue {
#nums; // 用於儲存佇列元素的陣列
#front = 0; // 佇列首指標，指向佇列首元素
#queSize = 0; // 佇列長度
constructor(capacity) {
this.#nums = new Array(capacity);
}
/* 獲取佇列的容量 */
get capacity() {
return this.#nums.length;
}
/* 獲取佇列的長度 */
get size() {
return this.#queSize;
}
/* 判斷佇列是否為空 */
isEmpty() {
return this.#queSize === 0;
}
/* 入列 */
push(num) {
if (this.size === this.capacity) {
console.log('佇列已滿');
return;
}
// 計算佇列尾指標，指向佇列尾索引 + 1
// 透過取餘操作實現 rear 越過陣列尾部後回到頭部
const rear = (this.#front + this.size) % this.capacity;
// 將 num 新增至佇列尾
this.#nums[rear] = num;
this.#queSize++;
}
/* 出列 */
pop() {
const num = this.peek();
// 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部
this.#front = (this.#front + 1) % this.capacity;
this.#queSize--;
return num;
}
/* 訪問佇列首元素 */
peek() {
if (this.isEmpty()) throw new Error('佇列為空');
return this.#nums[this.#front];
}
/* 返回 Array */
toArray() {
// 僅轉換有效長度範圍內的串列元素
const arr = new Array(this.size);
for (let i = 0, j = this.#front; i < this.size; i++, j++) {
arr[i] = this.#nums[j % this.capacity];
}
return arr;
}
}
/* Driver Code */
/* 初始化佇列 */
const capacity = 10;
const queue = new ArrayQueue(capacity);
/* 元素入列 */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);
console.log('佇列 queue =', queue.toArray());
/* 訪問佇列首元素 */
const peek = queue.peek();
console.log('佇列首元素 peek = ' + peek);
/* 元素出列 */
const pop = queue.pop();
console.log('出列元素 pop = ' + pop + '，出列後 queue =', queue.toArray());
/* 獲取佇列的長度 */
const size = queue.size;
console.log('佇列長度 size = ' + size);
/* 判斷佇列是否為空 */
const isEmpty = queue.isEmpty();
console.log('佇列是否為空 = ' + isEmpty);
/* 測試環形陣列 */
for (let i = 0; i < 10; i++) {
queue.push(i);
queue.pop();
console.log('第 ' + i + ' 輪入列 + 出列後 queue =', queue.toArray());
}

75
zh-hant/codes/javascript/chapter_stack_and_queue/array_stack.js Normal file
View File

@@ -0,0 +1,75 @@
/**
* File: array_stack.js
* Created Time: 2022-12-09
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
*/
/* 基於陣列實現的堆疊 */
class ArrayStack {
#stack;
constructor() {
this.#stack = [];
}
/* 獲取堆疊的長度 */
get size() {
return this.#stack.length;
}
/* 判斷堆疊是否為空 */
isEmpty() {
return this.#stack.length === 0;
}
/* 入堆疊 */
push(num) {
this.#stack.push(num);
}
/* 出堆疊 */
pop() {
if (this.isEmpty()) throw new Error('堆疊為空');
return this.#stack.pop();
}
/* 訪問堆疊頂元素 */
top() {
if (this.isEmpty()) throw new Error('堆疊為空');
return this.#stack[this.#stack.length - 1];
}
/* 返回 Array */
toArray() {
return this.#stack;
}
}
/* Driver Code */
/* 初始化堆疊 */
const stack = new ArrayStack();
/* 元素入堆疊 */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
console.log('堆疊 stack = ');
console.log(stack.toArray());
/* 訪問堆疊頂元素 */
const top = stack.top();
console.log('堆疊頂元素 top = ' + top);
/* 元素出堆疊 */
const pop = stack.pop();
console.log('出堆疊元素 pop = ' + pop + '，出堆疊後 stack = ');
console.log(stack.toArray());
/* 獲取堆疊的長度 */
const size = stack.size;
console.log('堆疊的長度 size = ' + size);
/* 判斷是否為空 */
const isEmpty = stack.isEmpty();
console.log('堆疊是否為空 = ' + isEmpty);

44
zh-hant/codes/javascript/chapter_stack_and_queue/deque.js Normal file
View File

@@ -0,0 +1,44 @@
/**
* File: deque.js
* Created Time: 2023-01-17
* Author: Zhuo Qinyue (1403450829@qq.com)
*/
/* Driver Code */
/* 初始化雙向佇列 */
// JavaScript 沒有內建的雙端佇列，只能把 Array 當作雙端佇列來使用
const deque = [];
/* 元素入列 */
deque.push(2);
deque.push(5);
deque.push(4);
// 請注意，由於是陣列，unshift() 方法的時間複雜度為 O(n)
deque.unshift(3);
deque.unshift(1);
console.log('雙向佇列 deque = ', deque);
/* 訪問元素 */
const peekFirst = deque[0];
console.log('佇列首元素 peekFirst = ' + peekFirst);
const peekLast = deque[deque.length - 1];
console.log('佇列尾元素 peekLast = ' + peekLast);
/* 元素出列 */
// 請注意，由於是陣列，shift() 方法的時間複雜度為 O(n)
const popFront = deque.shift();
console.log(
'佇列首出列元素 popFront = ' + popFront + '，佇列首出列後 deque = ' + deque
);
const popBack = deque.pop();
console.log(
'佇列尾出列元素 popBack = ' + popBack + '，佇列尾出列後 deque = ' + deque
);
/* 獲取雙向佇列的長度 */
const size = deque.length;
console.log('雙向佇列長度 size = ' + size);
/* 判斷雙向佇列是否為空 */
const isEmpty = size === 0;
console.log('雙向佇列是否為空 = ' + isEmpty);

167
zh-hant/codes/javascript/chapter_stack_and_queue/linkedlist_deque.js Normal file
View File

@@ -0,0 +1,167 @@
/**
* File: linkedlist_deque.js
* Created Time: 2023-02-04
* Author: Zhuo Qinyue (1403450829@qq.com)
*/
/* 雙向鏈結串列節點 */
class ListNode {
prev; // 前驅節點引用 (指標)
next; // 後繼節點引用 (指標)
val; // 節點值
constructor(val) {
this.val = val;
this.next = null;
this.prev = null;
}
}
/* 基於雙向鏈結串列實現的雙向佇列 */
class LinkedListDeque {
#front; // 頭節點 front
#rear; // 尾節點 rear
#queSize; // 雙向佇列的長度
constructor() {
this.#front = null;
this.#rear = null;
this.#queSize = 0;
}
/* 佇列尾入列操作 */
pushLast(val) {
const node = new ListNode(val);
// 若鏈結串列為空，則令 front 和 rear 都指向 node
if (this.#queSize === 0) {
this.#front = node;
this.#rear = node;
} else {
// 將 node 新增至鏈結串列尾部
this.#rear.next = node;
node.prev = this.#rear;
this.#rear = node; // 更新尾節點
}
this.#queSize++;
}
/* 佇列首入列操作 */
pushFirst(val) {
const node = new ListNode(val);
// 若鏈結串列為空，則令 front 和 rear 都指向 node
if (this.#queSize === 0) {
this.#front = node;
this.#rear = node;
} else {
// 將 node 新增至鏈結串列頭部
this.#front.prev = node;
node.next = this.#front;
this.#front = node; // 更新頭節點
}
this.#queSize++;
}
/* 佇列尾出列操作 */
popLast() {
if (this.#queSize === 0) {
return null;
}
const value = this.#rear.val; // 儲存尾節點值
// 刪除尾節點
let temp = this.#rear.prev;
if (temp !== null) {
temp.next = null;
this.#rear.prev = null;
}
this.#rear = temp; // 更新尾節點
this.#queSize--;
return value;
}
/* 佇列首出列操作 */
popFirst() {
if (this.#queSize === 0) {
return null;
}
const value = this.#front.val; // 儲存尾節點值
// 刪除頭節點
let temp = this.#front.next;
if (temp !== null) {
temp.prev = null;
this.#front.next = null;
}
this.#front = temp; // 更新頭節點
this.#queSize--;
return value;
}
/* 訪問佇列尾元素 */
peekLast() {
return this.#queSize === 0 ? null : this.#rear.val;
}
/* 訪問佇列首元素 */
peekFirst() {
return this.#queSize === 0 ? null : this.#front.val;
}
/* 獲取雙向佇列的長度 */
size() {
return this.#queSize;
}
/* 判斷雙向佇列是否為空 */
isEmpty() {
return this.#queSize === 0;
}
/* 列印雙向佇列 */
print() {
const arr = [];
let temp = this.#front;
while (temp !== null) {
arr.push(temp.val);
temp = temp.next;
}
console.log('[' + arr.join(', ') + ']');
}
}
/* Driver Code */
/* 初始化雙向佇列 */
const linkedListDeque = new LinkedListDeque();
linkedListDeque.pushLast(3);
linkedListDeque.pushLast(2);
linkedListDeque.pushLast(5);
console.log('雙向佇列 linkedListDeque = ');
linkedListDeque.print();
/* 訪問元素 */
const peekFirst = linkedListDeque.peekFirst();
console.log('佇列首元素 peekFirst = ' + peekFirst);
const peekLast = linkedListDeque.peekLast();
console.log('佇列尾元素 peekLast = ' + peekLast);
/* 元素入列 */
linkedListDeque.pushLast(4);
console.log('元素 4 佇列尾入列後 linkedListDeque = ');
linkedListDeque.print();
linkedListDeque.pushFirst(1);
console.log('元素 1 佇列首入列後 linkedListDeque = ');
linkedListDeque.print();
/* 元素出列 */
const popLast = linkedListDeque.popLast();
console.log('佇列尾出列元素 = ' + popLast + '，佇列尾出列後 linkedListDeque = ');
linkedListDeque.print();
const popFirst = linkedListDeque.popFirst();
console.log('佇列首出列元素 = ' + popFirst + '，佇列首出列後 linkedListDeque = ');
linkedListDeque.print();
/* 獲取雙向佇列的長度 */
const size = linkedListDeque.size();
console.log('雙向佇列長度 size = ' + size);
/* 判斷雙向佇列是否為空 */
const isEmpty = linkedListDeque.isEmpty();
console.log('雙向佇列是否為空 = ' + isEmpty);

99
zh-hant/codes/javascript/chapter_stack_and_queue/linkedlist_queue.js Normal file
View File

@@ -0,0 +1,99 @@
/**
* File: linkedlist_queue.js
* Created Time: 2022-12-20
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
*/
const { ListNode } = require('../modules/ListNode');
/* 基於鏈結串列實現的佇列 */
class LinkedListQueue {
#front; // 頭節點 #front
#rear; // 尾節點 #rear
#queSize = 0;
constructor() {
this.#front = null;
this.#rear = null;
}
/* 獲取佇列的長度 */
get size() {
return this.#queSize;
}
/* 判斷佇列是否為空 */
isEmpty() {
return this.size === 0;
}
/* 入列 */
push(num) {
// 在尾節點後新增 num
const node = new ListNode(num);
// 如果佇列為空，則令頭、尾節點都指向該節點
if (!this.#front) {
this.#front = node;
this.#rear = node;
// 如果佇列不為空，則將該節點新增到尾節點後
} else {
this.#rear.next = node;
this.#rear = node;
}
this.#queSize++;
}
/* 出列 */
pop() {
const num = this.peek();
// 刪除頭節點
this.#front = this.#front.next;
this.#queSize--;
return num;
}
/* 訪問佇列首元素 */
peek() {
if (this.size === 0) throw new Error('佇列為空');
return this.#front.val;
}
/* 將鏈結串列轉化為 Array 並返回 */
toArray() {
let node = this.#front;
const res = new Array(this.size);
for (let i = 0; i < res.length; i++) {
res[i] = node.val;
node = node.next;
}
return res;
}
}
/* Driver Code */
/* 初始化佇列 */
const queue = new LinkedListQueue();
/* 元素入列 */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);
console.log('佇列 queue = ' + queue.toArray());
/* 訪問佇列首元素 */
const peek = queue.peek();
console.log('佇列首元素 peek = ' + peek);
/* 元素出列 */
const pop = queue.pop();
console.log('出列元素 pop = ' + pop + '，出列後 queue = ' + queue.toArray());
/* 獲取佇列的長度 */
const size = queue.size;
console.log('佇列長度 size = ' + size);
/* 判斷佇列是否為空 */
const isEmpty = queue.isEmpty();
console.log('佇列是否為空 = ' + isEmpty);

88
zh-hant/codes/javascript/chapter_stack_and_queue/linkedlist_stack.js Normal file
View File

@@ -0,0 +1,88 @@
/**
* File: linkedlist_stack.js
* Created Time: 2022-12-22
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
*/
const { ListNode } = require('../modules/ListNode');
/* 基於鏈結串列實現的堆疊 */
class LinkedListStack {
#stackPeek; // 將頭節點作為堆疊頂
#stkSize = 0; // 堆疊的長度
constructor() {
this.#stackPeek = null;
}
/* 獲取堆疊的長度 */
get size() {
return this.#stkSize;
}
/* 判斷堆疊是否為空 */
isEmpty() {
return this.size === 0;
}
/* 入堆疊 */
push(num) {
const node = new ListNode(num);
node.next = this.#stackPeek;
this.#stackPeek = node;
this.#stkSize++;
}
/* 出堆疊 */
pop() {
const num = this.peek();
this.#stackPeek = this.#stackPeek.next;
this.#stkSize--;
return num;
}
/* 訪問堆疊頂元素 */
peek() {
if (!this.#stackPeek) throw new Error('堆疊為空');
return this.#stackPeek.val;
}
/* 將鏈結串列轉化為 Array 並返回 */
toArray() {
let node = this.#stackPeek;
const res = new Array(this.size);
for (let i = res.length - 1; i >= 0; i--) {
res[i] = node.val;
node = node.next;
}
return res;
}
}
/* Driver Code */
/* 初始化堆疊 */
const stack = new LinkedListStack();
/* 元素入堆疊 */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
console.log('堆疊 stack = ' + stack.toArray());
/* 訪問堆疊頂元素 */
const peek = stack.peek();
console.log('堆疊頂元素 peek = ' + peek);
/* 元素出堆疊 */
const pop = stack.pop();
console.log('出堆疊元素 pop = ' + pop + '，出堆疊後 stack = ' + stack.toArray());
/* 獲取堆疊的長度 */
const size = stack.size;
console.log('堆疊的長度 size = ' + size);
/* 判斷是否為空 */
const isEmpty = stack.isEmpty();
console.log('堆疊是否為空 = ' + isEmpty);

35
zh-hant/codes/javascript/chapter_stack_and_queue/queue.js Normal file
View File

@@ -0,0 +1,35 @@
/**
* File: queue.js
* Created Time: 2022-12-05
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
*/
/* Driver Code */
/* 初始化佇列 */
// JavaScript 沒有內建的佇列，可以把 Array 當作佇列來使用
const queue = [];
/* 元素入列 */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);
console.log('佇列 queue =', queue);
/* 訪問佇列首元素 */
const peek = queue[0];
console.log('佇列首元素 peek =', peek);
/* 元素出列 */
// 底層是陣列，因此 shift() 方法的時間複雜度為 O(n)
const pop = queue.shift();
console.log('出列元素 pop =', pop, '，出列後 queue = ', queue);
/* 獲取佇列的長度 */
const size = queue.length;
console.log('佇列長度 size =', size);
/* 判斷佇列是否為空 */
const isEmpty = queue.length === 0;
console.log('佇列是否為空 = ', isEmpty);

35
zh-hant/codes/javascript/chapter_stack_and_queue/stack.js Normal file
View File

@@ -0,0 +1,35 @@
/**
* File: stack.js
* Created Time: 2022-12-04
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
*/
/* Driver Code */
/* 初始化堆疊 */
// JavaScript 沒有內建的堆疊類別，可以把 Array 當作堆疊來使用
const stack = [];
/* 元素入堆疊 */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
console.log('堆疊 stack =', stack);
/* 訪問堆疊頂元素 */
const peek = stack[stack.length - 1];
console.log('堆疊頂元素 peek =', peek);
/* 元素出堆疊 */
const pop = stack.pop();
console.log('出堆疊元素 pop =', pop);
console.log('出堆疊後 stack =', stack);
/* 獲取堆疊的長度 */
const size = stack.length;
console.log('堆疊的長度 size =', size);
/* 判斷是否為空 */
const isEmpty = stack.length === 0;
console.log('堆疊是否為空 =', isEmpty);

147
zh-hant/codes/javascript/chapter_tree/array_binary_tree.js Normal file
View File

@@ -0,0 +1,147 @@
/**
* File: array_binary_tree.js
* Created Time: 2023-08-06
* Author: yuan0221 (yl1452491917@gmail.com)
*/
const { arrToTree } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
/* 陣列表示下的二元樹類別 */
class ArrayBinaryTree {
#tree;
/* 建構子 */
constructor(arr) {
this.#tree = arr;
}
/* 串列容量 */
size() {
return this.#tree.length;
}
/* 獲取索引為 i 節點的值 */
val(i) {
// 若索引越界，則返回 null ，代表空位
if (i < 0 || i >= this.size()) return null;
return this.#tree[i];
}
/* 獲取索引為 i 節點的左子節點的索引 */
left(i) {
return 2 * i + 1;
}
/* 獲取索引為 i 節點的右子節點的索引 */
right(i) {
return 2 * i + 2;
}
/* 獲取索引為 i 節點的父節點的索引 */
parent(i) {
return Math.floor((i - 1) / 2); // 向下整除
}
/* 層序走訪 */
levelOrder() {
let res = [];
// 直接走訪陣列
for (let i = 0; i < this.size(); i++) {
if (this.val(i) !== null) res.push(this.val(i));
}
return res;
}
/* 深度優先走訪 */
#dfs(i, order, res) {
// 若為空位，則返回
if (this.val(i) === null) return;
// 前序走訪
if (order === 'pre') res.push(this.val(i));
this.#dfs(this.left(i), order, res);
// 中序走訪
if (order === 'in') res.push(this.val(i));
this.#dfs(this.right(i), order, res);
// 後序走訪
if (order === 'post') res.push(this.val(i));
}
/* 前序走訪 */
preOrder() {
const res = [];
this.#dfs(0, 'pre', res);
return res;
}
/* 中序走訪 */
inOrder() {
const res = [];
this.#dfs(0, 'in', res);
return res;
}
/* 後序走訪 */
postOrder() {
const res = [];
this.#dfs(0, 'post', res);
return res;
}
}
/* Driver Code */
// 初始化二元樹
// 這裡藉助了一個從陣列直接生成二元樹的函式
const arr = Array.of(
1,
2,
3,
4,
null,
6,
7,
8,
9,
null,
null,
12,
null,
null,
15
);
const root = arrToTree(arr);
console.log('\n初始化二元樹\n');
console.log('二元樹的陣列表示：');
console.log(arr);
console.log('二元樹的鏈結串列表示：');
printTree(root);
// 陣列表示下的二元樹類別
const abt = new ArrayBinaryTree(arr);
// 訪問節點
const i = 1;
const l = abt.left(i);
const r = abt.right(i);
const p = abt.parent(i);
console.log('\n當前節點的索引為 ' + i + ' ，值為 ' + abt.val(i));
console.log(
'其左子節點的索引為 ' + l + ' ，值為 ' + (l === null ? 'null' : abt.val(l))
);
console.log(
'其右子節點的索引為 ' + r + ' ，值為 ' + (r === null ? 'null' : abt.val(r))
);
console.log(
'其父節點的索引為 ' + p + ' ，值為 ' + (p === null ? 'null' : abt.val(p))
);
// 走訪樹
let res = abt.levelOrder();
console.log('\n層序走訪為：' + res);
res = abt.preOrder();
console.log('前序走訪為：' + res);
res = abt.inOrder();
console.log('中序走訪為：' + res);
res = abt.postOrder();
console.log('後序走訪為：' + res);

208
zh-hant/codes/javascript/chapter_tree/avl_tree.js Normal file
View File

@@ -0,0 +1,208 @@
/**
* File: avl_tree.js
* Created Time: 2023-02-05
* Author: what-is-me (whatisme@outlook.jp)
*/
const { TreeNode } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
/* AVL 樹*/
class AVLTree {
/* 建構子 */
constructor() {
this.root = null; //根節點
}
/* 獲取節點高度 */
height(node) {
// 空節點高度為 -1 ，葉節點高度為 0
return node === null ? -1 : node.height;
}
/* 更新節點高度 */
#updateHeight(node) {
// 節點高度等於最高子樹高度 + 1
node.height =
Math.max(this.height(node.left), this.height(node.right)) + 1;
}
/* 獲取平衡因子 */
balanceFactor(node) {
// 空節點平衡因子為 0
if (node === null) return 0;
// 節點平衡因子 = 左子樹高度 - 右子樹高度
return this.height(node.left) - this.height(node.right);
}
/* 右旋操作 */
#rightRotate(node) {
const child = node.left;
const grandChild = child.right;
// 以 child 為原點，將 node 向右旋轉
child.right = node;
node.left = grandChild;
// 更新節點高度
this.#updateHeight(node);
this.#updateHeight(child);
// 返回旋轉後子樹的根節點
return child;
}
/* 左旋操作 */
#leftRotate(node) {
const child = node.right;
const grandChild = child.left;
// 以 child 為原點，將 node 向左旋轉
child.left = node;
node.right = grandChild;
// 更新節點高度
this.#updateHeight(node);
this.#updateHeight(child);
// 返回旋轉後子樹的根節點
return child;
}
/* 執行旋轉操作，使該子樹重新恢復平衡 */
#rotate(node) {
// 獲取節點 node 的平衡因子
const balanceFactor = this.balanceFactor(node);
// 左偏樹
if (balanceFactor > 1) {
if (this.balanceFactor(node.left) >= 0) {
// 右旋
return this.#rightRotate(node);
} else {
// 先左旋後右旋
node.left = this.#leftRotate(node.left);
return this.#rightRotate(node);
}
}
// 右偏樹
if (balanceFactor < -1) {
if (this.balanceFactor(node.right) <= 0) {
// 左旋
return this.#leftRotate(node);
} else {
// 先右旋後左旋
node.right = this.#rightRotate(node.right);
return this.#leftRotate(node);
}
}
// 平衡樹，無須旋轉，直接返回
return node;
}
/* 插入節點 */
insert(val) {
this.root = this.#insertHelper(this.root, val);
}
/* 遞迴插入節點（輔助方法） */
#insertHelper(node, val) {
if (node === null) return new TreeNode(val);
/* 1. 查詢插入位置並插入節點 */
if (val < node.val) node.left = this.#insertHelper(node.left, val);
else if (val > node.val)
node.right = this.#insertHelper(node.right, val);
else return node; // 重複節點不插入，直接返回
this.#updateHeight(node); // 更新節點高度
/* 2. 執行旋轉操作，使該子樹重新恢復平衡 */
node = this.#rotate(node);
// 返回子樹的根節點
return node;
}
/* 刪除節點 */
remove(val) {
this.root = this.#removeHelper(this.root, val);
}
/* 遞迴刪除節點（輔助方法） */
#removeHelper(node, val) {
if (node === null) return null;
/* 1. 查詢節點並刪除 */
if (val < node.val) node.left = this.#removeHelper(node.left, val);
else if (val > node.val)
node.right = this.#removeHelper(node.right, val);
else {
if (node.left === null || node.right === null) {
const child = node.left !== null ? node.left : node.right;
// 子節點數量 = 0 ，直接刪除 node 並返回
if (child === null) return null;
// 子節點數量 = 1 ，直接刪除 node
else node = child;
} else {
// 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點
let temp = node.right;
while (temp.left !== null) {
temp = temp.left;
}
node.right = this.#removeHelper(node.right, temp.val);
node.val = temp.val;
}
}
this.#updateHeight(node); // 更新節點高度
/* 2. 執行旋轉操作，使該子樹重新恢復平衡 */
node = this.#rotate(node);
// 返回子樹的根節點
return node;
}
/* 查詢節點 */
search(val) {
let cur = this.root;
// 迴圈查詢，越過葉節點後跳出
while (cur !== null) {
// 目標節點在 cur 的右子樹中
if (cur.val < val) cur = cur.right;
// 目標節點在 cur 的左子樹中
else if (cur.val > val) cur = cur.left;
// 找到目標節點，跳出迴圈
else break;
}
// 返回目標節點
return cur;
}
}
function testInsert(tree, val) {
tree.insert(val);
console.log('\n插入節點 ' + val + ' 後，AVL 樹為');
printTree(tree.root);
}
function testRemove(tree, val) {
tree.remove(val);
console.log('\n刪除節點 ' + val + ' 後，AVL 樹為');
printTree(tree.root);
}
/* Driver Code */
/* 初始化空 AVL 樹 */
const avlTree = new AVLTree();
/* 插入節點 */
// 請關注插入節點後，AVL 樹是如何保持平衡的
testInsert(avlTree, 1);
testInsert(avlTree, 2);
testInsert(avlTree, 3);
testInsert(avlTree, 4);
testInsert(avlTree, 5);
testInsert(avlTree, 8);
testInsert(avlTree, 7);
testInsert(avlTree, 9);
testInsert(avlTree, 10);
testInsert(avlTree, 6);
/* 插入重複節點 */
testInsert(avlTree, 7);
/* 刪除節點 */
// 請關注刪除節點後，AVL 樹是如何保持平衡的
testRemove(avlTree, 8); // 刪除度為 0 的節點
testRemove(avlTree, 5); // 刪除度為 1 的節點
testRemove(avlTree, 4); // 刪除度為 2 的節點
/* 查詢節點 */
const node = avlTree.search(7);
console.log('\n查詢到的節點物件為', node, '，節點值 = ' + node.val);

139
zh-hant/codes/javascript/chapter_tree/binary_search_tree.js Normal file
View File

@@ -0,0 +1,139 @@
/**
* File: binary_search_tree.js
* Created Time: 2022-12-04
* Author: IsChristina (christinaxia77@foxmail.com)
*/
const { TreeNode } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
/* 二元搜尋樹 */
class BinarySearchTree {
/* 建構子 */
constructor() {
// 初始化空樹
this.root = null;
}
/* 獲取二元樹根節點 */
getRoot() {
return this.root;
}
/* 查詢節點 */
search(num) {
let cur = this.root;
// 迴圈查詢，越過葉節點後跳出
while (cur !== null) {
// 目標節點在 cur 的右子樹中
if (cur.val < num) cur = cur.right;
// 目標節點在 cur 的左子樹中
else if (cur.val > num) cur = cur.left;
// 找到目標節點，跳出迴圈
else break;
}
// 返回目標節點
return cur;
}
/* 插入節點 */
insert(num) {
// 若樹為空，則初始化根節點
if (this.root === null) {
this.root = new TreeNode(num);
return;
}
let cur = this.root,
pre = null;
// 迴圈查詢，越過葉節點後跳出
while (cur !== null) {
// 找到重複節點，直接返回
if (cur.val === num) return;
pre = cur;
// 插入位置在 cur 的右子樹中
if (cur.val < num) cur = cur.right;
// 插入位置在 cur 的左子樹中
else cur = cur.left;
}
// 插入節點
const node = new TreeNode(num);
if (pre.val < num) pre.right = node;
else pre.left = node;
}
/* 刪除節點 */
remove(num) {
// 若樹為空，直接提前返回
if (this.root === null) return;
let cur = this.root,
pre = null;
// 迴圈查詢，越過葉節點後跳出
while (cur !== null) {
// 找到待刪除節點，跳出迴圈
if (cur.val === num) break;
pre = cur;
// 待刪除節點在 cur 的右子樹中
if (cur.val < num) cur = cur.right;
// 待刪除節點在 cur 的左子樹中
else cur = cur.left;
}
// 若無待刪除節點，則直接返回
if (cur === null) return;
// 子節點數量 = 0 or 1
if (cur.left === null || cur.right === null) {
// 當子節點數量 = 0 / 1 時， child = null / 該子節點
const child = cur.left !== null ? cur.left : cur.right;
// 刪除節點 cur
if (cur !== this.root) {
if (pre.left === cur) pre.left = child;
else pre.right = child;
} else {
// 若刪除節點為根節點，則重新指定根節點
this.root = child;
}
}
// 子節點數量 = 2
else {
// 獲取中序走訪中 cur 的下一個節點
let tmp = cur.right;
while (tmp.left !== null) {
tmp = tmp.left;
}
// 遞迴刪除節點 tmp
this.remove(tmp.val);
// 用 tmp 覆蓋 cur
cur.val = tmp.val;
}
}
}
/* Driver Code */
/* 初始化二元搜尋樹 */
const bst = new BinarySearchTree();
// 請注意，不同的插入順序會生成不同的二元樹，該序列可以生成一個完美二元樹
const nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15];
for (const num of nums) {
bst.insert(num);
}
console.log('\n初始化的二元樹為\n');
printTree(bst.getRoot());
/* 查詢節點 */
const node = bst.search(7);
console.log('\n查詢到的節點物件為 ' + node + '，節點值 = ' + node.val);
/* 插入節點 */
bst.insert(16);
console.log('\n插入節點 16 後，二元樹為\n');
printTree(bst.getRoot());
/* 刪除節點 */
bst.remove(1);
console.log('\n刪除節點 1 後，二元樹為\n');
printTree(bst.getRoot());
bst.remove(2);
console.log('\n刪除節點 2 後，二元樹為\n');
printTree(bst.getRoot());
bst.remove(4);
console.log('\n刪除節點 4 後，二元樹為\n');
printTree(bst.getRoot());

35
zh-hant/codes/javascript/chapter_tree/binary_tree.js Normal file
View File

@@ -0,0 +1,35 @@
/**
* File: binary_tree.js
* Created Time: 2022-12-04
* Author: IsChristina (christinaxia77@foxmail.com)
*/
const { TreeNode } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
/* 初始化二元樹 */
// 初始化節點
let n1 = new TreeNode(1),
n2 = new TreeNode(2),
n3 = new TreeNode(3),
n4 = new TreeNode(4),
n5 = new TreeNode(5);
// 構建節點之間的引用（指標）
n1.left = n2;
n1.right = n3;
n2.left = n4;
n2.right = n5;
console.log('\n初始化二元樹\n');
printTree(n1);
/* 插入與刪除節點 */
const P = new TreeNode(0);
// 在 n1 -> n2 中間插入節點 P
n1.left = P;
P.left = n2;
console.log('\n插入節點 P 後\n');
printTree(n1);
// 刪除節點 P
n1.left = n2;
console.log('\n刪除節點 P 後\n');
printTree(n1);

34
zh-hant/codes/javascript/chapter_tree/binary_tree_bfs.js Normal file
View File

@@ -0,0 +1,34 @@
/**
* File: binary_tree_bfs.js
* Created Time: 2022-12-04
* Author: IsChristina (christinaxia77@foxmail.com)
*/
const { arrToTree } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
/* 層序走訪 */
function levelOrder(root) {
// 初始化佇列，加入根節點
const queue = [root];
// 初始化一個串列，用於儲存走訪序列
const list = [];
while (queue.length) {
let node = queue.shift(); // 隊列出隊
list.push(node.val); // 儲存節點值
if (node.left) queue.push(node.left); // 左子節點入列
if (node.right) queue.push(node.right); // 右子節點入列
}
return list;
}
/* Driver Code */
/* 初始化二元樹 */
// 這裡藉助了一個從陣列直接生成二元樹的函式
const root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
console.log('\n初始化二元樹\n');
printTree(root);
/* 層序走訪 */
const list = levelOrder(root);
console.log('\n層序走訪的節點列印序列 = ' + list);

60
zh-hant/codes/javascript/chapter_tree/binary_tree_dfs.js Normal file
View File

@@ -0,0 +1,60 @@
/**
* File: binary_tree_dfs.js
* Created Time: 2022-12-04
* Author: IsChristina (christinaxia77@foxmail.com)
*/
const { arrToTree } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
// 初始化串列，用於儲存走訪序列
const list = [];
/* 前序走訪 */
function preOrder(root) {
if (root === null) return;
// 訪問優先順序：根節點 -> 左子樹 -> 右子樹
list.push(root.val);
preOrder(root.left);
preOrder(root.right);
}
/* 中序走訪 */
function inOrder(root) {
if (root === null) return;
// 訪問優先順序：左子樹 -> 根節點 -> 右子樹
inOrder(root.left);
list.push(root.val);
inOrder(root.right);
}
/* 後序走訪 */
function postOrder(root) {
if (root === null) return;
// 訪問優先順序：左子樹 -> 右子樹 -> 根節點
postOrder(root.left);
postOrder(root.right);
list.push(root.val);
}
/* Driver Code */
/* 初始化二元樹 */
// 這裡藉助了一個從陣列直接生成二元樹的函式
const root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
console.log('\n初始化二元樹\n');
printTree(root);
/* 前序走訪 */
list.length = 0;
preOrder(root);
console.log('\n前序走訪的節點列印序列 = ' + list);
/* 中序走訪 */
list.length = 0;
inOrder(root);
console.log('\n中序走訪的節點列印序列 = ' + list);
/* 後序走訪 */
list.length = 0;
postOrder(root);
console.log('\n後序走訪的節點列印序列 = ' + list);

31
zh-hant/codes/javascript/modules/ListNode.js Executable file
View File

@@ -0,0 +1,31 @@
/**
* File: ListNode.js
* Created Time: 2022-12-12
* Author: IsChristina (christinaxia77@foxmail.com)
*/
/* 鏈結串列節點 */
class ListNode {
val; // 節點值
next; // 指向下一節點的引用（指標）
constructor(val, next) {
this.val = val === undefined ? 0 : val;
this.next = next === undefined ? null : next;
}
}
/* 將串列反序列化為鏈結串列 */
function arrToLinkedList(arr) {
const dum = new ListNode(0);
let head = dum;
for (const val of arr) {
head.next = new ListNode(val);
head = head.next;
}
return dum.next;
}
module.exports = {
ListNode,
arrToLinkedList,
};

86
zh-hant/codes/javascript/modules/PrintUtil.js Normal file
View File

@@ -0,0 +1,86 @@
/**
* File: PrintUtil.js
* Created Time: 2022-12-04
* Author: IsChristina (christinaxia77@foxmail.com)
*/
const { arrToTree } = require('./TreeNode');
/* 列印鏈結串列 */
function printLinkedList(head) {
let list = [];
while (head !== null) {
list.push(head.val.toString());
head = head.next;
}
console.log(list.join(' -> '));
}
function Trunk(prev, str) {
this.prev = prev;
this.str = str;
}
/**
* 列印二元樹
* This tree printer is borrowed from TECHIE DELIGHT
* https://www.techiedelight.com/c-program-print-binary-tree/
*/
function printTree(root) {
printTree(root, null, false);
}
/* 列印二元樹 */
function printTree(root, prev, isRight) {
if (root === null) {
return;
}
let prev_str = ' ';
let trunk = new Trunk(prev, prev_str);
printTree(root.right, trunk, true);
if (!prev) {
trunk.str = '———';
} else if (isRight) {
trunk.str = '/———';
prev_str = ' |';
} else {
trunk.str = '\\———';
prev.str = prev_str;
}
showTrunks(trunk);
console.log(' ' + root.val);
if (prev) {
prev.str = prev_str;
}
trunk.str = ' |';
printTree(root.left, trunk, false);
}
function showTrunks(p) {
if (!p) {
return;
}
showTrunks(p.prev);
process.stdout.write(p.str);
}
/* 列印堆積 */
function printHeap(arr) {
console.log('堆積的陣列表示：');
console.log(arr);
console.log('堆積的樹狀表示：');
printTree(arrToTree(arr));
}
module.exports = {
printLinkedList,
printTree,
printHeap,
};

35
zh-hant/codes/javascript/modules/TreeNode.js Normal file
View File

@@ -0,0 +1,35 @@
/**
* File: TreeNode.js
* Created Time: 2022-12-04
* Author: IsChristina (christinaxia77@foxmail.com)
*/
/* 二元樹節點 */
class TreeNode {
val; // 節點值
left; // 左子節點指標
right; // 右子節點指標
height; //節點高度
constructor(val, left, right, height) {
this.val = val === undefined ? 0 : val;
this.left = left === undefined ? null : left;
this.right = right === undefined ? null : right;
this.height = height === undefined ? 0 : height;
}
}
/* 將陣列反序列化為二元樹 */
function arrToTree(arr, i = 0) {
if (i < 0 || i >= arr.length || arr[i] === null) {
return null;
}
let root = new TreeNode(arr[i]);
root.left = arrToTree(arr, 2 * i + 1);
root.right = arrToTree(arr, 2 * i + 2);
return root;
}
module.exports = {
TreeNode,
arrToTree,
};

35
zh-hant/codes/javascript/modules/Vertex.js Normal file
View File

@@ -0,0 +1,35 @@
/**
* File: Vertex.js
* Created Time: 2023-02-15
* Author: Zhuo Qinyue (1403450829@qq.com)
*/
/* 頂點類別 */
class Vertex {
val;
constructor(val) {
this.val = val;
}
/* 輸入值串列 vals ，返回頂點串列 vets */
static valsToVets(vals) {
const vets = [];
for (let i = 0; i < vals.length; i++) {
vets[i] = new Vertex(vals[i]);
}
return vets;
}
/* 輸入頂點串列 vets ，返回值串列 vals */
static vetsToVals(vets) {
const vals = [];
for (const vet of vets) {
vals.push(vet.val);
}
return vals;
}
}
module.exports = {
Vertex,
};