Retranslate the complete Japanese online edition from Chinese (#2008)

* Retranslate the complete Japanese online edition from Chinese

* Fit Japanese homepage labels and localize heading permalinks

* Point Japanese contribution instructions to the Japanese preview

* Replace locale conditionals with multilingual UI tables

ja/codes/javascript/chapter_stack_and_queue/array_deque.js

@@ -4,10 +4,10 @@
  * Author: Zhuo Qinyue ([email protected])
  */
 
-/* 循環配列ベースの両端キュー */
+/* 循環配列で実装した両端キュー */
 class ArrayDeque {
     #nums; // 両端キューの要素を格納する配列
-    #front; // 先頭ポインタ。先頭要素を指す
+    #front; // キューの先頭要素を指す先頭ポインタ
     #queSize; // 両端キューの長さ
 
     /* コンストラクタ */
@@ -17,89 +17,89 @@ class ArrayDeque {
         this.#queSize = 0;
     }
 
-    /* 両端キューの容量を取得 */
+    /* 両端キューの容量を取得する */
     capacity() {
         return this.#nums.length;
     }
 
-    /* 両端キューの長さを取得 */
+    /* 両端キューの長さを取得する */
     size() {
         return this.#queSize;
     }
 
-    /* 両端キューが空かどうかを判定 */
+    /* 両端キューが空かどうかを判定する */
     isEmpty() {
         return this.#queSize === 0;
     }
 
-    /* 循環配列のインデックスを計算 */
+    /* 循環配列のインデックスを計算する */
     index(i) {
-        // 剰余演算により配列の先頭と末尾をつなげる
-        // i が配列の末尾を越えたら先頭に戻る
-        // i が配列の先頭を越えて前に出たら末尾に戻る
+        // 剰余演算を使い、配列の先頭と末尾をつなぐ
+        // i が配列の末尾を越えたら、先頭に戻る
+        // i が配列の先頭を越えたら、末尾に戻る
         return (i + this.capacity()) % this.capacity();
     }
 
-    /* キュー先頭にエンキュー */
+    /* 先頭にエンキューする */
     pushFirst(num) {
         if (this.#queSize === this.capacity()) {
-            console.log('両端キューがいっぱいです');
+            console.log('両端キューが満杯です');
             return;
         }
         // 先頭ポインタを左に 1 つ移動する
-        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする
+        // 剰余演算により、front が配列の先頭を越えたら末尾に戻るようにする
         this.#front = this.index(this.#front - 1);
-        // num をキュー先頭に追加
+        // num をキューの先頭に追加する
         this.#nums[this.#front] = num;
         this.#queSize++;
     }
 
-    /* キュー末尾にエンキュー */
+    /* 末尾にエンキューする */
     pushLast(num) {
         if (this.#queSize === this.capacity()) {
-            console.log('両端キューがいっぱいです');
+            console.log('両端キューが満杯です');
             return;
         }
-        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す
+        // 末尾のインデックス + 1 を指す末尾ポインタを計算する
         const rear = this.index(this.#front + this.#queSize);
-        // num をキュー末尾に追加
+        // num をキューの末尾に追加する
         this.#nums[rear] = num;
         this.#queSize++;
     }
 
-    /* キュー先頭からデキュー */
+    /* 先頭からデキューする */
     popFirst() {
         const num = this.peekFirst();
-        // 先頭ポインタを 1 つ後ろへ進める
+        // 先頭ポインタを後ろに 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.');
+        if (this.isEmpty()) throw new Error('両端キューが空です。');
         return this.#nums[this.#front];
     }
 
-    /* キュー末尾の要素にアクセス */
+    /* キューの末尾要素にアクセスする */
     peekLast() {
-        if (this.isEmpty()) throw new Error('The Deque Is Empty.');
-        // 末尾要素のインデックスを計算
+        if (this.isEmpty()) throw new Error('両端キューが空です。');
+        // 末尾要素のインデックスを計算する
         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)];
@@ -108,8 +108,8 @@ class ArrayDeque {
     }
 }
 
-/* Driver Code */
-/* 両端キューを初期化 */
+/* 実行用コード */
+/* 両端キューを初期化する */
 const capacity = 5;
 const deque = new ArrayDeque(capacity);
 deque.pushLast(3);
@@ -117,40 +117,40 @@ deque.pushLast(2);
 deque.pushLast(5);
 console.log('両端キュー deque = [' + deque.toArray() + ']');
 
-/* 要素にアクセス */
+/* 要素にアクセスする */
 const peekFirst = deque.peekFirst();
-console.log('先頭要素 peekFirst = ' + peekFirst);
+console.log('キューの先頭要素 peekFirst = ' + peekFirst);
 const peekLast = deque.peekLast();
-console.log('末尾要素 peekLast = ' + peekLast);
+console.log('キューの末尾要素 peekLast = ' + peekLast);
 
-/* 要素をエンキュー */
+/* 要素をエンキューする */
 deque.pushLast(4);
-console.log('要素 4 を末尾に追加した後 deque = [' + deque.toArray() + ']');
+console.log('要素 4 を末尾にエンキューした後 deque = [' + deque.toArray() + ']');
 deque.pushFirst(1);
-console.log('要素 1 を先頭に追加した後 deque = [' + deque.toArray() + ']');
+console.log('要素 1 を先頭にエンキューした後 deque = [' + deque.toArray() + ']');
 
-/* 要素をデキュー */
+/* 要素をデキューする */
 const popLast = deque.popLast();
 console.log(
-    '末尾から取り出した要素 = ' +
+    '末尾からデキューした要素 = ' +
         popLast +
-        '、末尾から取り出した後 deque = [' +
+        '、末尾からデキューした後 deque = [' +
         deque.toArray() +
         ']'
 );
 const popFirst = deque.popFirst();
 console.log(
-    '先頭から取り出した要素 = ' +
+    '先頭からデキューした要素 = ' +
         popFirst +
-        '、先頭から取り出した後 deque = [' +
+        '、先頭からデキューした後 deque = [' +
         deque.toArray() +
         ']'
 );
 
-/* 両端キューの長さを取得 */
+/* 両端キューの長さを取得する */
 const size = deque.size();
 console.log('両端キューの長さ size = ' + size);
 
-/* 両端キューが空かどうかを判定 */
+/* 両端キューが空かどうかを判定する */
 const isEmpty = deque.isEmpty();
-console.log('両端キューが空かどうか = ' + isEmpty);
+console.log('両端キューは空か = ' + isEmpty);

ja/codes/javascript/chapter_stack_and_queue/array_queue.js

@@ -4,17 +4,17 @@
  * Author: S-N-O-R-L-A-X ([email protected])
  */
 
-/* 循環配列ベースのキュー */
+/* 循環配列で実装したキュー */
 class ArrayQueue {
-    #nums; // キュー要素を格納する配列
-    #front = 0; // 先頭ポインタ。先頭要素を指す
+    #nums; // キューの要素を格納する配列
+    #front = 0; // キューの先頭要素を指す先頭ポインタ
     #queSize = 0; // キューの長さ
 
     constructor(capacity) {
         this.#nums = new Array(capacity);
     }
 
-    /* キューの容量を取得 */
+    /* キューの容量を取得する */
     get capacity() {
         return this.#nums.length;
     }
@@ -24,7 +24,7 @@ class ArrayQueue {
         return this.#queSize;
     }
 
-    /* キューが空かどうかを判定 */
+    /* キューが空か判定 */
     isEmpty() {
         return this.#queSize === 0;
     }
@@ -32,13 +32,13 @@ class ArrayQueue {
     /* エンキュー */
     push(num) {
         if (this.size === this.capacity) {
-            console.log('キューがいっぱいです');
+            console.log('キューが満杯です');
             return;
         }
-        // 末尾ポインタを計算し、末尾インデックス + 1 を指す
-        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする
+        // 末尾のインデックス + 1 を指す末尾ポインタを計算する
+        // 剰余演算で、rear が配列末尾を越えたら先頭へ戻る
         const rear = (this.#front + this.size) % this.capacity;
-        // num をキュー末尾に追加
+        // num をキューの末尾に追加する
         this.#nums[rear] = num;
         this.#queSize++;
     }
@@ -46,13 +46,13 @@ class ArrayQueue {
     /* デキュー */
     pop() {
         const num = this.peek();
-        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す
+        // 先頭ポインタを後ろに 1 つ移動し、末尾を越えたら配列の先頭に戻す
         this.#front = (this.#front + 1) % this.capacity;
         this.#queSize--;
         return num;
     }
 
-    /* キュー先頭の要素にアクセス */
+    /* キューの先頭要素にアクセス */
     peek() {
         if (this.isEmpty()) throw new Error('キューが空です');
         return this.#nums[this.#front];
@@ -60,7 +60,7 @@ class ArrayQueue {
 
     /* 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];
@@ -69,12 +69,12 @@ class ArrayQueue {
     }
 }
 
-/* Driver Code */
-/* キューを初期化 */
+/* 実行用コード */
+/* キューを初期化する */
 const capacity = 10;
 const queue = new ArrayQueue(capacity);
 
-/* 要素をエンキュー */
+/* 要素をエンキューする */
 queue.push(1);
 queue.push(3);
 queue.push(2);
@@ -82,19 +82,19 @@ queue.push(5);
 queue.push(4);
 console.log('キュー queue =', queue.toArray());
 
-/* キュー先頭の要素にアクセス */
+/* キューの先頭要素にアクセス */
 const peek = queue.peek();
-console.log('先頭要素 peek = ' + peek);
+console.log('キューの先頭要素 peek = ' + peek);
 
-/* 要素をデキュー */
+/* 要素をデキューする */
 const pop = queue.pop();
-console.log('取り出した要素 pop = ' + pop + '、取り出した後 queue =', queue.toArray());
+console.log('デキューした要素 pop = ' + pop + '、デキュー後 queue =', queue.toArray());
 
 /* キューの長さを取得 */
 const size = queue.size;
 console.log('キューの長さ size = ' + size);
 
-/* キューが空かどうかを判定 */
+/* キューが空か判定 */
 const isEmpty = queue.isEmpty();
 console.log('キューは空か = ' + isEmpty);
 
@@ -102,5 +102,5 @@ console.log('キューは空か = ' + isEmpty);
 for (let i = 0; i < 10; i++) {
     queue.push(i);
     queue.pop();
-    console.log('第 ' + i + ' 回エンキュー + デキュー後 queue =', queue.toArray());
+    console.log('第 ' + i + ' 回のエンキューとデキューの後 queue =', queue.toArray());
 }

ja/codes/javascript/chapter_stack_and_queue/array_stack.js

@@ -4,19 +4,19 @@
  * Author: S-N-O-R-L-A-X ([email protected])
  */
 
-/* 配列ベースのスタック */
+/* 配列で実装したスタック */
 class ArrayStack {
     #stack;
     constructor() {
         this.#stack = [];
     }
 
-    /* スタックの長さを取得 */
+    /* スタックの長さを取得する */
     get size() {
         return this.#stack.length;
     }
 
-    /* スタックが空かどうかを判定 */
+    /* スタックが空かどうかを判定する */
     isEmpty() {
         return this.#stack.length === 0;
     }
@@ -28,13 +28,13 @@ class ArrayStack {
 
     /* ポップ */
     pop() {
-        if (this.isEmpty()) throw new Error('スタックが空');
+        if (this.isEmpty()) throw new Error('スタックが空です');
         return this.#stack.pop();
     }
 
-    /* スタックトップの要素にアクセス */
+    /* スタックの先頭要素にアクセスする */
     top() {
-        if (this.isEmpty()) throw new Error('スタックが空');
+        if (this.isEmpty()) throw new Error('スタックが空です');
         return this.#stack[this.#stack.length - 1];
     }
 
@@ -44,11 +44,11 @@ class ArrayStack {
     }
 }
 
-/* Driver Code */
-/* スタックを初期化 */
+/* 実行用コード */
+/* スタックを初期化する */
 const stack = new ArrayStack();
 
-/* 要素をプッシュ */
+/* 要素をプッシュする */
 stack.push(1);
 stack.push(3);
 stack.push(2);
@@ -57,19 +57,19 @@ stack.push(4);
 console.log('スタック stack = ');
 console.log(stack.toArray());
 
-/* スタックトップの要素にアクセス */
+/* スタックの先頭要素にアクセスする */
 const top = stack.top();
-console.log('スタックトップ要素 top = ' + top);
+console.log('スタックの先頭要素 top = ' + top);
 
-/* 要素をポップ */
+/* 要素をポップする */
 const pop = stack.pop();
-console.log('ポップした要素 pop = ' + pop + '，ポップ後 stack = ');
+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

@@ -4,41 +4,41 @@
  * Author: Zhuo Qinyue ([email protected])
  */
 
-/* Driver Code */
-/* 両端キューを初期化 */
-// JavaScript には組み込みの両端キューがないため、Array を両端キューとして使う
+/* 実行用コード */
+/* 両端キューを初期化する */
+// JavaScript には組み込みの両端キューがないため、Array を両端キューとして使うしかない
 const deque = [];
 
-/* 要素をエンキュー */
+/* 要素をエンキューする */
 deque.push(2);
 deque.push(5);
 deque.push(4);
-// 注意: 配列であるため、unshift() メソッドの時間計算量は O(n)
+// 配列なので unshift() メソッドの時間計算量は O(n) であることに注意
 deque.unshift(3);
 deque.unshift(1);
 console.log('両端キュー deque = ', deque);
 
-/* 要素にアクセス */
+/* 要素にアクセスする */
 const peekFirst = deque[0];
-console.log('先頭要素 peekFirst = ' + peekFirst);
+console.log('キューの先頭要素 peekFirst = ' + peekFirst);
 const peekLast = deque[deque.length - 1];
-console.log('末尾要素 peekLast = ' + peekLast);
+console.log('キューの末尾要素 peekLast = ' + peekLast);
 
-/* 要素をデキュー */
-// 注意: 配列であるため、shift() メソッドの時間計算量は O(n)
+/* 要素をデキューする */
+// 配列なので shift() メソッドの時間計算量は O(n) であることに注意
 const popFront = deque.shift();
 console.log(
-    '先頭からデキューした要素 popFront = ' + popFront + '，先頭からデキュー後 deque = ' + deque
+    '先頭からデキューした要素 popFront = ' + popFront + '、先頭からデキューした後 deque = ' + deque
 );
 const popBack = deque.pop();
 console.log(
-    '末尾からデキューした要素 popBack = ' + popBack + '，末尾からデキュー後 deque = ' + deque
+    '末尾からデキューした要素 popBack = ' + popBack + '、末尾からデキューした後 deque = ' + deque
 );
 
-/* 両端キューの長さを取得 */
+/* 両端キューの長さを取得する */
 const size = deque.length;
 console.log('両端キューの長さ size = ' + size);
 
-/* 両端キューが空かどうかを判定 */
+/* 両端キューが空かどうかを判定する */
 const isEmpty = size === 0;
-console.log('両端キューが空かどうか = ' + isEmpty);
+console.log('両端キューは空か = ' + isEmpty);

ja/codes/javascript/chapter_stack_and_queue/linkedlist_deque.js

@@ -4,11 +4,11 @@
  * Author: Zhuo Qinyue ([email protected])
  */
 
-/* 双方向連結リストノード */
+/* 双方向連結リストのノード */
 class ListNode {
-    prev; // 前駆ノードへの参照（ポインタ）
-    next; // 後継ノードへの参照（ポインタ）
-    val; // ノード値
+    prev; // 前のノードへの参照（ポインタ）
+    next; // 後続ノードへの参照（ポインタ）
+    val; // ノードの値
 
     constructor(val) {
         this.val = val;
@@ -17,7 +17,7 @@ class ListNode {
     }
 }
 
-/* 双方向連結リストベースの両端キュー */
+/* 双方向連結リストで実装した両端キュー */
 class LinkedListDeque {
     #front; // 先頭ノード front
     #rear; // 末尾ノード rear
@@ -32,12 +32,12 @@ class LinkedListDeque {
     /* 末尾へのエンキュー操作 */
     pushLast(val) {
         const node = new ListNode(val);
-        // 連結リストが空なら、front と rear の両方を node に向ける
+        // 連結リストが空の場合、front と rear の両方が node を指すようにする
         if (this.#queSize === 0) {
             this.#front = node;
             this.#rear = node;
         } else {
-            // node を連結リストの末尾に追加
+            // node を連結リストの末尾に追加する
             this.#rear.next = node;
             node.prev = this.#rear;
             this.#rear = node; // 末尾ノードを更新する
@@ -48,12 +48,12 @@ class LinkedListDeque {
     /* 先頭へのエンキュー操作 */
     pushFirst(val) {
         const node = new ListNode(val);
-        // 連結リストが空なら、front と rear の両方を node に向ける
+        // 連結リストが空の場合、front と rear の両方が node を指すようにする
         if (this.#queSize === 0) {
             this.#front = node;
             this.#rear = node;
         } else {
-            // node を連結リストの先頭に追加
+            // node を連結リストの先頭に追加する
             this.#front.prev = node;
             node.next = this.#front;
             this.#front = node; // 先頭ノードを更新する
@@ -61,18 +61,18 @@ class LinkedListDeque {
         this.#queSize++;
     }
 
-    /* キュー末尾からの取り出し */
+    /* 末尾からのデキュー操作 */
     popLast() {
         if (this.#queSize === 0) {
             return null;
         }
         const value = this.#rear.val; // 末尾ノードの値を保存する
-        // 要素が1つの場合、先頭と末尾は同じノードを指す
+        // キューの長さが 1 のとき、先頭と末尾は同じノードを指す
         if (this.#queSize === 1) {
             this.#front = null;
             this.#rear = null;
         }
-        // 末尾ノードを削除
+        // 末尾ノードを削除する
         else {
             let temp = this.#rear.prev;
             temp.next = null;
@@ -83,18 +83,18 @@ class LinkedListDeque {
         return value;
     }
 
-    /* キュー先頭からの取り出し */
+    /* 先頭からのデキュー操作 */
     popFirst() {
         if (this.#queSize === 0) {
             return null;
         }
-        const value = this.#front.val; // 先頭ノードの値を保存
-        // 要素が1つの場合、先頭と末尾は同じノードを指す
+        const value = this.#front.val; // 先頭ノードの値を保存する
+        // キューの長さが 1 のとき、先頭と末尾は同じノードを指す
         if (this.#queSize === 1) {
             this.#front = null;
             this.#rear = null;
         }
-        // 先頭ノードを削除
+        // 先頭ノードを削除する
         else {
             let temp = this.#front.next;
             temp.prev = null;
@@ -105,27 +105,27 @@ class LinkedListDeque {
         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;
@@ -137,8 +137,8 @@ class LinkedListDeque {
     }
 }
 
-/* Driver Code */
-/* 両端キューを初期化 */
+/* 実行用コード */
+/* 両端キューを初期化する */
 const linkedListDeque = new LinkedListDeque();
 linkedListDeque.pushLast(3);
 linkedListDeque.pushLast(2);
@@ -146,32 +146,32 @@ linkedListDeque.pushLast(5);
 console.log('両端キュー linkedListDeque = ');
 linkedListDeque.print();
 
-/* 要素にアクセス */
+/* 要素にアクセスする */
 const peekFirst = linkedListDeque.peekFirst();
-console.log('先頭要素 peekFirst = ' + peekFirst);
+console.log('キューの先頭要素 peekFirst = ' + peekFirst);
 const peekLast = linkedListDeque.peekLast();
-console.log('末尾要素 peekLast = ' + peekLast);
+console.log('キューの末尾要素 peekLast = ' + peekLast);
 
-/* 要素をエンキュー */
+/* 要素をエンキューする */
 linkedListDeque.pushLast(4);
-console.log('要素 4 を末尾にエンキュー後 linkedListDeque = ');
+console.log('要素 4 を末尾にエンキューした後 linkedListDeque = ');
 linkedListDeque.print();
 linkedListDeque.pushFirst(1);
-console.log('要素 1 を先頭にエンキュー後 linkedListDeque = ');
+console.log('要素 1 を先頭にエンキューした後 linkedListDeque = ');
 linkedListDeque.print();
 
-/* 要素をデキュー */
+/* 要素をデキューする */
 const popLast = linkedListDeque.popLast();
-console.log('末尾からデキューした要素 = ' + popLast + '，末尾からデキュー後 linkedListDeque = ');
+console.log('末尾からデキューした要素 = ' + popLast + '、末尾からデキューした後 linkedListDeque = ');
 linkedListDeque.print();
 const popFirst = linkedListDeque.popFirst();
-console.log('先頭からデキューした要素 = ' + popFirst + '，先頭からデキュー後 linkedListDeque = ');
+console.log('先頭からデキューした要素 = ' + popFirst + '、先頭からデキューした後 linkedListDeque = ');
 linkedListDeque.print();
 
-/* 両端キューの長さを取得 */
+/* 両端キューの長さを取得する */
 const size = linkedListDeque.size();
 console.log('両端キューの長さ size = ' + size);
 
-/* 両端キューが空かどうかを判定 */
+/* 両端キューが空かどうかを判定する */
 const isEmpty = linkedListDeque.isEmpty();
-console.log('両端キューが空かどうか = ' + isEmpty);
+console.log('両端キューは空か = ' + isEmpty);

ja/codes/javascript/chapter_stack_and_queue/linkedlist_queue.js

@@ -6,7 +6,7 @@
 
 const { ListNode } = require('../modules/ListNode');
 
-/* 連結リストベースのキュー */
+/* 連結リストで実装したキュー */
 class LinkedListQueue {
     #front; // 先頭ノード #front
     #rear; // 末尾ノード #rear
@@ -22,20 +22,20 @@ class LinkedListQueue {
         return this.#queSize;
     }
 
-    /* キューが空かどうかを判定 */
+    /* キューが空か判定 */
     isEmpty() {
         return this.size === 0;
     }
 
     /* エンキュー */
     push(num) {
-        // 末尾ノードの後ろに num を追加
+        // 末尾ノードの後ろに num を追加する
         const node = new ListNode(num);
-        // キューが空なら、先頭・末尾ノードをともにそのノードに設定
+        // キューが空の場合、先頭と末尾の両方がこのノードを指すようにする
         if (!this.#front) {
             this.#front = node;
             this.#rear = node;
-            // キューが空でなければ、そのノードを末尾ノードの後ろに追加
+            // キューが空でない場合、このノードを末尾ノードの後ろに追加する
         } else {
             this.#rear.next = node;
             this.#rear = node;
@@ -46,15 +46,15 @@ class LinkedListQueue {
     /* デキュー */
     pop() {
         const num = this.peek();
-        // 先頭ノードを削除
+        // 先頭ノードを削除する
         this.#front = this.#front.next;
         this.#queSize--;
         return num;
     }
 
-    /* キュー先頭の要素にアクセス */
+    /* キューの先頭要素にアクセス */
     peek() {
-        if (this.size === 0) throw new Error('キューが空');
+        if (this.size === 0) throw new Error('キューが空です');
         return this.#front.val;
     }
 
@@ -70,11 +70,11 @@ class LinkedListQueue {
     }
 }
 
-/* Driver Code */
-/* キューを初期化 */
+/* 実行用コード */
+/* キューを初期化する */
 const queue = new LinkedListQueue();
 
-/* 要素をエンキュー */
+/* 要素をエンキューする */
 queue.push(1);
 queue.push(3);
 queue.push(2);
@@ -82,18 +82,18 @@ queue.push(5);
 queue.push(4);
 console.log('キュー queue = ' + queue.toArray());
 
-/* キュー先頭の要素にアクセス */
+/* キューの先頭要素にアクセス */
 const peek = queue.peek();
-console.log('先頭要素 peek = ' + peek);
+console.log('キューの先頭要素 peek = ' + peek);
 
-/* 要素をデキュー */
+/* 要素をデキューする */
 const pop = queue.pop();
-console.log('デキューした要素 pop = ' + pop + '，デキュー後 queue = ' + queue.toArray());
+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

@@ -6,21 +6,21 @@
 
 const { ListNode } = require('../modules/ListNode');
 
-/* 連結リストベースのスタック */
+/* 連結リストで実装したスタック */
 class LinkedListStack {
-    #stackPeek; // 先頭ノードをスタックトップとする
+    #stackPeek; // 先頭ノードをスタックの先頭とする
     #stkSize = 0; // スタックの長さ
 
     constructor() {
         this.#stackPeek = null;
     }
 
-    /* スタックの長さを取得 */
+    /* スタックの長さを取得する */
     get size() {
         return this.#stkSize;
     }
 
-    /* スタックが空かどうかを判定 */
+    /* スタックが空かどうかを判定する */
     isEmpty() {
         return this.size === 0;
     }
@@ -41,9 +41,9 @@ class LinkedListStack {
         return num;
     }
 
-    /* スタックトップの要素にアクセス */
+    /* スタックの先頭要素にアクセスする */
     peek() {
-        if (!this.#stackPeek) throw new Error('スタックが空');
+        if (!this.#stackPeek) throw new Error('スタックが空です');
         return this.#stackPeek.val;
     }
 
@@ -59,11 +59,11 @@ class LinkedListStack {
     }
 }
 
-/* Driver Code */
-/* スタックを初期化 */
+/* 実行用コード */
+/* スタックを初期化する */
 const stack = new LinkedListStack();
 
-/* 要素をプッシュ */
+/* 要素をプッシュする */
 stack.push(1);
 stack.push(3);
 stack.push(2);
@@ -71,18 +71,18 @@ stack.push(5);
 stack.push(4);
 console.log('スタック stack = ' + stack.toArray());
 
-/* スタックトップの要素にアクセス */
+/* スタックの先頭要素にアクセスする */
 const peek = stack.peek();
-console.log('スタックトップ要素 peek = ' + peek);
+console.log('スタックの先頭要素 peek = ' + peek);
 
-/* 要素をポップ */
+/* 要素をポップする */
 const pop = stack.pop();
-console.log('ポップした要素 pop = ' + pop + '，ポップ後 stack = ' + stack.toArray());
+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

@@ -4,12 +4,12 @@
  * Author: S-N-O-R-L-A-X ([email protected])
  */
 
-/* Driver Code */
-/* キューを初期化 */
-// JavaScript には組み込みのキューがないため、Array をキューとして使う
+/* 実行用コード */
+/* キューを初期化する */
+// JavaScript には組み込みのキューがないため、Array をキューとして使える
 const queue = [];
 
-/* 要素をエンキュー */
+/* 要素をエンキューする */
 queue.push(1);
 queue.push(3);
 queue.push(2);
@@ -17,19 +17,19 @@ queue.push(5);
 queue.push(4);
 console.log('キュー queue =', queue);
 
-/* キュー先頭の要素にアクセス */
+/* キューの先頭要素にアクセス */
 const peek = queue[0];
-console.log('先頭要素 peek =', peek);
+console.log('キューの先頭要素 peek =', peek);
 
-/* 要素をデキュー */
-// 基盤が配列であるため、shift() メソッドの時間計算量は O(n)
+/* 要素をデキューする */
+// 内部は配列なので、shift() メソッドの時間計算量は O(n)
 const pop = queue.shift();
-console.log('デキューした要素 pop =', pop, '，デキュー後 queue = ', queue);
+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

@@ -4,12 +4,12 @@
  * Author: S-N-O-R-L-A-X ([email protected])
  */
 
-/* Driver Code */
-/* スタックを初期化 */
-// JavaScript には組み込みのスタッククラスがないため、Array をスタックとして使う
+/* 実行用コード */
+/* スタックを初期化する */
+// JavaScript には組み込みのスタッククラスがないため、Array をスタックとして使える
 const stack = [];
 
-/* 要素をプッシュ */
+/* 要素をプッシュする */
 stack.push(1);
 stack.push(3);
 stack.push(2);
@@ -17,19 +17,19 @@ stack.push(5);
 stack.push(4);
 console.log('スタック stack =', stack);
 
-/* スタックトップの要素にアクセス */
+/* スタックの先頭要素にアクセスする */
 const peek = stack[stack.length - 1];
-console.log('スタックトップ要素 peek =', peek);
+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);