Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/cpp/chapter_stack_and_queue/CMakeLists.txt

@@ -0,0 +1,9 @@
+add_executable(array_deque array_deque.cpp)
+add_executable(array_queue array_queue.cpp)
+add_executable(array_stack array_stack.cpp)
+add_executable(deque deque.cpp)
+add_executable(linkedlist_deque linkedlist_deque.cpp)
+add_executable(linkedlist_queue linkedlist_queue.cpp)
+add_executable(linkedlist_stack linkedlist_stack.cpp)
+add_executable(queue queue.cpp)
+add_executable(stack stack.cpp)

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:
@@ -37,74 +37,74 @@ class ArrayDeque {
 
     /* 循環配列のインデックスを計算 */
     int index(int i) {
-        // 剰余演算で循環配列を実現
-        // iが配列の末尾を超えた場合、先頭に戻る
-        // iが配列の先頭を超えた場合、末尾に戻る
+        // 剰余演算により配列の先頭と末尾をつなげる
+        // i が配列の末尾を越えたら先頭に戻る
+        // i が配列の先頭を越えて前に出たら末尾に戻る
         return (i + capacity()) % capacity();
     }
 
-    /* 先頭エンキュー */
+    /* キュー先頭にエンキュー */
     void pushFirst(int num) {
         if (queSize == capacity()) {
-            cout << "Double-ended queue is full" << endl;
+            cout << "両端キューがいっぱいです" << endl;
             return;
         }
-        // 先頭ポインタを1つ左に移動
-        // 剰余演算でfrontが配列の先頭を越えて末尾に戻ることを実現
+        // 先頭ポインタを左に 1 つ移動する
+        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする
         front = index(front - 1);
-        // numを先頭に追加
+        // num をキュー先頭に追加
         nums[front] = num;
         queSize++;
     }
 
-    /* 末尾エンキュー */
+    /* キュー末尾にエンキュー */
     void pushLast(int num) {
         if (queSize == capacity()) {
-            cout << "Double-ended queue is full" << 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("Double-ended queue is empty");
+            throw out_of_range("両端キューが空です");
         return nums[front];
     }
 
-    /* 末尾要素にアクセス */
+    /* キュー末尾の要素にアクセス */
     int peekLast() {
         if (isEmpty())
-            throw out_of_range("Double-ended queue is empty");
+            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,44 +113,44 @@ class ArrayDeque {
     }
 };
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     /* 両端キューを初期化 */
     ArrayDeque *deque = new ArrayDeque(10);
     deque->pushLast(3);
     deque->pushLast(2);
     deque->pushLast(5);
-    cout << "Double-ended queue deque = ";
+    cout << "両端キュー deque = ";
     printVector(deque->toVector());
 
     /* 要素にアクセス */
     int peekFirst = deque->peekFirst();
-    cout << "Front element peekFirst = " << peekFirst << endl;
+    cout << "先頭要素 peekFirst = " << peekFirst << endl;
     int peekLast = deque->peekLast();
-    cout << "Back element peekLast = " << peekLast << endl;
+    cout << "末尾要素 peekLast = " << peekLast << endl;
 
-    /* 要素エンキュー */
+    /* 要素をエンキュー */
     deque->pushLast(4);
-    cout << "Element 4 enqueued at the tail, deque = ";
+    cout << "要素 4 を末尾に追加した後 deque = ";
     printVector(deque->toVector());
     deque->pushFirst(1);
-    cout << "Element 1 enqueued at the head, deque = ";
+    cout << "要素 1 を先頭に追加した後 deque = ";
     printVector(deque->toVector());
 
-    /* 要素デキュー */
+    /* 要素をデキュー */
     int popLast = deque->popLast();
-    cout << "Deque tail element = " << popLast << ", after dequeuing from the tail";
+    cout << "末尾から取り出した要素 = " << popLast << "、末尾から取り出した後 deque = ";
     printVector(deque->toVector());
     int popFirst = deque->popFirst();
-    cout << "Deque front element = " << popFirst << ", after dequeuing from the front";
+    cout << "先頭から取り出した要素 = " << popFirst << "、先頭から取り出した後 deque = ";
     printVector(deque->toVector());
 
     /* 両端キューの長さを取得 */
     int size = deque->size();
-    cout << "Length of the double-ended queue size = " << size << endl;
+    cout << "両端キューの長さ size = " << size << endl;
 
     /* 両端キューが空かどうかを判定 */
     bool isEmpty = deque->isEmpty();
-    cout << "Is the double-ended queue empty = " << boolalpha << isEmpty << endl;
+    cout << "両端キューが空かどうか = " << boolalpha << isEmpty << endl;
     return 0;
-}
+}

ja/codes/cpp/chapter_stack_and_queue/array_queue.cpp

@@ -6,11 +6,11 @@
 
 #include "../utils/common.hpp"
 
-/* 循環配列に基づくキュークラス */
+/* 循環配列ベースのキュー */
 class ArrayQueue {
   private:
     int *nums;       // キュー要素を格納する配列
-    int front;       // 先頭ポインタ、先頭要素を指す
+    int front;       // 先頭ポインタ。先頭要素を指す
     int queSize;     // キューの長さ
     int queCapacity; // キューの容量
 
@@ -44,13 +44,13 @@ class ArrayQueue {
     /* エンキュー */
     void push(int num) {
         if (queSize == queCapacity) {
-            cout << "Queue is full" << endl;
+            cout << "キューがいっぱいです" << endl;
             return;
         }
-        // 末尾ポインタを計算、末尾インデックス + 1を指す
-        // 剰余演算を使用して末尾ポインタが配列の末尾から先頭に戻るようにラップ
+        // 末尾ポインタを計算し、末尾インデックス + 1 を指す
+        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする
         int rear = (front + queSize) % queCapacity;
-        // numを末尾に追加
+        // num をキュー末尾に追加
         nums[rear] = num;
         queSize++;
     }
@@ -58,22 +58,22 @@ class ArrayQueue {
     /* デキュー */
     int pop() {
         int num = peek();
-        // 先頭ポインタを1つ後ろに移動、末尾を超えた場合は配列の先頭に戻る
+        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す
         front = (front + 1) % queCapacity;
         queSize--;
         return num;
     }
 
-    /* 先頭要素にアクセス */
+    /* キュー先頭の要素にアクセス */
     int peek() {
         if (isEmpty())
-            throw out_of_range("Queue is empty");
+            throw out_of_range("キューが空です");
         return nums[front];
     }
 
-    /* 配列をVectorに変換して返却 */
+    /* 配列を Vector に変換して返す */
     vector<int> toVector() {
-        // 有効な長さ範囲内の要素のみを変換
+        // 有効長の範囲内のリスト要素のみを変換
         vector<int> arr(queSize);
         for (int i = 0, j = front; i < queSize; i++, j++) {
             arr[i] = nums[j % queCapacity];
@@ -82,48 +82,48 @@ class ArrayQueue {
     }
 };
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     /* キューを初期化 */
     int capacity = 10;
     ArrayQueue *queue = new ArrayQueue(capacity);
 
-    /* 要素エンキュー */
+    /* 要素をエンキュー */
     queue->push(1);
     queue->push(3);
     queue->push(2);
     queue->push(5);
     queue->push(4);
-    cout << "Queue queue = ";
+    cout << "キュー queue = ";
     printVector(queue->toVector());
 
-    /* 先頭要素にアクセス */
+    /* キュー先頭の要素にアクセス */
     int peek = queue->peek();
-    cout << "Front element peek = " << peek << endl;
+    cout << "先頭要素 peek = " << peek << endl;
 
-    /* 要素デキュー */
+    /* 要素をデキュー */
     peek = queue->pop();
-    cout << "Element dequeued = " << peek << ", after dequeuing";
+    cout << "取り出した要素 pop = " << peek << "、取り出し後の queue = ";
     printVector(queue->toVector());
 
     /* キューの長さを取得 */
     int size = queue->size();
-    cout << "Length of the queue size = " << size << endl;
+    cout << "キューの長さ size = " << size << endl;
 
     /* キューが空かどうかを判定 */
     bool empty = queue->isEmpty();
-    cout << "Is the queue empty = " << empty << endl;
+    cout << "キューが空かどうか = " << empty << endl;
 
-    /* 循環配列をテスト */
+    /* 循環配列をテストする */
     for (int i = 0; i < 10; i++) {
         queue->push(i);
         queue->pop();
-        cout << "After the " << i << "th round of enqueueing + dequeuing, queue = ";
+        cout << "第 " << i << " 回のエンキュー + デキュー後の queue = ";
         printVector(queue->toVector());
     }
 
-    // メモリを解放
+    // メモリを解放する
     delete queue;
 
     return 0;
-}
+}

ja/codes/cpp/chapter_stack_and_queue/array_stack.cpp

@@ -6,7 +6,7 @@
 
 #include "../utils/common.hpp"
 
-/* 配列に基づくスタッククラス */
+/* 配列ベースのスタック */
 class ArrayStack {
   private:
     vector<int> stack;
@@ -34,52 +34,52 @@ class ArrayStack {
         return num;
     }
 
-    /* スタックトップ要素にアクセス */
+    /* スタックトップの要素にアクセス */
     int top() {
         if (isEmpty())
-            throw out_of_range("Stack is empty");
+            throw out_of_range("スタックが空です");
         return stack.back();
     }
 
-    /* Vectorを返却 */
+    /* Vector を返す */
     vector<int> toVector() {
         return stack;
     }
 };
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     /* スタックを初期化 */
     ArrayStack *stack = new ArrayStack();
 
-    /* 要素プッシュ */
+    /* 要素をプッシュ */
     stack->push(1);
     stack->push(3);
     stack->push(2);
     stack->push(5);
     stack->push(4);
-    cout << "Stack stack = ";
+    cout << "スタック stack = ";
     printVector(stack->toVector());
 
-    /* スタックトップ要素にアクセス */
+    /* スタックトップの要素にアクセス */
     int top = stack->top();
-    cout << "Top element of the stack top = " << top << endl;
+    cout << "トップ要素 top = " << top << endl;
 
-    /* 要素ポップ */
+    /* 要素をポップ */
     top = stack->pop();
-    cout << "Element popped from the stack = " << top << ", after popping";
+    cout << "取り出した要素 pop = " << top << "、取り出し後の stack = ";
     printVector(stack->toVector());
 
     /* スタックの長さを取得 */
     int size = stack->size();
-    cout << "Length of the stack size = " << size << endl;
+    cout << "スタックの長さ size = " << size << endl;
 
     /* 空かどうかを判定 */
     bool empty = stack->isEmpty();
-    cout << "Is the stack empty = " << empty << endl;
+    cout << "スタックが空かどうか = " << empty << endl;
 
-    // メモリを解放
+    // メモリを解放する
     delete stack;
 
     return 0;
-}
+}

ja/codes/cpp/chapter_stack_and_queue/deque.cpp

@@ -6,41 +6,41 @@
 
 #include "../utils/common.hpp"
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     /* 両端キューを初期化 */
     deque<int> deque;
 
-    /* 要素エンキュー */
+    /* 要素をエンキュー */
     deque.push_back(2);
     deque.push_back(5);
     deque.push_back(4);
     deque.push_front(3);
     deque.push_front(1);
-    cout << "Double-ended queue deque = ";
+    cout << "両端キュー deque = ";
     printDeque(deque);
 
     /* 要素にアクセス */
     int front = deque.front();
-    cout << "Front element of the queue front = " << front << endl;
+    cout << "先頭要素 front = " << front << endl;
     int back = deque.back();
-    cout << "Back element of the queue back = " << back << endl;
+    cout << "末尾要素 back = " << back << endl;
 
-    /* 要素デキュー */
+    /* 要素をデキュー */
     deque.pop_front();
-    cout << "Front element dequeued = " << front << ", after dequeuing from the front";
+    cout << "先頭から取り出した要素 popFront = " << front << "、先頭から取り出した後の deque = ";
     printDeque(deque);
     deque.pop_back();
-    cout << "Back element dequeued = " << back << ", after dequeuing from the back";
+    cout << "末尾から取り出した要素 popLast = " << back << "、末尾から取り出した後の deque = ";
     printDeque(deque);
 
     /* 両端キューの長さを取得 */
     int size = deque.size();
-    cout << "Length of the double-ended queue size = " << size << endl;
+    cout << "両端キューの長さ size = " << size << endl;
 
     /* 両端キューが空かどうかを判定 */
     bool empty = deque.empty();
-    cout << "Is the double-ended queue empty = " << empty << endl;
+    cout << "両端キューが空かどうか = " << empty << endl;
 
     return 0;
-}
+}

ja/codes/cpp/chapter_stack_and_queue/linkedlist_deque.cpp

@@ -8,17 +8,17 @@
 
 /* 双方向連結リストノード */
 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,9 +26,9 @@ class LinkedListDeque {
     LinkedListDeque() : front(nullptr), rear(nullptr) {
     }
 
-    /* デストラクタ */
+    /* デストラクタメソッド */
     ~LinkedListDeque() {
-        // 連結リストを走査、ノードを削除、メモリを解放
+        // 連結リストを走査してノードを削除し、メモリを解放する
         DoublyListNode *pre, *cur = front;
         while (cur != nullptr) {
             pre = cur;
@@ -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 を連結リストの先頭に追加
             front->prev = node;
             node->next = front;
-            front = node; // 先頭ノードを更新
-        // 末尾エンキュー操作
+            front = node; // 先頭ノードを更新する
+        // 末尾へのエンキュー操作
         } else {
-            // ノードをリストの末尾に追加
+            // node を連結リストの末尾に追加
             rear->next = node;
             node->prev = rear;
-            rear = node; // 末尾ノードを更新
+            rear = node; // 末尾ノードを更新する
         }
-        queSize++; // キュー長を更新
+        queSize++; // キューの長さを更新
     }
 
-    /* 先頭エンキュー */
+    /* キュー先頭にエンキュー */
     void pushFirst(int num) {
         push(num, true);
     }
 
-    /* 末尾エンキュー */
+    /* キュー末尾にエンキュー */
     void pushLast(int num) {
         push(num, false);
     }
@@ -82,9 +82,9 @@ class LinkedListDeque {
     /* デキュー操作 */
     int pop(bool isFront) {
         if (isEmpty())
-            throw out_of_range("Queue is empty");
+            throw out_of_range("キューが空です");
         int val;
-        // 先頭デキュー操作
+        // キュー先頭からの取り出し
         if (isFront) {
             val = front->val; // 先頭ノードの値を一時保存
             // 先頭ノードを削除
@@ -94,8 +94,8 @@ class LinkedListDeque {
                 front->next = nullptr;
             }
             delete front;
-            front = fNext; // 先頭ノードを更新
-        // 末尾デキュー操作
+            front = fNext; // 先頭ノードを更新する
+        // キュー末尾からの取り出し
         } else {
             val = rear->val; // 末尾ノードの値を一時保存
             // 末尾ノードを削除
@@ -105,37 +105,37 @@ class LinkedListDeque {
                 rear->prev = nullptr;
             }
             delete rear;
-            rear = rPrev; // 末尾ノードを更新
+            rear = rPrev; // 末尾ノードを更新する
         }
-        queSize--; // キュー長を更新
+        queSize--; // キューの長さを更新
         return val;
     }
 
-    /* 先頭デキュー */
+    /* キュー先頭からデキュー */
     int popFirst() {
         return pop(true);
     }
 
-    /* 末尾デキュー */
+    /* キュー末尾からデキュー */
     int popLast() {
         return pop(false);
     }
 
-    /* 先頭要素にアクセス */
+    /* キュー先頭の要素にアクセス */
     int peekFirst() {
         if (isEmpty())
-            throw out_of_range("Double-ended queue is empty");
+            throw out_of_range("両端キューが空です");
         return front->val;
     }
 
-    /* 末尾要素にアクセス */
+    /* キュー末尾の要素にアクセス */
     int peekLast() {
         if (isEmpty())
-            throw out_of_range("Double-ended queue is empty");
+            throw out_of_range("両端キューが空です");
         return rear->val;
     }
 
-    /* 印刷用に配列を返却 */
+    /* 出力用の配列を返す */
     vector<int> toVector() {
         DoublyListNode *node = front;
         vector<int> res(size());
@@ -147,48 +147,48 @@ class LinkedListDeque {
     }
 };
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     /* 両端キューを初期化 */
     LinkedListDeque *deque = new LinkedListDeque();
     deque->pushLast(3);
     deque->pushLast(2);
     deque->pushLast(5);
-    cout << "Double-ended queue deque = ";
+    cout << "両端キュー deque = ";
     printVector(deque->toVector());
 
     /* 要素にアクセス */
     int peekFirst = deque->peekFirst();
-    cout << "Front element peekFirst = " << peekFirst << endl;
+    cout << "先頭要素 peekFirst = " << peekFirst << endl;
     int peekLast = deque->peekLast();
-    cout << "Back element peekLast = " << peekLast << endl;
+    cout << "末尾要素 peekLast = " << peekLast << endl;
 
-    /* 要素エンキュー */
+    /* 要素をエンキュー */
     deque->pushLast(4);
-    cout << "Element 4 rear enqueued, deque =";
+    cout << "要素 4 を末尾に追加した後の deque =";
     printVector(deque->toVector());
     deque->pushFirst(1);
-    cout << "Element 1 enqueued at the head, deque = ";
+    cout << "要素 1 を先頭に追加した後 deque = ";
     printVector(deque->toVector());
 
-    /* 要素デキュー */
+    /* 要素をデキュー */
     int popLast = deque->popLast();
-    cout << "Deque tail element = " << popLast << ", after dequeuing from the tail";
+    cout << "末尾から取り出した要素 = " << popLast << "、末尾から取り出した後 deque = ";
     printVector(deque->toVector());
     int popFirst = deque->popFirst();
-    cout << "Deque front element = " << popFirst << ", after dequeuing from the front";
+    cout << "先頭から取り出した要素 = " << popFirst << "、先頭から取り出した後 deque = ";
     printVector(deque->toVector());
 
     /* 両端キューの長さを取得 */
     int size = deque->size();
-    cout << "Length of the double-ended queue size = " << size << endl;
+    cout << "両端キューの長さ size = " << size << endl;
 
     /* 両端キューが空かどうかを判定 */
     bool isEmpty = deque->isEmpty();
-    cout << "Is the double-ended queue empty = " << boolalpha << isEmpty << endl;
+    cout << "両端キューが空かどうか = " << boolalpha << isEmpty << endl;
 
-    // メモリを解放
+    // メモリを解放する
     delete deque;
 
     return 0;
-}
+}

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:
@@ -20,7 +20,7 @@ class LinkedListQueue {
     }
 
     ~LinkedListQueue() {
-        // 連結リストを走査、ノードを削除、メモリを解放
+        // 連結リストを走査してノードを削除し、メモリを解放する
         freeMemoryLinkedList(front);
     }
 
@@ -36,14 +36,14 @@ class LinkedListQueue {
 
     /* エンキュー */
     void push(int num) {
-        // 末尾ノードの後ろにnumを追加
+        // 末尾ノードの後ろに num を追加
         ListNode *node = new ListNode(num);
-        // キューが空の場合、先頭と末尾ノードの両方をそのノードに向ける
+        // キューが空なら、先頭・末尾ノードをともにそのノードに設定
         if (front == nullptr) {
             front = node;
             rear = node;
         }
-        // キューが空でない場合、そのノードを末尾ノードの後ろに追加
+        // キューが空でなければ、そのノードを末尾ノードの後ろに追加
         else {
             rear->next = node;
             rear = node;
@@ -57,20 +57,20 @@ class LinkedListQueue {
         // 先頭ノードを削除
         ListNode *tmp = front;
         front = front->next;
-        // メモリを解放
+        // メモリを解放する
         delete tmp;
         queSize--;
         return num;
     }
 
-    /* 先頭要素にアクセス */
+    /* キュー先頭の要素にアクセス */
     int peek() {
         if (size() == 0)
-            throw out_of_range("Queue is empty");
+            throw out_of_range("キューが空です");
         return front->val;
     }
 
-    /* 連結リストをVectorに変換して返却 */
+    /* 連結リストを Vector に変換して返す */
     vector<int> toVector() {
         ListNode *node = front;
         vector<int> res(size());
@@ -82,39 +82,39 @@ class LinkedListQueue {
     }
 };
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     /* キューを初期化 */
     LinkedListQueue *queue = new LinkedListQueue();
 
-    /* 要素エンキュー */
+    /* 要素をエンキュー */
     queue->push(1);
     queue->push(3);
     queue->push(2);
     queue->push(5);
     queue->push(4);
-    cout << "Queue queue = ";
+    cout << "キュー queue = ";
     printVector(queue->toVector());
 
-    /* 先頭要素にアクセス */
+    /* キュー先頭の要素にアクセス */
     int peek = queue->peek();
-    cout << "Front element peek = " << peek << endl;
+    cout << "先頭要素 peek = " << peek << endl;
 
-    /* 要素デキュー */
+    /* 要素をデキュー */
     peek = queue->pop();
-    cout << "Element dequeued = " << peek << ", after dequeuing";
+    cout << "取り出した要素 pop = " << peek << "、取り出し後の queue = ";
     printVector(queue->toVector());
 
     /* キューの長さを取得 */
     int size = queue->size();
-    cout << "Length of the queue size = " << size << endl;
+    cout << "キューの長さ size = " << size << endl;
 
     /* キューが空かどうかを判定 */
     bool empty = queue->isEmpty();
-    cout << "Is the queue empty = " << empty << endl;
+    cout << "キューが空かどうか = " << empty << endl;
 
-    // メモリを解放
+    // メモリを解放する
     delete queue;
 
     return 0;
-}
+}

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:
@@ -19,7 +19,7 @@ class LinkedListStack {
     }
 
     ~LinkedListStack() {
-        // 連結リストを走査、ノードを削除、メモリを解放
+        // 連結リストを走査してノードを削除し、メモリを解放する
         freeMemoryLinkedList(stackTop);
     }
 
@@ -46,20 +46,20 @@ class LinkedListStack {
         int num = top();
         ListNode *tmp = stackTop;
         stackTop = stackTop->next;
-        // メモリを解放
+        // メモリを解放する
         delete tmp;
         stkSize--;
         return num;
     }
 
-    /* スタックトップ要素にアクセス */
+    /* スタックトップの要素にアクセス */
     int top() {
         if (isEmpty())
-            throw out_of_range("Stack is empty");
+            throw out_of_range("スタックが空です");
         return stackTop->val;
     }
 
-    /* リストを配列に変換して返却 */
+    /* List を Array に変換して返す */
     vector<int> toVector() {
         ListNode *node = stackTop;
         vector<int> res(size());
@@ -71,39 +71,39 @@ class LinkedListStack {
     }
 };
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     /* スタックを初期化 */
     LinkedListStack *stack = new LinkedListStack();
 
-    /* 要素プッシュ */
+    /* 要素をプッシュ */
     stack->push(1);
     stack->push(3);
     stack->push(2);
     stack->push(5);
     stack->push(4);
-    cout << "Stack stack = ";
+    cout << "スタック stack = ";
     printVector(stack->toVector());
 
-    /* スタックトップ要素にアクセス */
+    /* スタックトップの要素にアクセス */
     int top = stack->top();
-    cout << "Top element of the stack top = " << top << endl;
+    cout << "トップ要素 top = " << top << endl;
 
-    /* 要素ポップ */
+    /* 要素をポップ */
     top = stack->pop();
-    cout << "Element popped from the stack = " << top << ", after popping";
+    cout << "取り出した要素 pop = " << top << "、取り出し後の stack = ";
     printVector(stack->toVector());
 
     /* スタックの長さを取得 */
     int size = stack->size();
-    cout << "Length of the stack size = " << size << endl;
+    cout << "スタックの長さ size = " << size << endl;
 
     /* 空かどうかを判定 */
     bool empty = stack->isEmpty();
-    cout << "Is the stack empty = " << empty << endl;
+    cout << "スタックが空かどうか = " << empty << endl;
 
-    // メモリを解放
+    // メモリを解放する
     delete stack;
 
     return 0;
-}
+}

ja/codes/cpp/chapter_stack_and_queue/queue.cpp

@@ -6,36 +6,36 @@
 
 #include "../utils/common.hpp"
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     /* キューを初期化 */
     queue<int> queue;
 
-    /* 要素エンキュー */
+    /* 要素をエンキュー */
     queue.push(1);
     queue.push(3);
     queue.push(2);
     queue.push(5);
     queue.push(4);
-    cout << "Queue queue = ";
+    cout << "キュー queue = ";
     printQueue(queue);
 
-    /* 先頭要素にアクセス */
+    /* キュー先頭の要素にアクセス */
     int front = queue.front();
-    cout << "Front element of the queue front = " << front << endl;
+    cout << "先頭要素 front = " << front << endl;
 
-    /* 要素デキュー */
+    /* 要素をデキュー */
     queue.pop();
-    cout << "Element dequeued = " << front << ", after dequeuing";
+    cout << "取り出した要素 front = " << front << "、取り出し後の queue = ";
     printQueue(queue);
 
     /* キューの長さを取得 */
     int size = queue.size();
-    cout << "Length of the queue size = " << size << endl;
+    cout << "キューの長さ size = " << size << endl;
 
     /* キューが空かどうかを判定 */
     bool empty = queue.empty();
-    cout << "Is the queue empty = " << empty << endl;
+    cout << "キューが空かどうか = " << empty << endl;
 
     return 0;
-}
+}

ja/codes/cpp/chapter_stack_and_queue/stack.cpp

@@ -6,36 +6,36 @@
 
 #include "../utils/common.hpp"
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     /* スタックを初期化 */
     stack<int> stack;
 
-    /* 要素プッシュ */
+    /* 要素をプッシュ */
     stack.push(1);
     stack.push(3);
     stack.push(2);
     stack.push(5);
     stack.push(4);
-    cout << "Stack stack = ";
+    cout << "スタック stack = ";
     printStack(stack);
 
-    /* スタックトップ要素にアクセス */
+    /* スタックトップの要素にアクセス */
     int top = stack.top();
-    cout << "Top element of the stack top = " << top << endl;
+    cout << "トップ要素 top = " << top << endl;
 
-    /* 要素ポップ */
+    /* 要素をポップ */
     stack.pop(); // 戻り値なし
-    cout << "Element popped from the stack = " << top << ", after popping";
+    cout << "取り出した要素 pop = " << top << "、取り出し後の stack = ";
     printStack(stack);
 
     /* スタックの長さを取得 */
     int size = stack.size();
-    cout << "Length of the stack size = " << size << endl;
+    cout << "スタックの長さ size = " << size << endl;
 
     /* 空かどうかを判定 */
     bool empty = stack.empty();
-    cout << "Is the stack empty = " << empty << endl;
+    cout << "スタックが空かどうか = " << empty << endl;
 
     return 0;
-}
+}