Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/javascript/.prettierrc

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

ja/codes/javascript/chapter_array_and_linkedlist/array.js

@@ -0,0 +1,97 @@
+/**
+ * File: array.js
+ * Created Time: 2022-11-27
+ * Author: IsChristina (christinaxia77@foxmail.com)
+ */
+
+/* 要素へランダムアクセス */
+function randomAccess(nums) {
+    // 区間 [0, nums.length) からランダムに 1 つの数を選ぶ
+    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 以降の全要素を 1 つ後ろへ移動する
+    for (let i = nums.length - 1; i > index; i--) {
+        nums[i] = nums[i - 1];
+    }
+    // index の要素に num を代入する
+    nums[index] = num;
+}
+
+/* index の要素を削除する */
+function remove(nums, index) {
+    // インデックス index より後ろの全要素を 1 つ前へ移動する
+    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);

ja/codes/javascript/chapter_array_and_linkedlist/linked_list.js

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

ja/codes/javascript/chapter_array_and_linkedlist/list.js

@@ -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;
+}
+
+/* 2 つのリストを連結する */
+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}`);

ja/codes/javascript/chapter_array_and_linkedlist/my_list.js

@@ -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 以降の要素をすべて 1 つ後ろへずらす
+        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 より後の要素をすべて 1 つ前に移動する
+        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()}`
+);

ja/codes/javascript/chapter_backtracking/n_queens.js

@@ -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));
+});

ja/codes/javascript/chapter_backtracking/permutations_i.js

@@ -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)}`);

ja/codes/javascript/chapter_backtracking/permutations_ii.js

@@ -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)}`);

ja/codes/javascript/chapter_backtracking/preorder_traversal_i_compact.js

@@ -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');
+
+/* 前順走査：例題 1 */
+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));

ja/codes/javascript/chapter_backtracking/preorder_traversal_ii_compact.js

@@ -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');
+
+/* 前順走査：例題 2 */
+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));
+});

ja/codes/javascript/chapter_backtracking/preorder_traversal_iii_compact.js

@@ -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');
+
+/* 前順走査：例題 3 */
+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));
+});

ja/codes/javascript/chapter_backtracking/preorder_traversal_iii_template.js

@@ -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();
+}
+
+/* バックトラッキング：例題 3 */
+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));
+});

ja/codes/javascript/chapter_backtracking/subset_sum_i.js

@@ -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;
+    }
+    // すべての選択肢を走査
+    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
+    for (let i = start; i < choices.length; i++) {
+        // 枝刈り1：部分集合の和が 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)}`);

ja/codes/javascript/chapter_backtracking/subset_sum_i_naive.js

@@ -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('注意してください。この方法の出力結果には重複した集合が含まれます');

ja/codes/javascript/chapter_backtracking/subset_sum_ii.js

@@ -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;
+    }
+    // すべての選択肢を走査
+    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
+    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける
+    for (let i = start; i < choices.length; i++) {
+        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
+        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
+        if (target - choices[i] < 0) {
+            break;
+        }
+        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする
+        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)}`);

ja/codes/javascript/chapter_computational_complexity/iteration.js

@@ -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 ループ（2回更新） */
+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 ループ（2 回更新）の合計結果 res = ${res}`);
+
+const resStr = nestedForLoop(n);
+console.log(`二重 for ループの走査結果 ${resStr}`);

ja/codes/javascript/chapter_computational_complexity/recursion.js

@@ -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}`);
+

ja/codes/javascript/chapter_computational_complexity/space_complexity.js

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

ja/codes/javascript/chapter_computational_complexity/time_complexity.js

@@ -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;
+    // 細胞は各ラウンドで 2 つに分裂し、数列 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);

ja/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js

@@ -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);
+}

ja/codes/javascript/chapter_divide_and_conquer/binary_search_recur.js

@@ -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}`);

ja/codes/javascript/chapter_divide_and_conquer/build_tree.js

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

ja/codes/javascript/chapter_divide_and_conquer/hanota.js

@@ -0,0 +1,52 @@
+/**
+ * File: hanota.js
+ * Created Time: 2023-07-30
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* 円盤を 1 枚移動 */
+function move(src, tar) {
+    // src の上から円盤を1枚取り出す
+    const pan = src.pop();
+    // 円盤を tar の上に置く
+    tar.push(pan);
+}
+
+/* ハノイの塔の問題 f(i) を解く */
+function dfs(i, src, buf, tar) {
+    // src に円盤が 1 枚だけ残っている場合は、そのまま 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 に残る 1 枚の円盤を 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)}`);

ja/codes/javascript/chapter_dynamic_programming/climbing_stairs_backtrack.js

@@ -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} 通り`);

ja/codes/javascript/chapter_dynamic_programming/climbing_stairs_constraint_dp.js

@@ -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} 通り`);

ja/codes/javascript/chapter_dynamic_programming/climbing_stairs_dfs.js

@@ -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} 通り`);

ja/codes/javascript/chapter_dynamic_programming/climbing_stairs_dfs_mem.js

@@ -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} 通り`);

ja/codes/javascript/chapter_dynamic_programming/climbing_stairs_dp.js

@@ -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} 通り`);

ja/codes/javascript/chapter_dynamic_programming/coin_change.js

@@ -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}`);

ja/codes/javascript/chapter_dynamic_programming/coin_change_ii.js

@@ -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}`);

ja/codes/javascript/chapter_dynamic_programming/edit_distance.js

@@ -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;
+
+    // 2 つの文字が等しければ、その 2 文字をそのままスキップする
+    if (s.charAt(i - 1) === t.charAt(j - 1))
+        return editDistanceDFS(s, t, i - 1, j - 1);
+
+    // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 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];
+
+    // 2 つの文字が等しければ、その 2 文字をそのままスキップする
+    if (s.charAt(i - 1) === t.charAt(j - 1))
+        return editDistanceDFSMem(s, t, mem, i - 1, j - 1);
+
+    // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 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)) {
+                // 2 つの文字が等しければ、その 2 文字をそのままスキップする
+                dp[i][j] = dp[i - 1][j - 1];
+            } else {
+                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 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)) {
+                // 2 つの文字が等しければ、その 2 文字をそのままスキップする
+                dp[j] = leftup;
+            } else {
+                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 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} 回の編集が必要`);

ja/codes/javascript/chapter_dynamic_programming/knapsack.js

@@ -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];
+    // 2つの案のうち価値が大きいほうを返す
+    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];
+    // 2 つの案のうち価値が大きい方を記録して返す
+    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}`);

ja/codes/javascript/chapter_dynamic_programming/min_cost_climbing_stairs_dp.js

@@ -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}`);

ja/codes/javascript/chapter_dynamic_programming/min_path_sum.js

@@ -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}`);

ja/codes/javascript/chapter_dynamic_programming/unbounded_knapsack.js

@@ -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}`);

ja/codes/javascript/chapter_graph/graph_adjacency_list.js

@@ -0,0 +1,142 @@
+/**
+ * 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 ||
+            this.adjList.get(vet1).indexOf(vet2) === -1
+        ) {
+            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,
+};

ja/codes/javascript/chapter_graph/graph_adjacency_matrix.js

@@ -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);
+        // 隣接行列に 1 行追加
+        const newRow = [];
+        for (let j = 0; j < n; j++) {
+            newRow.push(0);
+        }
+        this.adjMat.push(newRow);
+        // 隣接行列に 1 列追加
+        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();

ja/codes/javascript/chapter_graph/graph_bfs.js

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

ja/codes/javascript/chapter_graph/graph_dfs.js

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

ja/codes/javascript/chapter_greedy/coin_change_greedy.js

@@ -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');

ja/codes/javascript/chapter_greedy/fractional_knapsack.js

@@ -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) {
+    // 重さと価値の 2 属性を持つ品物リストを作成
+    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}`);

ja/codes/javascript/chapter_greedy/max_capacity.js

@@ -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;
+    // 2 枚の板が出会うまで貪欲選択を繰り返す
+    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}`);

ja/codes/javascript/chapter_greedy/max_product_cutting.js

@@ -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}`);

ja/codes/javascript/chapter_hashing/array_hash_map.js

@@ -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('\n10583 を削除した後、ハッシュ表は\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);
+}

ja/codes/javascript/chapter_hashing/hash_map.js

@@ -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('\n10583 を削除した後、ハッシュ表は\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);
+}

ja/codes/javascript/chapter_hashing/hash_map_chaining.js

@@ -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('\n12836 を削除した後、ハッシュテーブルは\nKey -> Value');
+map.print();

ja/codes/javascript/chapter_hashing/hash_map_open_addressing.js

@@ -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('\n16750 を削除した後、ハッシュテーブルは\nKey -> Value');
+hashmap.print();

ja/codes/javascript/chapter_hashing/simple_hash.js

@@ -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;
+}
+
+/* XOR ハッシュ */
+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('XORハッシュ値は ' + hash);
+
+hash = rotHash(key);
+console.log('回転ハッシュ値は ' + hash);

ja/codes/javascript/chapter_heap/my_heap.js

@@ -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;
+            // 2 つのノードを交換
+            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;
+            // 2 つのノードを交換
+            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,
+};

ja/codes/javascript/chapter_heap/top_k.js

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

ja/codes/javascript/chapter_searching/binary_search.js

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

ja/codes/javascript/chapter_searching/binary_search_edge.js

@@ -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);
+}

ja/codes/javascript/chapter_searching/binary_search_insertion.js

@@ -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,
+};

ja/codes/javascript/chapter_searching/hashing_search.js

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

ja/codes/javascript/chapter_searching/linear_search.js

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

ja/codes/javascript/chapter_searching/two_sum.js

@@ -0,0 +1,46 @@
+/**
+ * File: two_sum.js
+ * Created Time: 2022-12-15
+ * Author: gyt95 (gytkwan@gmail.com)
+ */
+
+/* 方法 1：総当たり列挙 */
+function twoSumBruteForce(nums, target) {
+    const n = nums.length;
+    // 2重ループのため、時間計算量は 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 [];
+}
+
+/* 方法 2：補助ハッシュテーブル */
+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 */
+// 方法 1
+const nums = [2, 7, 11, 15],
+    target = 13;
+
+let res = twoSumBruteForce(nums, target);
+console.log('方法1 res = ', res);
+
+// 方法 2
+res = twoSumHashTable(nums, target);
+console.log('方法2 res = ', res);

ja/codes/javascript/chapter_sorting/bubble_sort.js

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

ja/codes/javascript/chapter_sorting/bucket_sort.js

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

ja/codes/javascript/chapter_sorting/counting_sort.js

@@ -0,0 +1,65 @@
+/**
+ * File: counting_sort.js
+ * Created Time: 2023-04-08
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* 計数ソート */
+// 簡易実装のため、オブジェクトのソートには使えない
+function countingSortNaive(nums) {
+    // 1. 配列の最大要素 m を求める
+    let m = Math.max(...nums);
+    // 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 = Math.max(...nums);
+    // 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);

ja/codes/javascript/chapter_sorting/heap_sort.js

@@ -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;
+        }
+        // 2 つのノードを交換
+        [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);

ja/codes/javascript/chapter_sorting/insertion_sort.js

@@ -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] を 1 つ右へ移動する
+            j--;
+        }
+        nums[j + 1] = base; // base を正しい位置に配置する
+    }
+}
+
+/* Driver Code */
+const nums = [4, 1, 3, 1, 5, 2];
+insertionSort(nums);
+console.log('挿入ソート完了後 nums =', nums);

ja/codes/javascript/chapter_sorting/merge_sort.js

@@ -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 - left) / 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);

ja/codes/javascript/chapter_sorting/quick_sort.js

@@ -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); // この 2 つの要素を交換
+        }
+        this.swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する
+        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;
+    }
+
+    /* 3つの候補要素の中央値を選ぶ */
+    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;
+    }
+
+    /* 番兵による分割処理（3 点中央値） */
+    partition(nums, left, right) {
+        // 3つの候補要素の中央値を選ぶ
+        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); // この 2 つの要素を交換
+        }
+        this.swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する
+        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); // この 2 つの要素を交換
+        }
+        this.swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する
+        return i; // 基準値のインデックスを返す
+    }
+
+    /* クイックソート（再帰深度最適化） */
+    quickSort(nums, left, right) {
+        // 部分配列の長さが 1 なら終了
+        while (left < right) {
+            // 番兵による分割処理
+            let pivot = this.partition(nums, left, right);
+            // 2 つの部分配列のうち短いほうにクイックソートを適用する
+            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);

ja/codes/javascript/chapter_sorting/radix_sort.js

@@ -0,0 +1,61 @@
+/**
+ * File: radix_sort.js
+ * Created Time: 2023-04-08
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */
+function digit(num, exp) {
+    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す
+    return Math.floor(num / exp) % 10;
+}
+
+/* 計数ソート（nums の k 桁目でソート） */
+function countingSortDigit(nums, exp) {
+    // 10 進数の各桁は 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 = Math.max(... nums);
+    // 下位桁から上位桁の順に走査する
+    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);

ja/codes/javascript/chapter_sorting/selection_sort.js

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

ja/codes/javascript/chapter_stack_and_queue/array_deque.js

@@ -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;
+        }
+        // 先頭ポインタを左に 1 つ移動する
+        // 剰余演算により、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();
+        // 先頭ポインタを 1 つ後ろへ進める
+        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);

ja/codes/javascript/chapter_stack_and_queue/array_queue.js

@@ -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();
+        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す
+        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());
+}

ja/codes/javascript/chapter_stack_and_queue/array_stack.js

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

ja/codes/javascript/chapter_stack_and_queue/deque.js

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

ja/codes/javascript/chapter_stack_and_queue/linkedlist_deque.js

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

ja/codes/javascript/chapter_stack_and_queue/linkedlist_queue.js

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

ja/codes/javascript/chapter_stack_and_queue/linkedlist_stack.js

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

ja/codes/javascript/chapter_stack_and_queue/queue.js

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

ja/codes/javascript/chapter_stack_and_queue/stack.js

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

ja/codes/javascript/chapter_tree/array_binary_tree.js

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

ja/codes/javascript/chapter_tree/avl_tree.js

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

ja/codes/javascript/chapter_tree/binary_search_tree.js

@@ -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());

ja/codes/javascript/chapter_tree/binary_tree.js

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

ja/codes/javascript/chapter_tree/binary_tree_bfs.js

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

ja/codes/javascript/chapter_tree/binary_tree_dfs.js

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

ja/codes/javascript/modules/ListNode.js

@@ -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,
+};

ja/codes/javascript/modules/PrintUtil.js

@@ -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,
+};

ja/codes/javascript/modules/TreeNode.js

@@ -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,
+};

ja/codes/javascript/modules/Vertex.js

@@ -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,
+};

ja/codes/javascript/test_all.js

@@ -0,0 +1,63 @@
+import { bold, brightRed } from 'jsr:@std/fmt/colors';
+import { expandGlob } from 'jsr:@std/fs';
+import { relative, resolve } from 'jsr:@std/path';
+
+/**
+ * @typedef {import('jsr:@std/fs').WalkEntry} WalkEntry
+ * @type {WalkEntry[]}
+ */
+const entries = [];
+
+for await (const entry of expandGlob(
+    resolve(import.meta.dirname, './chapter_*/*.js')
+)) {
+    entries.push(entry);
+}
+
+/** @type {{ status: Promise<Deno.CommandStatus>; stderr: ReadableStream<Uint8Array>; }[]} */
+const processes = [];
+
+for (const file of entries) {
+    const execute = new Deno.Command('node', {
+        args: [relative(import.meta.dirname, file.path)],
+        cwd: import.meta.dirname,
+        stdin: 'piped',
+        stdout: 'piped',
+        stderr: 'piped',
+    });
+
+    const process = execute.spawn();
+    processes.push({ status: process.status, stderr: process.stderr });
+}
+
+const results = await Promise.all(
+    processes.map(async (item) => {
+        const status = await item.status;
+        return { status, stderr: item.stderr };
+    })
+);
+
+/** @type {ReadableStream<Uint8Array>[]} */
+const errors = [];
+
+for (const result of results) {
+    if (!result.status.success) {
+        errors.push(result.stderr);
+    }
+}
+
+console.log(`Tested ${entries.length} files`);
+console.log(`Found exception in ${errors.length} files`);
+
+if (errors.length) {
+    console.log();
+
+    for (const error of errors) {
+        const reader = error.getReader();
+        const { value } = await reader.read();
+        const decoder = new TextDecoder();
+        console.log(`${bold(brightRed('error'))}: ${decoder.decode(value)}`);
+    }
+
+    throw new Error('Test failed');
+}