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

@@ -6,18 +6,18 @@
 
 #include "../utils/common.h"
 
-/* 循環配列ベースの両端キュー */
+/* 循環配列で実装した両端キュー */
 typedef struct {
-    int *nums;       // キュー要素を格納する配列
-    int front;       // 先頭ポインタ。先頭要素を指す
-    int queSize;     // 末尾ポインタ。キューの末尾 + 1 を指す
+    int *nums;       // キューの要素を格納する配列
+    int front;       // キューの先頭要素を指す先頭ポインタ
+    int queSize;     // キューの末尾 + 1 を指す末尾ポインタ
     int queCapacity; // キューの容量
 } ArrayDeque;
 
 /* コンストラクタ */
 ArrayDeque *newArrayDeque(int capacity) {
     ArrayDeque *deque = (ArrayDeque *)malloc(sizeof(ArrayDeque));
-    // 配列を初期化
+    // 配列を初期化する
     deque->queCapacity = capacity;
     deque->nums = (int *)malloc(sizeof(int) * deque->queCapacity);
     deque->front = deque->queSize = 0;
@@ -30,88 +30,88 @@ void delArrayDeque(ArrayDeque *deque) {
     free(deque);
 }
 
-/* 両端キューの容量を取得 */
+/* 両端キューの容量を取得する */
 int capacity(ArrayDeque *deque) {
     return deque->queCapacity;
 }
 
-/* 両端キューの長さを取得 */
+/* 両端キューの長さを取得する */
 int size(ArrayDeque *deque) {
     return deque->queSize;
 }
 
-/* 両端キューが空かどうかを判定 */
+/* 両端キューが空かどうかを判定する */
 bool empty(ArrayDeque *deque) {
     return deque->queSize == 0;
 }
 
-/* 循環配列のインデックスを計算 */
+/* 循環配列のインデックスを計算する */
 int dequeIndex(ArrayDeque *deque, int i) {
-    // 剰余演算により配列の先頭と末尾をつなげる
-    // i が配列の末尾を越えたら先頭に戻る
-    // i が配列の先頭を越えたら末尾に戻る
+    // 剰余演算を使い、配列の先頭と末尾をつなぐ
+    // i が配列の末尾を越えたら、先頭に戻る
+    // i が配列の先頭を越えたら、末尾に戻る
     return ((i + capacity(deque)) % capacity(deque));
 }
 
-/* キュー先頭にエンキュー */
+/* 先頭にエンキューする */
 void pushFirst(ArrayDeque *deque, int num) {
     if (deque->queSize == capacity(deque)) {
-        printf("両端キューがいっぱいです\r\n");
+        printf("両端キューが満杯です\r\n");
         return;
     }
     // 先頭ポインタを左に 1 つ移動する
-    // 剰余演算により front が配列の先頭を越えたあと末尾に戻るようにする
+    // 剰余演算により、front が配列の先頭を越えたら末尾に戻るようにする
     deque->front = dequeIndex(deque, deque->front - 1);
-    // num をキューの先頭に追加
+    // num をキューの先頭に追加する
     deque->nums[deque->front] = num;
     deque->queSize++;
 }
 
-/* キュー末尾にエンキュー */
+/* 末尾にエンキューする */
 void pushLast(ArrayDeque *deque, int num) {
     if (deque->queSize == capacity(deque)) {
-        printf("両端キューがいっぱいです\r\n");
+        printf("両端キューが満杯です\r\n");
         return;
     }
-    // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す
+    // 末尾のインデックス + 1 を指す末尾ポインタを計算する
     int rear = dequeIndex(deque, deque->front + deque->queSize);
-    // num をキュー末尾に追加
+    // num をキューの末尾に追加する
     deque->nums[rear] = num;
     deque->queSize++;
 }
 
-/* キュー先頭の要素にアクセス */
+/* キューの先頭要素にアクセス */
 int peekFirst(ArrayDeque *deque) {
-    // アクセス例外：双方向キューが空です
+    // アクセス例外：両端キューが空です
     assert(empty(deque) == 0);
     return deque->nums[deque->front];
 }
 
-/* キュー末尾の要素にアクセス */
+/* キューの末尾要素にアクセスする */
 int peekLast(ArrayDeque *deque) {
-    // アクセス例外：双方向キューが空です
+    // アクセス例外：両端キューが空です
     assert(empty(deque) == 0);
     int last = dequeIndex(deque, deque->front + deque->queSize - 1);
     return deque->nums[last];
 }
 
-/* キュー先頭からデキュー */
+/* 先頭からデキューする */
 int popFirst(ArrayDeque *deque) {
     int num = peekFirst(deque);
-    // 先頭ポインタを 1 つ後ろへ進める
+    // 先頭ポインタを後ろに 1 つ移動する
     deque->front = dequeIndex(deque, deque->front + 1);
     deque->queSize--;
     return num;
 }
 
-/* キュー末尾からデキュー */
+/* 末尾からデキューする */
 int popLast(ArrayDeque *deque) {
     int num = peekLast(deque);
     deque->queSize--;
     return num;
 }
 
-/* 出力用の配列を返す */
+/* 表示用の配列を返す */
 int *toArray(ArrayDeque *deque, int *queSize) {
     *queSize = deque->queSize;
     int *res = (int *)calloc(deque->queSize, sizeof(int));
@@ -123,9 +123,9 @@ int *toArray(ArrayDeque *deque, int *queSize) {
     return res;
 }
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* キューを初期化 */
+    /* キューを初期化する */
     int capacity = 10;
     int queSize;
     ArrayDeque *deque = newArrayDeque(capacity);
@@ -135,35 +135,35 @@ int main() {
     printf("両端キュー deque = ");
     printArray(toArray(deque, &queSize), queSize);
 
-    /* 要素にアクセス */
+    /* 要素にアクセスする */
     int peekFirstNum = peekFirst(deque);
-    printf("先頭要素 peekFirst = %d\r\n", peekFirstNum);
+    printf("キューの先頭要素 peekFirst = %d\r\n", peekFirstNum);
     int peekLastNum = peekLast(deque);
-    printf("末尾要素 peekLast = %d\r\n", peekLastNum);
+    printf("キューの末尾要素 peekLast = %d\r\n", peekLastNum);
 
-    /* 要素をエンキュー */
+    /* 要素をエンキューする */
     pushLast(deque, 4);
-    printf("要素 4 を末尾に追加後 deque = ");
+    printf("要素 4 を末尾にエンキューした後 deque = ");
     printArray(toArray(deque, &queSize), queSize);
     pushFirst(deque, 1);
-    printf("要素 1 を先頭に追加後 deque = ");
+    printf("要素 1 を先頭にエンキューした後 deque = ");
     printArray(toArray(deque, &queSize), queSize);
 
-    /* 要素をデキュー */
+    /* 要素をデキューする */
     int popLastNum = popLast(deque);
-    printf("末尾から取り出した要素 = %d ，末尾から取り出した後 deque= ", popLastNum);
+    printf("末尾からデキューした要素 = %d 、末尾からデキューした後 deque= ", popLastNum);
     printArray(toArray(deque, &queSize), queSize);
     int popFirstNum = popFirst(deque);
-    printf("先頭から取り出した要素 = %d ，先頭から取り出した後 deque= ", popFirstNum);
+    printf("先頭からデキューした要素 = %d 、先頭からデキューした後 deque= ", popFirstNum);
     printArray(toArray(deque, &queSize), queSize);
 
     /* キューの長さを取得 */
     int dequeSize = size(deque);
     printf("両端キューの長さ size = %d\r\n", dequeSize);
 
-    /* キューが空かどうかを判定 */
+    /* キューが空か判定 */
     bool isEmpty = empty(deque);
-    printf("キューが空かどうか = %s\r\n", isEmpty ? "true" : "false");
+    printf("キューは空か = %s\r\n", isEmpty ? "true" : "false");
 
     // メモリを解放する
     delArrayDeque(deque);

ja/codes/c/chapter_stack_and_queue/array_queue.c

@@ -6,18 +6,18 @@
 
 #include "../utils/common.h"
 
-/* 循環配列ベースのキュー */
+/* 循環配列で実装したキュー */
 typedef struct {
-    int *nums;       // キュー要素を格納する配列
-    int front;       // 先頭ポインタ。先頭要素を指す
-    int queSize;     // 現在のキュー内の要素数
+    int *nums;       // キューの要素を格納する配列
+    int front;       // キューの先頭要素を指す先頭ポインタ
+    int queSize;     // 現在のキューの要素数
     int queCapacity; // キューの容量
 } ArrayQueue;
 
 /* コンストラクタ */
 ArrayQueue *newArrayQueue(int capacity) {
     ArrayQueue *queue = (ArrayQueue *)malloc(sizeof(ArrayQueue));
-    // 配列を初期化
+    // 配列を初期化する
     queue->queCapacity = capacity;
     queue->nums = (int *)malloc(sizeof(int) * queue->queCapacity);
     queue->front = queue->queSize = 0;
@@ -30,7 +30,7 @@ void delArrayQueue(ArrayQueue *queue) {
     free(queue);
 }
 
-/* キューの容量を取得 */
+/* キューの容量を取得する */
 int capacity(ArrayQueue *queue) {
     return queue->queCapacity;
 }
@@ -40,12 +40,12 @@ int size(ArrayQueue *queue) {
     return queue->queSize;
 }
 
-/* キューが空かどうかを判定 */
+/* キューが空か判定 */
 bool empty(ArrayQueue *queue) {
     return queue->queSize == 0;
 }
 
-/* キュー先頭の要素にアクセス */
+/* キューの先頭要素にアクセス */
 int peek(ArrayQueue *queue) {
     assert(size(queue) != 0);
     return queue->nums[queue->front];
@@ -54,13 +54,13 @@ int peek(ArrayQueue *queue) {
 /* エンキュー */
 void push(ArrayQueue *queue, int num) {
     if (size(queue) == capacity(queue)) {
-        printf("キューは満杯です\r\n");
+        printf("キューが満杯です\r\n");
         return;
     }
-    // 末尾ポインタを計算し、末尾インデックス + 1 を指す
-    // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする
+    // 末尾のインデックス + 1 を指す末尾ポインタを計算する
+    // 剰余演算で、rear が配列末尾を越えたら先頭へ戻る
     int rear = (queue->front + queue->queSize) % queue->queCapacity;
-    // num をキュー末尾に追加
+    // num をキューの末尾に追加する
     queue->nums[rear] = num;
     queue->queSize++;
 }
@@ -68,13 +68,13 @@ void push(ArrayQueue *queue, int num) {
 /* デキュー */
 int pop(ArrayQueue *queue) {
     int num = peek(queue);
-    // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す
+    // 先頭ポインタを後ろに 1 つ移動し、末尾を越えたら配列の先頭に戻す
     queue->front = (queue->front + 1) % queue->queCapacity;
     queue->queSize--;
     return num;
 }
 
-/* 出力用の配列を返す */
+/* 表示用の配列を返す */
 int *toArray(ArrayQueue *queue, int *queSize) {
     *queSize = queue->queSize;
     int *res = (int *)calloc(queue->queSize, sizeof(int));
@@ -86,14 +86,14 @@ int *toArray(ArrayQueue *queue, int *queSize) {
     return res;
 }
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* キューを初期化 */
+    /* キューを初期化する */
     int capacity = 10;
     int queSize;
     ArrayQueue *queue = newArrayQueue(capacity);
 
-    /* 要素をエンキュー */
+    /* 要素をエンキューする */
     push(queue, 1);
     push(queue, 3);
     push(queue, 2);
@@ -102,28 +102,28 @@ int main() {
     printf("キュー queue = ");
     printArray(toArray(queue, &queSize), queSize);
 
-    /* キュー先頭の要素にアクセス */
+    /* キューの先頭要素にアクセス */
     int peekNum = peek(queue);
-    printf("先頭要素 peek = %d\r\n", peekNum);
+    printf("キューの先頭要素 peek = %d\r\n", peekNum);
 
-    /* 要素をデキュー */
+    /* 要素をデキューする */
     peekNum = pop(queue);
-    printf("デキューした要素 pop = %d ，デキュー後 queue = ", peekNum);
+    printf("デキューした要素 pop = %d 、デキュー後 queue = ", peekNum);
     printArray(toArray(queue, &queSize), queSize);
 
     /* キューの長さを取得 */
     int queueSize = size(queue);
     printf("キューの長さ size = %d\r\n", queueSize);
 
-    /* キューが空かどうかを判定 */
+    /* キューが空か判定 */
     bool isEmpty = empty(queue);
-    printf("キューが空かどうか = %s\r\n", isEmpty ? "true" : "false");
+    printf("キューは空か = %s\r\n", isEmpty ? "true" : "false");
 
     /* 循環配列をテストする */
     for (int i = 0; i < 10; i++) {
         push(queue, i);
         pop(queue);
-        printf("第 %d 回のエンキュー + デキュー後 queue = ", i);
+        printf("第 %d 回のエンキューとデキューの後 queue = ", i);
         printArray(toArray(queue, &queSize), queSize);
     }
 

ja/codes/c/chapter_stack_and_queue/array_stack.c

@@ -8,7 +8,7 @@
 
 #define MAX_SIZE 5000
 
-/* 配列ベースのスタック */
+/* 配列で実装したスタック */
 typedef struct {
     int *data;
     int size;
@@ -17,7 +17,7 @@ typedef struct {
 /* コンストラクタ */
 ArrayStack *newArrayStack() {
     ArrayStack *stack = malloc(sizeof(ArrayStack));
-    // 大きめの容量で初期化し、拡張を避ける
+    // 容量の拡張を避けるため、初期容量を大きくする
     stack->data = malloc(sizeof(int) * MAX_SIZE);
     stack->size = 0;
     return stack;
@@ -29,12 +29,12 @@ void delArrayStack(ArrayStack *stack) {
     free(stack);
 }
 
-/* スタックの長さを取得 */
+/* スタックの長さを取得する */
 int size(ArrayStack *stack) {
     return stack->size;
 }
 
-/* スタックが空かどうかを判定 */
+/* スタックが空かどうかを判定する */
 bool isEmpty(ArrayStack *stack) {
     return stack->size == 0;
 }
@@ -42,17 +42,17 @@ bool isEmpty(ArrayStack *stack) {
 /* プッシュ */
 void push(ArrayStack *stack, int num) {
     if (stack->size == MAX_SIZE) {
-        printf("スタックは満杯です\n");
+        printf("スタックが満杯です\n");
         return;
     }
     stack->data[stack->size] = num;
     stack->size++;
 }
 
-/* スタックトップの要素にアクセス */
+/* スタックの先頭要素にアクセスする */
 int peek(ArrayStack *stack) {
     if (stack->size == 0) {
-        printf("スタックは空です\n");
+        printf("スタックが空です\n");
         return INT_MAX;
     }
     return stack->data[stack->size - 1];
@@ -65,12 +65,12 @@ int pop(ArrayStack *stack) {
     return val;
 }
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* スタックを初期化 */
+    /* スタックを初期化する */
     ArrayStack *stack = newArrayStack();
 
-    /* 要素をプッシュ */
+    /* 要素をプッシュする */
     push(stack, 1);
     push(stack, 3);
     push(stack, 2);
@@ -79,22 +79,22 @@ int main() {
     printf("スタック stack = ");
     printArray(stack->data, stack->size);
 
-    /* スタックトップの要素にアクセス */
+    /* スタックの先頭要素にアクセスする */
     int val = peek(stack);
-    printf("先頭要素 top = %d\n", val);
+    printf("スタックの先頭要素 top = %d\n", val);
 
-    /* 要素をポップ */
+    /* 要素をポップする */
     val = pop(stack);
-    printf("ポップした要素 pop = %d ，ポップ後 stack = ", val);
+    printf("ポップした要素 pop = %d 、ポップ後 stack = ", val);
     printArray(stack->data, stack->size);
 
-    /* スタックの長さを取得 */
+    /* スタックの長さを取得する */
     int size = stack->size;
     printf("スタックの長さ size = %d\n", size);
 
-    /* 空かどうかを判定 */
+    /* 空かどうかを判定する */
     bool empty = isEmpty(stack);
-    printf("スタックが空かどうか = %s\n", empty ? "true" : "false");
+    printf("スタックは空か = %s\n", empty ? "true" : "false");
 
     // メモリを解放する
     delArrayStack(stack);

ja/codes/c/chapter_stack_and_queue/linkedlist_deque.c

@@ -6,11 +6,11 @@
 
 #include "../utils/common.h"
 
-/* 双方向連結リストノード */
+/* 双方向連結リストのノード */
 typedef struct DoublyListNode {
-    int val;                     // ノード値
+    int val;                     // ノードの値
     struct DoublyListNode *next; // 後続ノード
-    struct DoublyListNode *prev; // 前駆ノード
+    struct DoublyListNode *prev; // 前のノード
 } DoublyListNode;
 
 /* コンストラクタ */
@@ -27,9 +27,9 @@ void delDoublyListNode(DoublyListNode *node) {
     free(node);
 }
 
-/* 双方向連結リストベースの両端キュー */
+/* 双方向連結リストで実装した両端キュー */
 typedef struct {
-    DoublyListNode *front, *rear; // 先頭ノード front、末尾ノード rear
+    DoublyListNode *front, *rear; // 先頭ノード front 、末尾ノード rear
     int queSize;                  // 両端キューの長さ
 } LinkedListDeque;
 
@@ -44,7 +44,7 @@ LinkedListDeque *newLinkedListDeque() {
 
 /* デストラクタ */
 void delLinkedListdeque(LinkedListDeque *deque) {
-    // すべてのノードを解放
+    // すべてのノードを解放する
     for (int i = 0; i < deque->queSize && deque->front != NULL; i++) {
         DoublyListNode *tmp = deque->front;
         deque->front = deque->front->next;
@@ -59,7 +59,7 @@ int size(LinkedListDeque *deque) {
     return deque->queSize;
 }
 
-/* キューが空かどうかを判定 */
+/* キューが空か判定 */
 bool empty(LinkedListDeque *deque) {
     return (size(deque) == 0);
 }
@@ -67,44 +67,44 @@ bool empty(LinkedListDeque *deque) {
 /* エンキュー */
 void push(LinkedListDeque *deque, int num, bool isFront) {
     DoublyListNode *node = newDoublyListNode(num);
-    // 連結リストが空なら、`front` と `rear` の両方を `node` に向ける
+    // 連結リストが空の場合、front と rear の両方が node を指すようにする
     if (empty(deque)) {
         deque->front = deque->rear = node;
     }
     // 先頭へのエンキュー操作
     else if (isFront) {
-        // node を連結リストの先頭に追加
+        // node を連結リストの先頭に追加する
         deque->front->prev = node;
         node->next = deque->front;
         deque->front = node; // 先頭ノードを更新する
     }
     // 末尾へのエンキュー操作
     else {
-        // node を連結リストの末尾に追加
+        // node を連結リストの末尾に追加する
         deque->rear->next = node;
         node->prev = deque->rear;
         deque->rear = node;
     }
-    deque->queSize++; // キューの長さを更新
+    deque->queSize++; // キューの長さを更新する
 }
 
-/* キュー先頭にエンキュー */
+/* 先頭にエンキューする */
 void pushFirst(LinkedListDeque *deque, int num) {
     push(deque, num, true);
 }
 
-/* キュー末尾にエンキュー */
+/* 末尾にエンキューする */
 void pushLast(LinkedListDeque *deque, int num) {
     push(deque, num, false);
 }
 
-/* キュー先頭の要素にアクセス */
+/* キューの先頭要素にアクセス */
 int peekFirst(LinkedListDeque *deque) {
     assert(size(deque) && deque->front);
     return deque->front->val;
 }
 
-/* キュー末尾の要素にアクセス */
+/* キューの末尾要素にアクセスする */
 int peekLast(LinkedListDeque *deque) {
     assert(size(deque) && deque->rear);
     return deque->rear->val;
@@ -115,49 +115,49 @@ int pop(LinkedListDeque *deque, bool isFront) {
     if (empty(deque))
         return -1;
     int val;
-    // 要素が1つの場合、先頭と末尾は同じノードを指す
+    // キューの長さが 1 のとき、先頭と末尾は同じノードを指す
     if (deque->queSize == 1) {
         val = deque->front->val;
-        delDoublyListNode(deque->front); // 同じノードを一度だけ解放する
+        delDoublyListNode(deque->front); // 同じノードを指しているため、片方を解放すればよい
         deque->front = NULL;
         deque->rear = NULL;
     }
-    // キュー先頭からの取り出し
+    // 先頭からのデキュー操作
     else if (isFront) {
-        val = peekFirst(deque); // 先頭ノードの値を一時保存
+        val = peekFirst(deque); // 先頭ノードの値を一時保存する
         DoublyListNode *fNext = deque->front->next;
         fNext->prev = NULL;
         deque->front->next = NULL;
         delDoublyListNode(deque->front);
         deque->front = fNext; // 先頭ノードを更新する
     }
-    // キュー末尾からの取り出し
+    // 末尾からのデキュー操作
     else {
-        val = peekLast(deque); // 末尾ノードの値を一時保存
+        val = peekLast(deque); // 末尾ノードの値を一時保存する
         DoublyListNode *rPrev = deque->rear->prev;
         rPrev->next = NULL;
         deque->rear->prev = NULL;
         delDoublyListNode(deque->rear);
         deque->rear = rPrev; // 末尾ノードを更新する
     }
-    deque->queSize--; // キューの長さを更新
+    deque->queSize--; // キューの長さを更新する
     return val;
 }
 
-/* キュー先頭からデキュー */
+/* 先頭からデキューする */
 int popFirst(LinkedListDeque *deque) {
     return pop(deque, true);
 }
 
-/* キュー末尾からデキュー */
+/* 末尾からデキューする */
 int popLast(LinkedListDeque *deque) {
     return pop(deque, false);
 }
 
-/* キューを出力する */
+/* キューを表示する */
 void printLinkedListDeque(LinkedListDeque *deque) {
     int *arr = malloc(sizeof(int) * deque->queSize);
-    // 連結リスト内のデータを配列にコピー
+    // 連結リストのデータを配列にコピーする
     int i;
     DoublyListNode *node;
     for (i = 0, node = deque->front; i < deque->queSize; i++) {
@@ -168,9 +168,9 @@ void printLinkedListDeque(LinkedListDeque *deque) {
     free(arr);
 }
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* 両端キューを初期化 */
+    /* 両端キューを初期化する */
     LinkedListDeque *deque = newLinkedListDeque();
     pushLast(deque, 3);
     pushLast(deque, 2);
@@ -178,35 +178,35 @@ int main() {
     printf("両端キュー deque = ");
     printLinkedListDeque(deque);
 
-    /* 要素にアクセス */
+    /* 要素にアクセスする */
     int peekFirstNum = peekFirst(deque);
-    printf("先頭要素 peekFirst = %d\r\n", peekFirstNum);
+    printf("キューの先頭要素 peekFirst = %d\r\n", peekFirstNum);
     int peekLastNum = peekLast(deque);
-    printf("先頭要素 peekLast = %d\r\n", peekLastNum);
+    printf("キューの先頭要素 peekLast = %d\r\n", peekLastNum);
 
-    /* 要素をエンキュー */
+    /* 要素をエンキューする */
     pushLast(deque, 4);
-    printf("要素 4 を末尾に追加した後 deque =");
+    printf("要素 4 を末尾にエンキューした後 deque =");
     printLinkedListDeque(deque);
     pushFirst(deque, 1);
-    printf("要素 1 を先頭に追加した後 deque =");
+    printf("要素 1 を先頭にエンキューした後 deque =");
     printLinkedListDeque(deque);
 
-    /* 要素をデキュー */
+    /* 要素をデキューする */
     int popLastNum = popLast(deque);
-    printf("末尾から取り出した要素 popLast = %d ，末尾から取り出した後 deque = ", popLastNum);
+    printf("末尾からデキューした要素 popLast = %d 、末尾からデキューした後 deque = ", popLastNum);
     printLinkedListDeque(deque);
     int popFirstNum = popFirst(deque);
-    printf("先頭から取り出した要素 popFirst = %d ，先頭から取り出した後 deque = ", popFirstNum);
+    printf("先頭からデキューした要素 popFirst = %d 、先頭からデキューした後 deque = ", popFirstNum);
     printLinkedListDeque(deque);
 
     /* キューの長さを取得 */
     int dequeSize = size(deque);
     printf("両端キューの長さ size = %d\r\n", dequeSize);
 
-    /* キューが空かどうかを判定 */
+    /* キューが空か判定 */
     bool isEmpty = empty(deque);
-    printf("両端キューが空かどうか = %s\r\n", isEmpty ? "true" : "false");
+    printf("両端キューは空か = %s\r\n", isEmpty ? "true" : "false");
 
     // メモリを解放する
     delLinkedListdeque(deque);

ja/codes/c/chapter_stack_and_queue/linkedlist_queue.c

@@ -6,7 +6,7 @@
 
 #include "../utils/common.h"
 
-/* 連結リストベースのキュー */
+/* 連結リストで実装したキュー */
 typedef struct {
     ListNode *front, *rear;
     int queSize;
@@ -23,7 +23,7 @@ LinkedListQueue *newLinkedListQueue() {
 
 /* デストラクタ */
 void delLinkedListQueue(LinkedListQueue *queue) {
-    // すべてのノードを解放
+    // すべてのノードを解放する
     while (queue->front != NULL) {
         ListNode *tmp = queue->front;
         queue->front = queue->front->next;
@@ -38,21 +38,21 @@ int size(LinkedListQueue *queue) {
     return queue->queSize;
 }
 
-/* キューが空かどうかを判定 */
+/* キューが空か判定 */
 bool empty(LinkedListQueue *queue) {
     return (size(queue) == 0);
 }
 
 /* エンキュー */
 void push(LinkedListQueue *queue, int num) {
-    // 末尾ノードに node を追加
+    // 末尾ノードに node を追加する
     ListNode *node = newListNode(num);
-    // キューが空なら、先頭・末尾ノードをともにそのノードに設定
+    // キューが空の場合、先頭と末尾の両方がこのノードを指すようにする
     if (queue->front == NULL) {
         queue->front = node;
         queue->rear = node;
     }
-    // キューが空でなければ、そのノードを末尾ノードの後ろに追加
+    // キューが空でない場合、このノードを末尾ノードの後ろに追加する
     else {
         queue->rear->next = node;
         queue->rear = node;
@@ -60,7 +60,7 @@ void push(LinkedListQueue *queue, int num) {
     queue->queSize++;
 }
 
-/* キュー先頭の要素にアクセス */
+/* キューの先頭要素にアクセス */
 int peek(LinkedListQueue *queue) {
     assert(size(queue) && queue->front);
     return queue->front->val;
@@ -76,10 +76,10 @@ int pop(LinkedListQueue *queue) {
     return num;
 }
 
-/* キューを出力する */
+/* キューを表示する */
 void printLinkedListQueue(LinkedListQueue *queue) {
     int *arr = malloc(sizeof(int) * queue->queSize);
-    // 連結リスト内のデータを配列にコピー
+    // 連結リストのデータを配列にコピーする
     int i;
     ListNode *node;
     for (i = 0, node = queue->front; i < queue->queSize; i++) {
@@ -90,12 +90,12 @@ void printLinkedListQueue(LinkedListQueue *queue) {
     free(arr);
 }
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* キューを初期化 */
+    /* キューを初期化する */
     LinkedListQueue *queue = newLinkedListQueue();
 
-    /* 要素をエンキュー */
+    /* 要素をエンキューする */
     push(queue, 1);
     push(queue, 3);
     push(queue, 2);
@@ -104,22 +104,22 @@ int main() {
     printf("キュー queue = ");
     printLinkedListQueue(queue);
 
-    /* キュー先頭の要素にアクセス */
+    /* キューの先頭要素にアクセス */
     int peekNum = peek(queue);
-    printf("先頭要素 peek = %d\r\n", peekNum);
+    printf("キューの先頭要素 peek = %d\r\n", peekNum);
 
-    /* 要素をデキュー */
+    /* 要素をデキューする */
     peekNum = pop(queue);
-    printf("デキューした要素 pop = %d ，デキュー後 queue = ", peekNum);
+    printf("デキューした要素 pop = %d 、デキュー後 queue = ", peekNum);
     printLinkedListQueue(queue);
 
     /* キューの長さを取得 */
     int queueSize = size(queue);
     printf("キューの長さ size = %d\r\n", queueSize);
 
-    /* キューが空かどうかを判定 */
+    /* キューが空か判定 */
     bool isEmpty = empty(queue);
-    printf("キューが空かどうか = %s\r\n", isEmpty ? "true" : "false");
+    printf("キューは空か = %s\r\n", isEmpty ? "true" : "false");
 
     // メモリを解放する
     delLinkedListQueue(queue);

ja/codes/c/chapter_stack_and_queue/linkedlist_stack.c

@@ -6,9 +6,9 @@
 
 #include "../utils/common.h"
 
-/* 連結リストベースのスタック */
+/* 連結リストで実装したスタック */
 typedef struct {
-    ListNode *top; // 先頭ノードをスタックトップとする
+    ListNode *top; // 先頭ノードをスタックの先頭とする
     int size;      // スタックの長さ
 } LinkedListStack;
 
@@ -30,12 +30,12 @@ void delLinkedListStack(LinkedListStack *s) {
     free(s);
 }
 
-/* スタックの長さを取得 */
+/* スタックの長さを取得する */
 int size(LinkedListStack *s) {
     return s->size;
 }
 
-/* スタックが空かどうかを判定 */
+/* スタックが空かどうかを判定する */
 bool isEmpty(LinkedListStack *s) {
     return size(s) == 0;
 }
@@ -43,16 +43,16 @@ bool isEmpty(LinkedListStack *s) {
 /* プッシュ */
 void push(LinkedListStack *s, int num) {
     ListNode *node = (ListNode *)malloc(sizeof(ListNode));
-    node->next = s->top; // 新しく追加したノードのポインタフィールドを更新
-    node->val = num;     // 新しく追加したノードのデータフィールドを更新
-    s->top = node;       // スタックトップを更新
-    s->size++;           // スタックサイズを更新
+    node->next = s->top; // 追加するノードのポインタ領域を更新する
+    node->val = num;     // 追加するノードのデータ領域を更新する
+    s->top = node;       // スタックの先頭を更新する
+    s->size++;           // スタックのサイズを更新する
 }
 
-/* スタックトップの要素にアクセス */
+/* スタックの先頭要素にアクセスする */
 int peek(LinkedListStack *s) {
     if (s->size == 0) {
-        printf("スタックは空です\n");
+        printf("スタックが空です\n");
         return INT_MAX;
     }
     return s->top->val;
@@ -69,12 +69,12 @@ int pop(LinkedListStack *s) {
     return val;
 }
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* スタックを初期化 */
+    /* スタックを初期化する */
     LinkedListStack *stack = newLinkedListStack();
 
-    /* 要素をプッシュ */
+    /* 要素をプッシュする */
     push(stack, 1);
     push(stack, 3);
     push(stack, 2);
@@ -84,21 +84,21 @@ int main() {
     printf("スタック stack = ");
     printLinkedList(stack->top);
 
-    /* スタックトップの要素にアクセス */
+    /* スタックの先頭要素にアクセスする */
     int val = peek(stack);
-    printf("スタックトップ要素 top = %d\r\n", val);
+    printf("スタックの先頭要素 top = %d\r\n", val);
 
-    /* 要素をポップ */
+    /* 要素をポップする */
     val = pop(stack);
     printf("ポップした要素 pop = %d, ポップ後 stack =  ", val);
     printLinkedList(stack->top);
 
-    /* スタックの長さを取得 */
+    /* スタックの長さを取得する */
     printf("スタックの長さ size = %d\n", size(stack));
 
-    /* 空かどうかを判定 */
+    /* 空かどうかを判定する */
     bool empty = isEmpty(stack);
-    printf("スタックが空かどうか = %s\n", empty ? "true" : "false");
+    printf("スタックは空か = %s\n", empty ? "true" : "false");
 
     // メモリを解放する
     delLinkedListStack(stack);