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/cpp/chapter_stack_and_queue/array_deque.cpp

@@ -6,11 +6,11 @@
 
 #include "../utils/common.hpp"
 
-/* 循環配列ベースの両端キュー */
+/* 循環配列で実装した両端キュー */
 class ArrayDeque {
   private:
     vector<int> nums; // 両端キューの要素を格納する配列
-    int front;        // 先頭ポインタ。先頭要素を指す
+    int front;        // キューの先頭要素を指す先頭ポインタ
     int queSize;      // 両端キューの長さ
 
   public:
@@ -20,91 +20,91 @@ class ArrayDeque {
         front = queSize = 0;
     }
 
-    /* 両端キューの容量を取得 */
+    /* 両端キューの容量を取得する */
     int capacity() {
         return nums.size();
     }
 
-    /* 両端キューの長さを取得 */
+    /* 両端キューの長さを取得する */
     int size() {
         return queSize;
     }
 
-    /* 両端キューが空かどうかを判定 */
+    /* 両端キューが空かどうかを判定する */
     bool isEmpty() {
         return queSize == 0;
     }
 
-    /* 循環配列のインデックスを計算 */
+    /* 循環配列のインデックスを計算する */
     int index(int i) {
-        // 剰余演算により配列の先頭と末尾をつなげる
-        // i が配列の末尾を越えたら先頭に戻る
-        // i が配列の先頭を越えて前に出たら末尾に戻る
+        // 剰余演算を使い、配列の先頭と末尾をつなぐ
+        // i が配列の末尾を越えたら、先頭に戻る
+        // i が配列の先頭を越えたら、末尾に戻る
         return (i + capacity()) % capacity();
     }
 
-    /* キュー先頭にエンキュー */
+    /* 先頭にエンキューする */
     void pushFirst(int num) {
         if (queSize == capacity()) {
-            cout << "両端キューがいっぱいです" << endl;
+            cout << "両端キューが満杯です" << endl;
             return;
         }
         // 先頭ポインタを左に 1 つ移動する
-        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする
+        // 剰余演算により、front が配列の先頭を越えたら末尾に戻るようにする
         front = index(front - 1);
-        // num をキュー先頭に追加
+        // num をキューの先頭に追加する
         nums[front] = num;
         queSize++;
     }
 
-    /* キュー末尾にエンキュー */
+    /* 末尾にエンキューする */
     void pushLast(int num) {
         if (queSize == capacity()) {
-            cout << "両端キューがいっぱいです" << endl;
+            cout << "両端キューが満杯です" << endl;
             return;
         }
-        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す
+        // 末尾のインデックス + 1 を指す末尾ポインタを計算する
         int rear = index(front + queSize);
-        // num をキュー末尾に追加
+        // num をキューの末尾に追加する
         nums[rear] = num;
         queSize++;
     }
 
-    /* キュー先頭からデキュー */
+    /* 先頭からデキューする */
     int popFirst() {
         int num = peekFirst();
-        // 先頭ポインタを 1 つ後ろへ進める
+        // 先頭ポインタを後ろに 1 つ移動する
         front = index(front + 1);
         queSize--;
         return num;
     }
 
-    /* キュー末尾からデキュー */
+    /* 末尾からデキューする */
     int popLast() {
         int num = peekLast();
         queSize--;
         return num;
     }
 
-    /* キュー先頭の要素にアクセス */
+    /* キューの先頭要素にアクセス */
     int peekFirst() {
         if (isEmpty())
             throw out_of_range("両端キューが空です");
         return nums[front];
     }
 
-    /* キュー末尾の要素にアクセス */
+    /* キューの末尾要素にアクセスする */
     int peekLast() {
         if (isEmpty())
             throw out_of_range("両端キューが空です");
-        // 末尾要素のインデックスを計算
+        // 末尾要素のインデックスを計算する
         int last = index(front + queSize - 1);
         return nums[last];
     }
 
-    /* 出力用の配列を返す */
+    /* 表示用の配列を返す */
     vector<int> toVector() {
-        // 有効長の範囲内のリスト要素のみを変換
+        // 有効な長さの範囲内にあるリストの要素だけを変換する
         vector<int> res(queSize);
         for (int i = 0, j = front; i < queSize; i++, j++) {
             res[i] = nums[index(j)];
@@ -113,9 +113,9 @@ class ArrayDeque {
     }
 };
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* 両端キューを初期化 */
+    /* 両端キューを初期化する */
     ArrayDeque *deque = new ArrayDeque(10);
     deque->pushLast(3);
     deque->pushLast(2);
@@ -123,34 +123,34 @@ int main() {
     cout << "両端キュー deque = ";
     printVector(deque->toVector());
 
-    /* 要素にアクセス */
+    /* 要素にアクセスする */
     int peekFirst = deque->peekFirst();
-    cout << "先頭要素 peekFirst = " << peekFirst << endl;
+    cout << "キューの先頭要素 peekFirst = " << peekFirst << endl;
     int peekLast = deque->peekLast();
-    cout << "末尾要素 peekLast = " << peekLast << endl;
+    cout << "キューの末尾要素 peekLast = " << peekLast << endl;
 
-    /* 要素をエンキュー */
+    /* 要素をエンキューする */
     deque->pushLast(4);
-    cout << "要素 4 を末尾に追加した後 deque = ";
+    cout << "要素 4 を末尾にエンキューした後 deque = ";
     printVector(deque->toVector());
     deque->pushFirst(1);
-    cout << "要素 1 を先頭に追加した後 deque = ";
+    cout << "要素 1 を先頭にエンキューした後 deque = ";
     printVector(deque->toVector());
 
-    /* 要素をデキュー */
+    /* 要素をデキューする */
     int popLast = deque->popLast();
-    cout << "末尾から取り出した要素 = " << popLast << "、末尾から取り出した後 deque = ";
+    cout << "末尾からデキューした要素 = " << popLast << "、末尾からデキューした後 deque = ";
     printVector(deque->toVector());
     int popFirst = deque->popFirst();
-    cout << "先頭から取り出した要素 = " << popFirst << "、先頭から取り出した後 deque = ";
+    cout << "先頭からデキューした要素 = " << popFirst << "、先頭からデキューした後 deque = ";
     printVector(deque->toVector());
 
-    /* 両端キューの長さを取得 */
+    /* 両端キューの長さを取得する */
     int size = deque->size();
     cout << "両端キューの長さ size = " << size << endl;
 
-    /* 両端キューが空かどうかを判定 */
+    /* 両端キューが空かどうかを判定する */
     bool isEmpty = deque->isEmpty();
-    cout << "両端キューが空かどうか = " << boolalpha << isEmpty << endl;
+    cout << "両端キューは空か = " << boolalpha << isEmpty << endl;
     return 0;
 }

ja/codes/cpp/chapter_stack_and_queue/array_queue.cpp

@@ -6,17 +6,17 @@
 
 #include "../utils/common.hpp"
 
-/* 循環配列ベースのキュー */
+/* 循環配列で実装したキュー */
 class ArrayQueue {
   private:
-    int *nums;       // キュー要素を格納する配列
-    int front;       // 先頭ポインタ。先頭要素を指す
+    int *nums;       // キューの要素を格納する配列
+    int front;       // キューの先頭要素を指す先頭ポインタ
     int queSize;     // キューの長さ
     int queCapacity; // キューの容量
 
   public:
     ArrayQueue(int capacity) {
-        // 配列を初期化
+        // 配列を初期化する
         nums = new int[capacity];
         queCapacity = capacity;
         front = queSize = 0;
@@ -26,7 +26,7 @@ class ArrayQueue {
         delete[] nums;
     }
 
-    /* キューの容量を取得 */
+    /* キューの容量を取得する */
     int capacity() {
         return queCapacity;
     }
@@ -36,7 +36,7 @@ class ArrayQueue {
         return queSize;
     }
 
-    /* キューが空かどうかを判定 */
+    /* キューが空か判定 */
     bool isEmpty() {
         return size() == 0;
     }
@@ -44,13 +44,13 @@ class ArrayQueue {
     /* エンキュー */
     void push(int num) {
         if (queSize == queCapacity) {
-            cout << "キューがいっぱいです" << endl;
+            cout << "キューが満杯です" << endl;
             return;
         }
-        // 末尾ポインタを計算し、末尾インデックス + 1 を指す
-        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする
+        // 末尾のインデックス + 1 を指す末尾ポインタを計算する
+        // 剰余演算で、rear が配列末尾を越えたら先頭へ戻る
         int rear = (front + queSize) % queCapacity;
-        // num をキュー末尾に追加
+        // num をキューの末尾に追加する
         nums[rear] = num;
         queSize++;
     }
@@ -58,13 +58,13 @@ class ArrayQueue {
     /* デキュー */
     int pop() {
         int num = peek();
-        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す
+        // 先頭ポインタを後ろに 1 つ移動し、末尾を越えたら配列の先頭に戻す
         front = (front + 1) % queCapacity;
         queSize--;
         return num;
     }
 
-    /* キュー先頭の要素にアクセス */
+    /* キューの先頭要素にアクセス */
     int peek() {
         if (isEmpty())
             throw out_of_range("キューが空です");
@@ -73,7 +73,7 @@ class ArrayQueue {
 
     /* 配列を Vector に変換して返す */
     vector<int> toVector() {
-        // 有効長の範囲内のリスト要素のみを変換
+        // 有効な長さの範囲内にあるリストの要素だけを変換する
         vector<int> arr(queSize);
         for (int i = 0, j = front; i < queSize; i++, j++) {
             arr[i] = nums[j % queCapacity];
@@ -82,13 +82,13 @@ class ArrayQueue {
     }
 };
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* キューを初期化 */
+    /* キューを初期化する */
     int capacity = 10;
     ArrayQueue *queue = new ArrayQueue(capacity);
 
-    /* 要素をエンキュー */
+    /* 要素をエンキューする */
     queue->push(1);
     queue->push(3);
     queue->push(2);
@@ -97,28 +97,28 @@ int main() {
     cout << "キュー queue = ";
     printVector(queue->toVector());
 
-    /* キュー先頭の要素にアクセス */
+    /* キューの先頭要素にアクセス */
     int peek = queue->peek();
-    cout << "先頭要素 peek = " << peek << endl;
+    cout << "キューの先頭要素 peek = " << peek << endl;
 
-    /* 要素をデキュー */
+    /* 要素をデキューする */
     peek = queue->pop();
-    cout << "取り出した要素 pop = " << peek << "、取り出し後の queue = ";
+    cout << "デキューした要素 pop = " << peek << "、デキュー後 queue = ";
     printVector(queue->toVector());
 
     /* キューの長さを取得 */
     int size = queue->size();
     cout << "キューの長さ size = " << size << endl;
 
-    /* キューが空かどうかを判定 */
+    /* キューが空か判定 */
     bool empty = queue->isEmpty();
-    cout << "キューが空かどうか = " << empty << endl;
+    cout << "キューは空か = " << empty << endl;
 
     /* 循環配列をテストする */
     for (int i = 0; i < 10; i++) {
         queue->push(i);
         queue->pop();
-        cout << "第 " << i << " 回のエンキュー + デキュー後の queue = ";
+        cout << "第 " << i << " 回のエンキューとデキューの後 queue = ";
         printVector(queue->toVector());
     }
 

ja/codes/cpp/chapter_stack_and_queue/array_stack.cpp

@@ -6,18 +6,18 @@
 
 #include "../utils/common.hpp"
 
-/* 配列ベースのスタック */
+/* 配列で実装したスタック */
 class ArrayStack {
   private:
     vector<int> stack;
 
   public:
-    /* スタックの長さを取得 */
+    /* スタックの長さを取得する */
     int size() {
         return stack.size();
     }
 
-    /* スタックが空かどうかを判定 */
+    /* スタックが空かどうかを判定する */
     bool isEmpty() {
         return stack.size() == 0;
     }
@@ -34,7 +34,7 @@ class ArrayStack {
         return num;
     }
 
-    /* スタックトップの要素にアクセス */
+    /* スタックの先頭要素にアクセスする */
     int top() {
         if (isEmpty())
             throw out_of_range("スタックが空です");
@@ -47,12 +47,12 @@ class ArrayStack {
     }
 };
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* スタックを初期化 */
+    /* スタックを初期化する */
     ArrayStack *stack = new ArrayStack();
 
-    /* 要素をプッシュ */
+    /* 要素をプッシュする */
     stack->push(1);
     stack->push(3);
     stack->push(2);
@@ -61,22 +61,22 @@ int main() {
     cout << "スタック stack = ";
     printVector(stack->toVector());
 
-    /* スタックトップの要素にアクセス */
+    /* スタックの先頭要素にアクセスする */
     int top = stack->top();
-    cout << "トップ要素 top = " << top << endl;
+    cout << "スタックの先頭要素 top = " << top << endl;
 
-    /* 要素をポップ */
+    /* 要素をポップする */
     top = stack->pop();
-    cout << "取り出した要素 pop = " << top << "、取り出し後の stack = ";
+    cout << "ポップした要素 pop = " << top << "、ポップ後 stack = ";
     printVector(stack->toVector());
 
-    /* スタックの長さを取得 */
+    /* スタックの長さを取得する */
     int size = stack->size();
     cout << "スタックの長さ size = " << size << endl;
 
-    /* 空かどうかを判定 */
+    /* 空かどうかを判定する */
     bool empty = stack->isEmpty();
-    cout << "スタックが空かどうか = " << empty << endl;
+    cout << "スタックは空か = " << empty << endl;
 
     // メモリを解放する
     delete stack;

ja/codes/cpp/chapter_stack_and_queue/deque.cpp

@@ -6,12 +6,12 @@
 
 #include "../utils/common.hpp"
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* 両端キューを初期化 */
+    /* 両端キューを初期化する */
     deque<int> deque;
 
-    /* 要素をエンキュー */
+    /* 要素をエンキューする */
     deque.push_back(2);
     deque.push_back(5);
     deque.push_back(4);
@@ -20,27 +20,27 @@ int main() {
     cout << "両端キュー deque = ";
     printDeque(deque);
 
-    /* 要素にアクセス */
+    /* 要素にアクセスする */
     int front = deque.front();
-    cout << "先頭要素 front = " << front << endl;
+    cout << "キューの先頭要素 front = " << front << endl;
     int back = deque.back();
-    cout << "末尾要素 back = " << back << endl;
+    cout << "キューの末尾要素 back = " << back << endl;
 
-    /* 要素をデキュー */
+    /* 要素をデキューする */
     deque.pop_front();
-    cout << "先頭から取り出した要素 popFront = " << front << "、先頭から取り出した後の deque = ";
+    cout << "先頭からデキューした要素 popFront = " << front << "、先頭からデキューした後 deque = ";
     printDeque(deque);
     deque.pop_back();
-    cout << "末尾から取り出した要素 popLast = " << back << "、末尾から取り出した後の deque = ";
+    cout << "末尾からデキューした要素 popLast = " << back << "、末尾からデキューした後 deque = ";
     printDeque(deque);
 
-    /* 両端キューの長さを取得 */
+    /* 両端キューの長さを取得する */
     int size = deque.size();
     cout << "両端キューの長さ size = " << size << endl;
 
-    /* 両端キューが空かどうかを判定 */
+    /* 両端キューが空かどうかを判定する */
     bool empty = deque.empty();
-    cout << "両端キューが空かどうか = " << empty << endl;
+    cout << "両端キューは空か = " << empty << endl;
 
     return 0;
 }

ja/codes/cpp/chapter_stack_and_queue/linkedlist_deque.cpp

@@ -6,19 +6,19 @@
 
 #include "../utils/common.hpp"
 
-/* 双方向連結リストノード */
+/* 双方向連結リストのノード */
 struct DoublyListNode {
-    int val;              // ノード値
-    DoublyListNode *next; // 後継ノードへのポインタ
-    DoublyListNode *prev; // 前駆ノードへのポインタ
+    int val;              // ノードの値
+    DoublyListNode *next; // 後続ノードへのポインタ
+    DoublyListNode *prev; // 前のノードへのポインタ
     DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {
     }
 };
 
-/* 双方向連結リストベースの両端キュー */
+/* 双方向連結リストで実装した両端キュー */
 class LinkedListDeque {
   private:
-    DoublyListNode *front, *rear; // 先頭ノード front、末尾ノード rear
+    DoublyListNode *front, *rear; // 先頭ノード front 、末尾ノード rear
     int queSize = 0;              // 両端キューの長さ
 
   public:
@@ -26,7 +26,7 @@ class LinkedListDeque {
     LinkedListDeque() : front(nullptr), rear(nullptr) {
     }
 
-    /* デストラクタメソッド */
+    /* デストラクタ */
     ~LinkedListDeque() {
         // 連結リストを走査してノードを削除し、メモリを解放する
         DoublyListNode *pre, *cur = front;
@@ -37,12 +37,12 @@ class LinkedListDeque {
         }
     }
 
-    /* 両端キューの長さを取得 */
+    /* 両端キューの長さを取得する */
     int size() {
         return queSize;
     }
 
-    /* 両端キューが空かどうかを判定 */
+    /* 両端キューが空かどうかを判定する */
     bool isEmpty() {
         return size() == 0;
     }
@@ -50,31 +50,31 @@ class LinkedListDeque {
     /* エンキュー操作 */
     void push(int num, bool isFront) {
         DoublyListNode *node = new DoublyListNode(num);
-        // 連結リストが空なら、front と rear の両方を node に向ける
+        // 連結リストが空の場合、front と rear の両方が node を指すようにする
         if (isEmpty())
             front = rear = node;
         // 先頭へのエンキュー操作
         else if (isFront) {
-            // node を連結リストの先頭に追加
+            // node を連結リストの先頭に追加する
             front->prev = node;
             node->next = front;
             front = node; // 先頭ノードを更新する
         // 末尾へのエンキュー操作
         } else {
-            // node を連結リストの末尾に追加
+            // node を連結リストの末尾に追加する
             rear->next = node;
             node->prev = rear;
             rear = node; // 末尾ノードを更新する
         }
-        queSize++; // キューの長さを更新
+        queSize++; // キューの長さを更新する
     }
 
-    /* キュー先頭にエンキュー */
+    /* 先頭にエンキューする */
     void pushFirst(int num) {
         push(num, true);
     }
 
-    /* キュー末尾にエンキュー */
+    /* 末尾にエンキューする */
     void pushLast(int num) {
         push(num, false);
     }
@@ -84,61 +84,61 @@ class LinkedListDeque {
         if (isEmpty())
             throw out_of_range("キューが空です");
         int val;
-        // 要素が1つの場合、先頭と末尾は同じノードを指す
+        // キューの長さが 1 のとき、先頭と末尾は同じノードを指す
         if (queSize == 1) {
             val = front->val;
-            delete front; // 同じノードを一度だけ解放する
+            delete front; // 同じノードを指しているため、片方を解放すればよい
             front = nullptr;
             rear = nullptr;
         }
-        // キュー先頭からの取り出し
+        // 先頭からのデキュー操作
         else if (isFront) {
-            val = front->val; // 先頭ノードの値を一時保存
-            // 先頭ノードを削除
+            val = front->val; // 先頭ノードの値を一時保存する
+            // 先頭ノードを削除する
             DoublyListNode *fNext = front->next;
             fNext->prev = nullptr;
             front->next = nullptr;
             delete front;
             front = fNext; // 先頭ノードを更新する
-        // キュー末尾からの取り出し
+        // 末尾からのデキュー操作
         } else {
-            val = rear->val; // 末尾ノードの値を一時保存
-            // 末尾ノードを削除
+            val = rear->val; // 末尾ノードの値を一時保存する
+            // 末尾ノードを削除する
             DoublyListNode *rPrev = rear->prev;
             rPrev->next = nullptr;
             rear->prev = nullptr;
             delete rear;
             rear = rPrev; // 末尾ノードを更新する
         }
-        queSize--; // キューの長さを更新
+        queSize--; // キューの長さを更新する
         return val;
     }
 
-    /* キュー先頭からデキュー */
+    /* 先頭からデキューする */
     int popFirst() {
         return pop(true);
     }
 
-    /* キュー末尾からデキュー */
+    /* 末尾からデキューする */
     int popLast() {
         return pop(false);
     }
 
-    /* キュー先頭の要素にアクセス */
+    /* キューの先頭要素にアクセス */
     int peekFirst() {
         if (isEmpty())
             throw out_of_range("両端キューが空です");
         return front->val;
     }
 
-    /* キュー末尾の要素にアクセス */
+    /* キューの末尾要素にアクセスする */
     int peekLast() {
         if (isEmpty())
             throw out_of_range("両端キューが空です");
         return rear->val;
     }
 
-    /* 出力用の配列を返す */
+    /* 表示用の配列を返す */
     vector<int> toVector() {
         DoublyListNode *node = front;
         vector<int> res(size());
@@ -150,9 +150,9 @@ class LinkedListDeque {
     }
 };
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* 両端キューを初期化 */
+    /* 両端キューを初期化する */
     LinkedListDeque *deque = new LinkedListDeque();
     deque->pushLast(3);
     deque->pushLast(2);
@@ -160,35 +160,35 @@ int main() {
     cout << "両端キュー deque = ";
     printVector(deque->toVector());
 
-    /* 要素にアクセス */
+    /* 要素にアクセスする */
     int peekFirst = deque->peekFirst();
-    cout << "先頭要素 peekFirst = " << peekFirst << endl;
+    cout << "キューの先頭要素 peekFirst = " << peekFirst << endl;
     int peekLast = deque->peekLast();
-    cout << "末尾要素 peekLast = " << peekLast << endl;
+    cout << "キューの末尾要素 peekLast = " << peekLast << endl;
 
-    /* 要素をエンキュー */
+    /* 要素をエンキューする */
     deque->pushLast(4);
-    cout << "要素 4 を末尾に追加した後の deque =";
+    cout << "要素 4 を末尾にエンキューした後 deque =";
     printVector(deque->toVector());
     deque->pushFirst(1);
-    cout << "要素 1 を先頭に追加した後 deque = ";
+    cout << "要素 1 を先頭にエンキューした後 deque = ";
     printVector(deque->toVector());
 
-    /* 要素をデキュー */
+    /* 要素をデキューする */
     int popLast = deque->popLast();
-    cout << "末尾から取り出した要素 = " << popLast << "、末尾から取り出した後 deque = ";
+    cout << "末尾からデキューした要素 = " << popLast << "、末尾からデキューした後 deque = ";
     printVector(deque->toVector());
     int popFirst = deque->popFirst();
-    cout << "先頭から取り出した要素 = " << popFirst << "、先頭から取り出した後 deque = ";
+    cout << "先頭からデキューした要素 = " << popFirst << "、先頭からデキューした後 deque = ";
     printVector(deque->toVector());
 
-    /* 両端キューの長さを取得 */
+    /* 両端キューの長さを取得する */
     int size = deque->size();
     cout << "両端キューの長さ size = " << size << endl;
 
-    /* 両端キューが空かどうかを判定 */
+    /* 両端キューが空かどうかを判定する */
     bool isEmpty = deque->isEmpty();
-    cout << "両端キューが空かどうか = " << boolalpha << isEmpty << endl;
+    cout << "両端キューは空か = " << boolalpha << isEmpty << endl;
 
     // メモリを解放する
     delete deque;

ja/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp

@@ -6,10 +6,10 @@
 
 #include "../utils/common.hpp"
 
-/* 連結リストベースのキュー */
+/* 連結リストで実装したキュー */
 class LinkedListQueue {
   private:
-    ListNode *front, *rear; // 先頭ノード front、末尾ノード rear
+    ListNode *front, *rear; // 先頭ノード front 、末尾ノード rear
     int queSize;
 
   public:
@@ -29,21 +29,21 @@ class LinkedListQueue {
         return queSize;
     }
 
-    /* キューが空かどうかを判定 */
+    /* キューが空か判定 */
     bool isEmpty() {
         return queSize == 0;
     }
 
     /* エンキュー */
     void push(int num) {
-        // 末尾ノードの後ろに num を追加
+        // 末尾ノードの後ろに num を追加する
         ListNode *node = new ListNode(num);
-        // キューが空なら、先頭・末尾ノードをともにそのノードに設定
+        // キューが空の場合、先頭と末尾の両方がこのノードを指すようにする
         if (front == nullptr) {
             front = node;
             rear = node;
         }
-        // キューが空でなければ、そのノードを末尾ノードの後ろに追加
+        // キューが空でない場合、このノードを末尾ノードの後ろに追加する
         else {
             rear->next = node;
             rear = node;
@@ -54,7 +54,7 @@ class LinkedListQueue {
     /* デキュー */
     int pop() {
         int num = peek();
-        // 先頭ノードを削除
+        // 先頭ノードを削除する
         ListNode *tmp = front;
         front = front->next;
         // メモリを解放する
@@ -63,7 +63,7 @@ class LinkedListQueue {
         return num;
     }
 
-    /* キュー先頭の要素にアクセス */
+    /* キューの先頭要素にアクセス */
     int peek() {
         if (size() == 0)
             throw out_of_range("キューが空です");
@@ -82,12 +82,12 @@ class LinkedListQueue {
     }
 };
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* キューを初期化 */
+    /* キューを初期化する */
     LinkedListQueue *queue = new LinkedListQueue();
 
-    /* 要素をエンキュー */
+    /* 要素をエンキューする */
     queue->push(1);
     queue->push(3);
     queue->push(2);
@@ -96,22 +96,22 @@ int main() {
     cout << "キュー queue = ";
     printVector(queue->toVector());
 
-    /* キュー先頭の要素にアクセス */
+    /* キューの先頭要素にアクセス */
     int peek = queue->peek();
-    cout << "先頭要素 peek = " << peek << endl;
+    cout << "キューの先頭要素 peek = " << peek << endl;
 
-    /* 要素をデキュー */
+    /* 要素をデキューする */
     peek = queue->pop();
-    cout << "取り出した要素 pop = " << peek << "、取り出し後の queue = ";
+    cout << "デキューした要素 pop = " << peek << "、デキュー後 queue = ";
     printVector(queue->toVector());
 
     /* キューの長さを取得 */
     int size = queue->size();
     cout << "キューの長さ size = " << size << endl;
 
-    /* キューが空かどうかを判定 */
+    /* キューが空か判定 */
     bool empty = queue->isEmpty();
-    cout << "キューが空かどうか = " << empty << endl;
+    cout << "キューは空か = " << empty << endl;
 
     // メモリを解放する
     delete queue;

ja/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp

@@ -6,10 +6,10 @@
 
 #include "../utils/common.hpp"
 
-/* 連結リストベースのスタック */
+/* 連結リストで実装したスタック */
 class LinkedListStack {
   private:
-    ListNode *stackTop; // 先頭ノードをスタックトップとする
+    ListNode *stackTop; // 先頭ノードをスタックの先頭とする
     int stkSize;        // スタックの長さ
 
   public:
@@ -23,12 +23,12 @@ class LinkedListStack {
         freeMemoryLinkedList(stackTop);
     }
 
-    /* スタックの長さを取得 */
+    /* スタックの長さを取得する */
     int size() {
         return stkSize;
     }
 
-    /* スタックが空かどうかを判定 */
+    /* スタックが空かどうかを判定する */
     bool isEmpty() {
         return size() == 0;
     }
@@ -52,7 +52,7 @@ class LinkedListStack {
         return num;
     }
 
-    /* スタックトップの要素にアクセス */
+    /* スタックの先頭要素にアクセスする */
     int top() {
         if (isEmpty())
             throw out_of_range("スタックが空です");
@@ -71,12 +71,12 @@ class LinkedListStack {
     }
 };
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* スタックを初期化 */
+    /* スタックを初期化する */
     LinkedListStack *stack = new LinkedListStack();
 
-    /* 要素をプッシュ */
+    /* 要素をプッシュする */
     stack->push(1);
     stack->push(3);
     stack->push(2);
@@ -85,22 +85,22 @@ int main() {
     cout << "スタック stack = ";
     printVector(stack->toVector());
 
-    /* スタックトップの要素にアクセス */
+    /* スタックの先頭要素にアクセスする */
     int top = stack->top();
-    cout << "トップ要素 top = " << top << endl;
+    cout << "スタックの先頭要素 top = " << top << endl;
 
-    /* 要素をポップ */
+    /* 要素をポップする */
     top = stack->pop();
-    cout << "取り出した要素 pop = " << top << "、取り出し後の stack = ";
+    cout << "ポップした要素 pop = " << top << "、ポップ後 stack = ";
     printVector(stack->toVector());
 
-    /* スタックの長さを取得 */
+    /* スタックの長さを取得する */
     int size = stack->size();
     cout << "スタックの長さ size = " << size << endl;
 
-    /* 空かどうかを判定 */
+    /* 空かどうかを判定する */
     bool empty = stack->isEmpty();
-    cout << "スタックが空かどうか = " << empty << endl;
+    cout << "スタックは空か = " << empty << endl;
 
     // メモリを解放する
     delete stack;

ja/codes/cpp/chapter_stack_and_queue/queue.cpp

@@ -6,12 +6,12 @@
 
 #include "../utils/common.hpp"
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* キューを初期化 */
+    /* キューを初期化する */
     queue<int> queue;
 
-    /* 要素をエンキュー */
+    /* 要素をエンキューする */
     queue.push(1);
     queue.push(3);
     queue.push(2);
@@ -20,22 +20,22 @@ int main() {
     cout << "キュー queue = ";
     printQueue(queue);
 
-    /* キュー先頭の要素にアクセス */
+    /* キューの先頭要素にアクセス */
     int front = queue.front();
-    cout << "先頭要素 front = " << front << endl;
+    cout << "キューの先頭要素 front = " << front << endl;
 
-    /* 要素をデキュー */
+    /* 要素をデキューする */
     queue.pop();
-    cout << "取り出した要素 front = " << front << "、取り出し後の queue = ";
+    cout << "デキューした要素 front = " << front << "、デキュー後 queue = ";
     printQueue(queue);
 
     /* キューの長さを取得 */
     int size = queue.size();
     cout << "キューの長さ size = " << size << endl;
 
-    /* キューが空かどうかを判定 */
+    /* キューが空か判定 */
     bool empty = queue.empty();
-    cout << "キューが空かどうか = " << empty << endl;
+    cout << "キューは空か = " << empty << endl;
 
     return 0;
 }

ja/codes/cpp/chapter_stack_and_queue/stack.cpp

@@ -6,12 +6,12 @@
 
 #include "../utils/common.hpp"
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* スタックを初期化 */
+    /* スタックを初期化する */
     stack<int> stack;
 
-    /* 要素をプッシュ */
+    /* 要素をプッシュする */
     stack.push(1);
     stack.push(3);
     stack.push(2);
@@ -20,22 +20,22 @@ int main() {
     cout << "スタック stack = ";
     printStack(stack);
 
-    /* スタックトップの要素にアクセス */
+    /* スタックの先頭要素にアクセスする */
     int top = stack.top();
-    cout << "トップ要素 top = " << top << endl;
+    cout << "スタックの先頭要素 top = " << top << endl;
 
-    /* 要素をポップ */
+    /* 要素をポップする */
     stack.pop(); // 戻り値なし
-    cout << "取り出した要素 pop = " << top << "、取り出し後の stack = ";
+    cout << "ポップした要素 pop = " << top << "、ポップ後 stack = ";
     printStack(stack);
 
-    /* スタックの長さを取得 */
+    /* スタックの長さを取得する */
     int size = stack.size();
     cout << "スタックの長さ size = " << size << endl;
 
-    /* 空かどうかを判定 */
+    /* 空かどうかを判定する */
     bool empty = stack.empty();
-    cout << "スタックが空かどうか = " << empty << endl;
+    cout << "スタックは空か = " << empty << endl;
 
     return 0;
 }