docs: add Japanese translate documents (#1812)

* docs: add Japanese documents (`ja/docs`)

* docs: add Japanese documents (`ja/codes`)

* docs: add Japanese documents

* Remove pythontutor blocks in ja/

* Add an empty at the end of each markdown file.

* Add the missing figures (use the English version temporarily).

* Add index.md for Japanese version.

* Add index.html for Japanese version.

* Add missing index.assets

* Fix backtracking_algorithm.md for Japanese version.

* Add avatar_eltociear.jpg. Fix image links on the Japanese landing page.

* Add the Japanese banner.

---------

Co-authored-by: krahets <krahets@163.com>

ja/docs/chapter_stack_and_queue/deque.md

@@ -0,0 +1,401 @@
+# 両端キュー
+
+キューでは、先頭からの要素の削除や末尾への要素の追加のみが可能です。下図に示すように、<u>両端キュー（deque）</u>はより柔軟性を提供し、先頭と末尾の両方で要素の追加や削除を可能にします。
+
+![両端キューの操作](deque.assets/deque_operations.png)
+
+## 両端キューの一般的な操作
+
+両端キューの一般的な操作は以下の通りです。具体的なメソッド名は使用するプログラミング言語によって異なります。
+
+<p align="center"> 表 <id> &nbsp; 両端キューの操作効率 </p>
+
+| メソッド名        | 説明                | 時間計算量      |
+| ------------- | ------------------ | ------------- |
+| `pushFirst()` | 先頭に要素を追加        | $O(1)$        |
+| `pushLast()`  | 末尾に要素を追加        | $O(1)$        |
+| `popFirst()`  | 先頭要素を削除         | $O(1)$        |
+| `popLast()`   | 末尾要素を削除         | $O(1)$        |
+| `peekFirst()` | 先頭要素にアクセス      | $O(1)$        |
+| `peekLast()`  | 末尾要素にアクセス      | $O(1)$        |
+
+同様に、プログラミング言語で実装された両端キュークラスを直接使用することができます：
+
+=== "Python"
+
+    ```python title="deque.py"
+    from collections import deque
+
+    # 両端キューを初期化
+    deq: deque[int] = deque()
+
+    # 要素をエンキュー
+    deq.append(2)      # 末尾に追加
+    deq.append(5)
+    deq.append(4)
+    deq.appendleft(3)  # 先頭に追加
+    deq.appendleft(1)
+
+    # 要素にアクセス
+    front: int = deq[0]  # 先頭要素
+    rear: int = deq[-1]  # 末尾要素
+
+    # 要素をデキュー
+    pop_front: int = deq.popleft()  # 先頭要素をデキュー
+    pop_rear: int = deq.pop()       # 末尾要素をデキュー
+
+    # 両端キューの長さを取得
+    size: int = len(deq)
+
+    # 両端キューが空かどうかを確認
+    is_empty: bool = len(deq) == 0
+    ```
+
+=== "C++"
+
+    ```cpp title="deque.cpp"
+    /* 両端キューを初期化 */
+    deque<int> deque;
+
+    /* 要素をエンキュー */
+    deque.push_back(2);   // 末尾に追加
+    deque.push_back(5);
+    deque.push_back(4);
+    deque.push_front(3);  // 先頭に追加
+    deque.push_front(1);
+
+    /* 要素にアクセス */
+    int front = deque.front(); // 先頭要素
+    int back = deque.back();   // 末尾要素
+
+    /* 要素をデキュー */
+    deque.pop_front();  // 先頭要素をデキュー
+    deque.pop_back();   // 末尾要素をデキュー
+
+    /* 両端キューの長さを取得 */
+    int size = deque.size();
+
+    /* 両端キューが空かどうかを確認 */
+    bool empty = deque.empty();
+    ```
+
+=== "Java"
+
+    ```java title="deque.java"
+    /* 両端キューを初期化 */
+    Deque<Integer> deque = new LinkedList<>();
+
+    /* 要素をエンキュー */
+    deque.offerLast(2);   // 末尾に追加
+    deque.offerLast(5);
+    deque.offerLast(4);
+    deque.offerFirst(3);  // 先頭に追加
+    deque.offerFirst(1);
+
+    /* 要素にアクセス */
+    int peekFirst = deque.peekFirst();  // 先頭要素
+    int peekLast = deque.peekLast();    // 末尾要素
+
+    /* 要素をデキュー */
+    int popFirst = deque.pollFirst();  // 先頭要素をデキュー
+    int popLast = deque.pollLast();    // 末尾要素をデキュー
+
+    /* 両端キューの長さを取得 */
+    int size = deque.size();
+
+    /* 両端キューが空かどうかを確認 */
+    boolean isEmpty = deque.isEmpty();
+    ```
+
+=== "C#"
+
+    ```csharp title="deque.cs"
+    /* 両端キューを初期化 */
+    // C#では、LinkedListを両端キューとして使用
+    LinkedList<int> deque = new();
+
+    /* 要素をエンキュー */
+    deque.AddLast(2);   // 末尾に追加
+    deque.AddLast(5);
+    deque.AddLast(4);
+    deque.AddFirst(3);  // 先頭に追加
+    deque.AddFirst(1);
+
+    /* 要素にアクセス */
+    int peekFirst = deque.First.Value;  // 先頭要素
+    int peekLast = deque.Last.Value;    // 末尾要素
+
+    /* 要素をデキュー */
+    deque.RemoveFirst();  // 先頭要素をデキュー
+    deque.RemoveLast();   // 末尾要素をデキュー
+
+    /* 両端キューの長さを取得 */
+    int size = deque.Count;
+
+    /* 両端キューが空かどうかを確認 */
+    bool isEmpty = deque.Count == 0;
+    ```
+
+=== "Go"
+
+    ```go title="deque_test.go"
+    /* 両端キューを初期化 */
+    // Goでは、listを両端キューとして使用
+    deque := list.New()
+
+    /* 要素をエンキュー */
+    deque.PushBack(2)      // 末尾に追加
+    deque.PushBack(5)
+    deque.PushBack(4)
+    deque.PushFront(3)     // 先頭に追加
+    deque.PushFront(1)
+
+    /* 要素にアクセス */
+    front := deque.Front() // 先頭要素
+    rear := deque.Back()   // 末尾要素
+
+    /* 要素をデキュー */
+    deque.Remove(front)    // 先頭要素をデキュー
+    deque.Remove(rear)     // 末尾要素をデキュー
+
+    /* 両端キューの長さを取得 */
+    size := deque.Len()
+
+    /* 両端キューが空かどうかを確認 */
+    isEmpty := deque.Len() == 0
+    ```
+
+=== "Swift"
+
+    ```swift title="deque.swift"
+    /* 両端キューを初期化 */
+    // Swiftには組み込みの両端キュークラスがないため、Arrayを両端キューとして使用
+    var deque: [Int] = []
+
+    /* 要素をエンキュー */
+    deque.append(2) // 末尾に追加
+    deque.append(5)
+    deque.append(4)
+    deque.insert(3, at: 0) // 先頭に追加
+    deque.insert(1, at: 0)
+
+    /* 要素にアクセス */
+    let peekFirst = deque.first! // 先頭要素
+    let peekLast = deque.last!   // 末尾要素
+
+    /* 要素をデキュー */
+    // Arrayを使用する場合、popFirstの計算量はO(n)
+    let popFirst = deque.removeFirst() // 先頭要素をデキュー
+    let popLast = deque.removeLast()   // 末尾要素をデキュー
+
+    /* 両端キューの長さを取得 */
+    let size = deque.count
+
+    /* 両端キューが空かどうかを確認 */
+    let isEmpty = deque.isEmpty
+    ```
+
+=== "JS"
+
+    ```javascript title="deque.js"
+    /* 両端キューを初期化 */
+    // JavaScriptには組み込みの両端キューがないため、Arrayを両端キューとして使用
+    const deque = [];
+
+    /* 要素をエンキュー */
+    deque.push(2);
+    deque.push(5);
+    deque.push(4);
+    // 注意：unshift()は配列のため時間計算量がO(n)
+    deque.unshift(3);
+    deque.unshift(1);
+
+    /* 要素にアクセス */
+    const peekFirst = deque[0]; // 先頭要素
+    const peekLast = deque[deque.length - 1]; // 末尾要素
+
+    /* 要素をデキュー */
+    // 注意：shift()は配列のため時間計算量がO(n)
+    const popFront = deque.shift(); // 先頭要素をデキュー
+    const popBack = deque.pop();    // 末尾要素をデキュー
+
+    /* 両端キューの長さを取得 */
+    const size = deque.length;
+
+    /* 両端キューが空かどうかを確認 */
+    const isEmpty = size === 0;
+    ```
+
+=== "TS"
+
+    ```typescript title="deque.ts"
+    /* 両端キューを初期化 */
+    // TypeScriptには組み込みの両端キューがないため、Arrayを両端キューとして使用
+    const deque: number[] = [];
+
+    /* 要素をエンキュー */
+    deque.push(2);
+    deque.push(5);
+    deque.push(4);
+    // 注意：unshift()は配列のため時間計算量がO(n)
+    deque.unshift(3);
+    deque.unshift(1);
+
+    /* 要素にアクセス */
+    const peekFirst: number = deque[0]; // 先頭要素
+    const peekLast: number = deque[deque.length - 1]; // 末尾要素
+
+    /* 要素をデキュー */
+    // 注意：shift()は配列のため時間計算量がO(n)
+    const popFront: number = deque.shift() as number; // 先頭要素をデキュー
+    const popBack: number = deque.pop() as number;    // 末尾要素をデキュー
+
+    /* 両端キューの長さを取得 */
+    const size: number = deque.length;
+
+    /* 両端キューが空かどうかを確認 */
+    const isEmpty: boolean = size === 0;
+    ```
+
+=== "Dart"
+
+    ```dart title="deque.dart"
+    /* 両端キューを初期化 */
+    // Dartでは、Queueが両端キューとして定義される
+    Queue<int> deque = Queue<int>();
+
+    /* 要素をエンキュー */
+    deque.addLast(2);  // 末尾に追加
+    deque.addLast(5);
+    deque.addLast(4);
+    deque.addFirst(3); // 先頭に追加
+    deque.addFirst(1);
+
+    /* 要素にアクセス */
+    int peekFirst = deque.first; // 先頭要素
+    int peekLast = deque.last;   // 末尾要素
+
+    /* 要素をデキュー */
+    int popFirst = deque.removeFirst(); // 先頭要素をデキュー
+    int popLast = deque.removeLast();   // 末尾要素をデキュー
+
+    /* 両端キューの長さを取得 */
+    int size = deque.length;
+
+    /* 両端キューが空かどうかを確認 */
+    bool isEmpty = deque.isEmpty;
+    ```
+
+=== "Rust"
+
+    ```rust title="deque.rs"
+    /* 両端キューを初期化 */
+    let mut deque: VecDeque<u32> = VecDeque::new();
+
+    /* 要素をエンキュー */
+    deque.push_back(2);  // 末尾に追加
+    deque.push_back(5);
+    deque.push_back(4);
+    deque.push_front(3); // 先頭に追加
+    deque.push_front(1);
+
+    /* 要素にアクセス */
+    if let Some(front) = deque.front() { // 先頭要素
+    }
+    if let Some(rear) = deque.back() {   // 末尾要素
+    }
+
+    /* 要素をデキュー */
+    if let Some(pop_front) = deque.pop_front() { // 先頭要素をデキュー
+    }
+    if let Some(pop_rear) = deque.pop_back() {   // 末尾要素をデキュー
+    }
+
+    /* 両端キューの長さを取得 */
+    let size = deque.len();
+
+    /* 両端キューが空かどうかを確認 */
+    let is_empty = deque.is_empty();
+    ```
+
+=== "C"
+
+    ```c title="deque.c"
+    // Cには組み込みの両端キューが提供されていません
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title="deque.kt"
+
+    ```
+
+=== "Zig"
+
+    ```zig title="deque.zig"
+
+    ```
+
+## 両端キューの実装 *
+
+両端キューの実装は通常のキューの実装と似ており、連結リストまたは配列を基盤となるデータ構造として使用できます。
+
+### 双方向連結リストに基づく実装
+
+前節で、通常の単一連結リストを使ってキューを実装したことを思い出してください。これは先頭からの削除（デキュー操作に対応）と末尾への新しい要素の追加（エンキュー操作に対応）を便利に行えるためでした。
+
+両端キューでは、先頭と末尾の両方でエンキューとデキュー操作を実行できます。つまり、両端キューは逆方向の操作も実装する必要があります。このため、両端キューの基盤となるデータ構造として「双方向連結リスト」を使用します。
+
+下図に示すように、双方向連結リストの先頭ノードと末尾ノードをそれぞれ両端キューの前端と後端として扱い、両端でのノードの追加と削除機能を実装します。
+
+=== "LinkedListDeque"
+    ![双方向連結リストによる両端キューのエンキューとデキュー操作の実装](deque.assets/linkedlist_deque_step1.png)
+
+=== "pushLast()"
+    ![linkedlist_deque_push_last](deque.assets/linkedlist_deque_step2_push_last.png)
+
+=== "pushFirst()"
+    ![linkedlist_deque_push_first](deque.assets/linkedlist_deque_step3_push_first.png)
+
+=== "popLast()"
+    ![linkedlist_deque_pop_last](deque.assets/linkedlist_deque_step4_pop_last.png)
+
+=== "popFirst()"
+    ![linkedlist_deque_pop_first](deque.assets/linkedlist_deque_step5_pop_first.png)
+
+実装コードは以下の通りです：
+
+```src
+[file]{linkedlist_deque}-[class]{linked_list_deque}-[func]{}
+```
+
+### 配列に基づく実装
+
+下図に示すように、配列でキューを実装するのと同様に、循環配列を使って両端キューを実装することもできます。
+
+=== "ArrayDeque"
+    ![配列による両端キューのエンキューとデキュー操作の実装](deque.assets/array_deque_step1.png)
+
+=== "pushLast()"
+    ![array_deque_push_last](deque.assets/array_deque_step2_push_last.png)
+
+=== "pushFirst()"
+    ![array_deque_push_first](deque.assets/array_deque_step3_push_first.png)
+
+=== "popLast()"
+    ![array_deque_pop_last](deque.assets/array_deque_step4_pop_last.png)
+
+=== "popFirst()"
+    ![array_deque_pop_first](deque.assets/array_deque_step5_pop_first.png)
+
+実装では「前端エンキュー」と「後端デキュー」のメソッドを追加するだけです：
+
+```src
+[file]{array_deque}-[class]{array_deque}-[func]{}
+```
+
+## 両端キューの応用
+
+両端キューはスタックとキューの両方のロジックを組み合わせているため、**それぞれのすべてのユースケースを実装でき、より大きな柔軟性を提供します**。
+
+ソフトウェアの「元に戻す」機能は通常スタックを使って実装されることを知っています：システムは各変更操作をスタックに`push`し、次に`pop`して元に戻すことを実装します。しかし、システムリソースの制限を考慮して、ソフトウェアは元に戻すステップの数を制限することがよくあります（例えば、最後の50ステップのみを許可）。スタックの長さが50を超えた場合、ソフトウェアはスタックの底部（キューの前端）で削除操作を実行する必要があります。**しかし、通常のスタックではこの機能を実行できないため、両端キューが必要になります**。「元に戻す」のコアロジックは依然としてスタックの後入れ先出し原則に従いますが、両端キューはより柔軟にいくつかの追加ロジックを実装できることに注意してください。

ja/docs/chapter_stack_and_queue/index.md

@@ -0,0 +1,9 @@
+# スタックとキュー
+
+![スタックとキュー](../assets/covers/chapter_stack_and_queue.jpg)
+
+!!! abstract
+
+    スタックは積み重ねられた猫のようなもので、キューは一列に並んだ猫のようなものです。
+
+    それらはそれぞれ、後入先出（LIFO）と先入先出（FIFO）の論理関係を表しています。

ja/docs/chapter_stack_and_queue/queue.md

@@ -0,0 +1,377 @@
+# キュー
+
+<u>キュー</u>は、先入先出（FIFO）ルールに従う線形データ構造です。名前が示すように、キューは行列の現象をシミュレートし、新参者は列の後ろに並び、前の人が最初に列を離れます。
+
+下図に示すように、キューの前面を「ヘッド」、後面を「テール」と呼びます。キューの後ろに要素を追加する操作を「エンキュー」、前から要素を削除する操作を「デキュー」と呼びます。
+
+![キューの先入先出ルール](queue.assets/queue_operations.png)
+
+## キューの一般的な操作
+
+キューの一般的な操作を下表に示します。メソッド名はプログラミング言語によって異なる場合があることに注意してください。ここでは、スタックで使用したのと同じ命名規則を使用します。
+
+<p align="center"> 表 <id> &nbsp; キュー操作の効率 </p>
+
+| メソッド名 | 説明                            | 時間計算量 |
+| ----------- | -------------------------------------- | --------------- |
+| `push()`    | 要素をエンキュー、テールに追加 | $O(1)$          |
+| `pop()`     | ヘッド要素をデキュー               | $O(1)$          |
+| `peek()`    | ヘッド要素にアクセス                | $O(1)$          |
+
+プログラミング言語で用意されているキュークラスを直接使用できます：
+
+=== "Python"
+
+    ```python title="queue.py"
+    from collections import deque
+
+    # キューを初期化
+    # Pythonでは、一般的にdequeクラスをキューとして使用します
+    # queue.Queue()は純粋なキュークラスですが、使いにくいため推奨されません
+    que: deque[int] = deque()
+
+    # 要素をエンキュー
+    que.append(1)
+    que.append(3)
+    que.append(2)
+    que.append(5)
+    que.append(4)
+
+    # 最初の要素にアクセス
+    front: int = que[0]
+
+    # 要素をデキュー
+    pop: int = que.popleft()
+
+    # キューの長さを取得
+    size: int = len(que)
+
+    # キューが空かどうかチェック
+    is_empty: bool = len(que) == 0
+    ```
+
+=== "C++"
+
+    ```cpp title="queue.cpp"
+    /* キューを初期化 */
+    queue<int> queue;
+
+    /* 要素をエンキュー */
+    queue.push(1);
+    queue.push(3);
+    queue.push(2);
+    queue.push(5);
+    queue.push(4);
+
+    /* 最初の要素にアクセス */
+    int front = queue.front();
+
+    /* 要素をデキュー */
+    queue.pop();
+
+    /* キューの長さを取得 */
+    int size = queue.size();
+
+    /* キューが空かどうかチェック */
+    bool empty = queue.empty();
+    ```
+
+=== "Java"
+
+    ```java title="queue.java"
+    /* キューを初期化 */
+    Queue<Integer> queue = new LinkedList<>();
+
+    /* 要素をエンキュー */
+    queue.offer(1);
+    queue.offer(3);
+    queue.offer(2);
+    queue.offer(5);
+    queue.offer(4);
+
+    /* 最初の要素にアクセス */
+    int peek = queue.peek();
+
+    /* 要素をデキュー */
+    int pop = queue.poll();
+
+    /* キューの長さを取得 */
+    int size = queue.size();
+
+    /* キューが空かどうかチェック */
+    boolean isEmpty = queue.isEmpty();
+    ```
+
+=== "C#"
+
+    ```csharp title="queue.cs"
+    /* キューを初期化 */
+    Queue<int> queue = new();
+
+    /* 要素をエンキュー */
+    queue.Enqueue(1);
+    queue.Enqueue(3);
+    queue.Enqueue(2);
+    queue.Enqueue(5);
+    queue.Enqueue(4);
+
+    /* 最初の要素にアクセス */
+    int peek = queue.Peek();
+
+    /* 要素をデキュー */
+    int pop = queue.Dequeue();
+
+    /* キューの長さを取得 */
+    int size = queue.Count;
+
+    /* キューが空かどうかチェック */
+    bool isEmpty = queue.Count == 0;
+    ```
+
+=== "Go"
+
+    ```go title="queue_test.go"
+    /* キューを初期化 */
+    // Goでは、listをキューとして使用
+    queue := list.New()
+
+    /* 要素をエンキュー */
+    queue.PushBack(1)
+    queue.PushBack(3)
+    queue.PushBack(2)
+    queue.PushBack(5)
+    queue.PushBack(4)
+
+    /* 最初の要素にアクセス */
+    peek := queue.Front()
+
+    /* 要素をデキュー */
+    pop := queue.Front()
+    queue.Remove(pop)
+
+    /* キューの長さを取得 */
+    size := queue.Len()
+
+    /* キューが空かどうかチェック */
+    isEmpty := queue.Len() == 0
+    ```
+
+=== "Swift"
+
+    ```swift title="queue.swift"
+    /* キューを初期化 */
+    // Swiftには組み込みのキュークラスがないため、Arrayをキューとして使用
+    var queue: [Int] = []
+
+    /* 要素をエンキュー */
+    queue.append(1)
+    queue.append(3)
+    queue.append(2)
+    queue.append(5)
+    queue.append(4)
+
+    /* 最初の要素にアクセス */
+    let peek = queue.first!
+
+    /* 要素をデキュー */
+    // 配列なので、removeFirstの計算量はO(n)
+    let pool = queue.removeFirst()
+
+    /* キューの長さを取得 */
+    let size = queue.count
+
+    /* キューが空かどうかチェック */
+    let isEmpty = queue.isEmpty
+    ```
+
+=== "JS"
+
+    ```javascript title="queue.js"
+    /* キューを初期化 */
+    // JavaScriptには組み込みのキューがないため、Arrayをキューとして使用
+    const queue = [];
+
+    /* 要素をエンキュー */
+    queue.push(1);
+    queue.push(3);
+    queue.push(2);
+    queue.push(5);
+    queue.push(4);
+
+    /* 最初の要素にアクセス */
+    const peek = queue[0];
+
+    /* 要素をデキュー */
+    // 基礎構造が配列なので、shift()メソッドの時間計算量はO(n)
+    const pop = queue.shift();
+
+    /* キューの長さを取得 */
+    const size = queue.length;
+
+    /* キューが空かどうかチェック */
+    const empty = queue.length === 0;
+    ```
+
+=== "TS"
+
+    ```typescript title="queue.ts"
+    /* キューを初期化 */
+    // TypeScriptには組み込みのキューがないため、Arrayをキューとして使用
+    const queue: number[] = [];
+
+    /* 要素をエンキュー */
+    queue.push(1);
+    queue.push(3);
+    queue.push(2);
+    queue.push(5);
+    queue.push(4);
+
+    /* 最初の要素にアクセス */
+    const peek = queue[0];
+
+    /* 要素をデキュー */
+    // 基礎構造が配列なので、shift()メソッドの時間計算量はO(n)
+    const pop = queue.shift();
+
+    /* キューの長さを取得 */
+    const size = queue.length;
+
+    /* キューが空かどうかチェック */
+    const empty = queue.length === 0;
+    ```
+
+=== "Dart"
+
+    ```dart title="queue.dart"
+    /* キューを初期化 */
+    // DartのQueueクラスは双方向キューですが、キューとして使用できます
+    Queue<int> queue = Queue();
+
+    /* 要素をエンキュー */
+    queue.add(1);
+    queue.add(3);
+    queue.add(2);
+    queue.add(5);
+    queue.add(4);
+
+    /* 最初の要素にアクセス */
+    int peek = queue.first;
+
+    /* 要素をデキュー */
+    int pop = queue.removeFirst();
+
+    /* キューの長さを取得 */
+    int size = queue.length;
+
+    /* キューが空かどうかチェック */
+    bool isEmpty = queue.isEmpty;
+    ```
+
+=== "Rust"
+
+    ```rust title="queue.rs"
+    /* 双方向キューを初期化 */
+    // Rustでは、双方向キューを通常のキューとして使用
+    let mut deque: VecDeque<u32> = VecDeque::new();
+
+    /* 要素をエンキュー */
+    deque.push_back(1);
+    deque.push_back(3);
+    deque.push_back(2);
+    deque.push_back(5);
+    deque.push_back(4);
+
+    /* 最初の要素にアクセス */
+    if let Some(front) = deque.front() {
+    }
+
+    /* 要素をデキュー */
+    if let Some(pop) = deque.pop_front() {
+    }
+
+    /* キューの長さを取得 */
+    let size = deque.len();
+
+    /* キューが空かどうかチェック */
+    let is_empty = deque.is_empty();
+    ```
+
+=== "C"
+
+    ```c title="queue.c"
+    // Cは組み込みのキューを提供していません
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title="queue.kt"
+
+    ```
+
+=== "Zig"
+
+    ```zig title="queue.zig"
+
+    ```
+
+## キューの実装
+
+キューを実装するには、一方の端で要素を追加し、もう一方の端で要素を削除できるデータ構造が必要です。連結リストと配列の両方がこの要件を満たします。
+
+### 連結リストベースの実装
+
+下図に示すように、連結リストの「ヘッドノード」と「テールノード」をそれぞれキューの「フロント」と「リア」と考えることができます。ノードは後ろでのみ追加でき、前でのみ削除できるように規定されています。
+
+=== "LinkedListQueue"
+    ![連結リストによるキュー実装のエンキューとデキュー操作](queue.assets/linkedlist_queue_step1.png)
+
+=== "push()"
+    ![linkedlist_queue_push](queue.assets/linkedlist_queue_step2_push.png)
+
+=== "pop()"
+    ![linkedlist_queue_pop](queue.assets/linkedlist_queue_step3_pop.png)
+
+以下は、連結リストを使用してキューを実装するコードです：
+
+```src
+[file]{linkedlist_queue}-[class]{linked_list_queue}-[func]{}
+```
+
+### 配列ベースの実装
+
+配列の最初の要素を削除する時間計算量は$O(n)$で、デキュー操作が非効率になります。しかし、この問題は以下のように巧妙に回避できます。
+
+変数`front`を使用してフロント要素のインデックスを示し、変数`size`を維持してキューの長さを記録します。`rear = front + size`を定義し、これはテール要素の直後の位置を指します。
+
+この設計により、**配列内の要素の有効な間隔は`[front, rear - 1]`です**。各操作の実装方法を下図に示します。
+
+- エンキュー操作：入力要素を`rear`インデックスに割り当て、`size`を1増加させます。
+- デキュー操作：単に`front`を1増加させ、`size`を1減少させます。
+
+エンキューとデキュー操作は両方とも単一の操作のみを必要とし、それぞれの時間計算量は$O(1)$です。
+
+=== "ArrayQueue"
+    ![配列によるキュー実装のエンキューとデキュー操作](queue.assets/array_queue_step1.png)
+
+=== "push()"
+    ![array_queue_push](queue.assets/array_queue_step2_push.png)
+
+=== "pop()"
+    ![array_queue_pop](queue.assets/array_queue_step3_pop.png)
+
+問題に気づくかもしれません：エンキューとデキュー操作が継続的に実行されると、`front`と`rear`の両方が右に移動し、**最終的に配列の末尾に到達してそれ以上移動できなくなります**。これを解決するために、配列を「循環配列」として扱い、配列の末尾を先頭に接続します。
+
+循環配列では、`front`または`rear`が末尾に到達すると、配列の先頭にループバックする必要があります。この循環パターンは、以下のコードに示すように「剰余演算」で実現できます：
+
+```src
+[file]{array_queue}-[class]{array_queue}-[func]{}
+```
+
+上記のキュー実装にはまだ制限があります：長さが固定されています。しかし、この問題は解決が困難ではありません。配列を必要に応じて自動拡張できる動的配列に置き換えることができます。興味のある読者は自分で実装してみてください。
+
+2つの実装の比較はスタックの場合と一貫しており、ここでは繰り返しません。
+
+## キューの典型的な応用
+
+- **Amazonの注文**：買い物客が注文を行った後、これらの注文はキューに参加し、システムは順番に処理します。独身の日などのイベント中は、短時間で大量の注文が生成され、高い同時実行性がエンジニアにとって重要な課題となります。
+- **様々なToDoリスト**：「先着順」機能が必要なシナリオ、例えばプリンターのタスクキューやレストランの配達キューなど、キューで処理順序を効果的に維持できます。

ja/docs/chapter_stack_and_queue/stack.md

@@ -0,0 +1,385 @@
+# スタック
+
+<u>スタック</u>は、後入先出（LIFO）の原則に従う線形データ構造です。
+
+スタックをテーブル上の皿の山に例えることができます。底の皿にアクセスするには、まず上の皿を取り除く必要があります。皿を様々な種類の要素（整数、文字、オブジェクトなど）に置き換えることで、スタックと呼ばれるデータ構造を得ることができます。
+
+下図に示すように、要素の山の上部を「スタックのトップ」、下部を「スタックのボトム」と呼びます。スタックのトップに要素を追加する操作を「プッシュ」、トップ要素を削除する操作を「ポップ」と呼びます。
+
+![スタックの後入先出ルール](stack.assets/stack_operations.png)
+
+## スタックの一般的な操作
+
+スタックの一般的な操作を下表に示します。具体的なメソッド名は使用するプログラミング言語によって異なります。ここでは、例として`push()`、`pop()`、`peek()`を使用します。
+
+<p align="center"> 表 <id> &nbsp; スタック操作の効率 </p>
+
+| メソッド   | 説明                                     | 時間計算量 |
+| -------- | ----------------------------------------------- | --------------- |
+| `push()` | 要素をスタックにプッシュ（トップに追加） | $O(1)$          |
+| `pop()`  | スタックからトップ要素をポップ              | $O(1)$          |
+| `peek()` | スタックのトップ要素にアクセス             | $O(1)$          |
+
+通常、プログラミング言語に組み込まれているスタッククラスを直接使用できます。ただし、一部の言語では具体的にスタッククラスを提供していない場合があります。これらの場合、言語の「配列」または「連結リスト」をスタックとして使用し、プログラムでスタックロジックに関連しない操作を無視できます。
+
+=== "Python"
+
+    ```python title="stack.py"
+    # スタックを初期化
+    # Pythonには組み込みのスタッククラスがないため、listをスタックとして使用
+    stack: list[int] = []
+
+    # 要素をスタックにプッシュ
+    stack.append(1)
+    stack.append(3)
+    stack.append(2)
+    stack.append(5)
+    stack.append(4)
+
+    # スタックのトップ要素にアクセス
+    peek: int = stack[-1]
+
+    # スタックから要素をポップ
+    pop: int = stack.pop()
+
+    # スタックの長さを取得
+    size: int = len(stack)
+
+    # スタックが空かどうかチェック
+    is_empty: bool = len(stack) == 0
+    ```
+
+=== "C++"
+
+    ```cpp title="stack.cpp"
+    /* スタックを初期化 */
+    stack<int> stack;
+
+    /* 要素をスタックにプッシュ */
+    stack.push(1);
+    stack.push(3);
+    stack.push(2);
+    stack.push(5);
+    stack.push(4);
+
+    /* スタックのトップ要素にアクセス */
+    int top = stack.top();
+
+    /* スタックから要素をポップ */
+    stack.pop(); // 戻り値なし
+
+    /* スタックの長さを取得 */
+    int size = stack.size();
+
+    /* スタックが空かどうかチェック */
+    bool empty = stack.empty();
+    ```
+
+=== "Java"
+
+    ```java title="stack.java"
+    /* スタックを初期化 */
+    Stack<Integer> stack = new Stack<>();
+
+    /* 要素をスタックにプッシュ */
+    stack.push(1);
+    stack.push(3);
+    stack.push(2);
+    stack.push(5);
+    stack.push(4);
+
+    /* スタックのトップ要素にアクセス */
+    int peek = stack.peek();
+
+    /* スタックから要素をポップ */
+    int pop = stack.pop();
+
+    /* スタックの長さを取得 */
+    int size = stack.size();
+
+    /* スタックが空かどうかチェック */
+    boolean isEmpty = stack.isEmpty();
+    ```
+
+=== "C#"
+
+    ```csharp title="stack.cs"
+    /* スタックを初期化 */
+    Stack<int> stack = new();
+
+    /* 要素をスタックにプッシュ */
+    stack.Push(1);
+    stack.Push(3);
+    stack.Push(2);
+    stack.Push(5);
+    stack.Push(4);
+
+    /* スタックのトップ要素にアクセス */
+    int peek = stack.Peek();
+
+    /* スタックから要素をポップ */
+    int pop = stack.Pop();
+
+    /* スタックの長さを取得 */
+    int size = stack.Count;
+
+    /* スタックが空かどうかチェック */
+    bool isEmpty = stack.Count == 0;
+    ```
+
+=== "Go"
+
+    ```go title="stack_test.go"
+    /* スタックを初期化 */
+    // Goでは、Sliceをスタックとして使用することが推奨されます
+    var stack []int
+
+    /* 要素をスタックにプッシュ */
+    stack = append(stack, 1)
+    stack = append(stack, 3)
+    stack = append(stack, 2)
+    stack = append(stack, 5)
+    stack = append(stack, 4)
+
+    /* スタックのトップ要素にアクセス */
+    peek := stack[len(stack)-1]
+
+    /* スタックから要素をポップ */
+    pop := stack[len(stack)-1]
+    stack = stack[:len(stack)-1]
+
+    /* スタックの長さを取得 */
+    size := len(stack)
+
+    /* スタックが空かどうかチェック */
+    isEmpty := len(stack) == 0
+    ```
+
+=== "Swift"
+
+    ```swift title="stack.swift"
+    /* スタックを初期化 */
+    // Swiftには組み込みのスタッククラスがないため、Arrayをスタックとして使用
+    var stack: [Int] = []
+
+    /* 要素をスタックにプッシュ */
+    stack.append(1)
+    stack.append(3)
+    stack.append(2)
+    stack.append(5)
+    stack.append(4)
+
+    /* スタックのトップ要素にアクセス */
+    let peek = stack.last!
+
+    /* スタックから要素をポップ */
+    let pop = stack.removeLast()
+
+    /* スタックの長さを取得 */
+    let size = stack.count
+
+    /* スタックが空かどうかチェック */
+    let isEmpty = stack.isEmpty
+    ```
+
+=== "JS"
+
+    ```javascript title="stack.js"
+    /* スタックを初期化 */
+    // JavaScriptには組み込みのスタッククラスがないため、Arrayをスタックとして使用
+    const stack = [];
+
+    /* 要素をスタックにプッシュ */
+    stack.push(1);
+    stack.push(3);
+    stack.push(2);
+    stack.push(5);
+    stack.push(4);
+
+    /* スタックのトップ要素にアクセス */
+    const peek = stack[stack.length-1];
+
+    /* スタックから要素をポップ */
+    const pop = stack.pop();
+
+    /* スタックの長さを取得 */
+    const size = stack.length;
+
+    /* スタックが空かどうかチェック */
+    const is_empty = stack.length === 0;
+    ```
+
+=== "TS"
+
+    ```typescript title="stack.ts"
+    /* スタックを初期化 */
+    // TypeScriptには組み込みのスタッククラスがないため、Arrayをスタックとして使用
+    const stack: number[] = [];
+
+    /* 要素をスタックにプッシュ */
+    stack.push(1);
+    stack.push(3);
+    stack.push(2);
+    stack.push(5);
+    stack.push(4);
+
+    /* スタックのトップ要素にアクセス */
+    const peek = stack[stack.length - 1];
+
+    /* スタックから要素をポップ */
+    const pop = stack.pop();
+
+    /* スタックの長さを取得 */
+    const size = stack.length;
+
+    /* スタックが空かどうかチェック */
+    const is_empty = stack.length === 0;
+    ```
+
+=== "Dart"
+
+    ```dart title="stack.dart"
+    /* スタックを初期化 */
+    // Dartには組み込みのスタッククラスがないため、Listをスタックとして使用
+    List<int> stack = [];
+
+    /* 要素をスタックにプッシュ */
+    stack.add(1);
+    stack.add(3);
+    stack.add(2);
+    stack.add(5);
+    stack.add(4);
+
+    /* スタックのトップ要素にアクセス */
+    int peek = stack.last;
+
+    /* スタックから要素をポップ */
+    int pop = stack.removeLast();
+
+    /* スタックの長さを取得 */
+    int size = stack.length;
+
+    /* スタックが空かどうかチェック */
+    bool isEmpty = stack.isEmpty;
+    ```
+
+=== "Rust"
+
+    ```rust title="stack.rs"
+    /* スタックを初期化 */
+    // Vecをスタックとして使用
+    let mut stack: Vec<i32> = Vec::new();
+
+    /* 要素をスタックにプッシュ */
+    stack.push(1);
+    stack.push(3);
+    stack.push(2);
+    stack.push(5);
+    stack.push(4);
+
+    /* スタックのトップ要素にアクセス */
+    let top = stack.last().unwrap();
+
+    /* スタックから要素をポップ */
+    let pop = stack.pop().unwrap();
+
+    /* スタックの長さを取得 */
+    let size = stack.len();
+
+    /* スタックが空かどうかチェック */
+    let is_empty = stack.is_empty();
+    ```
+
+=== "C"
+
+    ```c title="stack.c"
+    // Cは組み込みのスタックを提供していません
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title="stack.kt"
+
+    ```
+
+=== "Zig"
+
+    ```zig title="stack.zig"
+
+    ```
+
+## スタックの実装
+
+スタックがどのように動作するかをより深く理解するために、自分でスタッククラスを実装してみましょう。
+
+スタックは後入先出の原則に従うため、スタックのトップでのみ要素を追加または削除できます。しかし、配列と連結リストの両方は任意の位置で要素を追加・削除できるため、**スタックは制限された配列または連結リストと見なすことができます**。言い換えれば、配列や連結リストの特定の無関係な操作を「遮蔽」して、外部の動作をスタックの特性に合わせることができます。
+
+### 連結リストベースの実装
+
+連結リストを使用してスタックを実装する場合、リストのヘッドノードをスタックのトップ、テールノードをスタックのボトムと考えることができます。
+
+下図に示すように、プッシュ操作では、単に連結リストのヘッドに要素を挿入します。このノード挿入方法は「ヘッド挿入」として知られています。ポップ操作では、リストからヘッドノードを削除するだけです。
+
+=== "LinkedListStack"
+    ![連結リストによるスタック実装のプッシュとポップ操作](stack.assets/linkedlist_stack_step1.png)
+
+=== "push()"
+    ![linkedlist_stack_push](stack.assets/linkedlist_stack_step2_push.png)
+
+=== "pop()"
+    ![linkedlist_stack_pop](stack.assets/linkedlist_stack_step3_pop.png)
+
+以下は、連結リストに基づくスタック実装のサンプルコードです：
+
+```src
+[file]{linkedlist_stack}-[class]{linked_list_stack}-[func]{}
+```
+
+### 配列ベースの実装
+
+配列を使用してスタックを実装する場合、配列の末尾をスタックのトップと考えることができます。下図に示すように、プッシュとポップ操作は、それぞれ配列の末尾での要素の追加と削除に対応し、どちらも時間計算量$O(1)$です。
+
+=== "ArrayStack"
+    ![配列によるスタック実装のプッシュとポップ操作](stack.assets/array_stack_step1.png)
+
+=== "push()"
+    ![array_stack_push](stack.assets/array_stack_step2_push.png)
+
+=== "pop()"
+    ![array_stack_pop](stack.assets/array_stack_step3_pop.png)
+
+スタックにプッシュされる要素が継続的に増加する可能性があるため、動的配列を使用でき、配列拡張を自分で処理する必要がありません。以下はサンプルコードです：
+
+```src
+[file]{array_stack}-[class]{array_stack}-[func]{}
+```
+
+## 2つの実装の比較
+
+**サポートされる操作**
+
+両方の実装は、スタックで定義されたすべての操作をサポートします。配列実装はさらにランダムアクセスをサポートしますが、これはスタック定義の範囲を超えており、一般的には使用されません。
+
+**時間効率**
+
+配列ベースの実装では、プッシュとポップ操作の両方が事前に割り当てられた連続メモリで発生し、良好なキャッシュ局所性があるため効率が高くなります。しかし、プッシュ操作が配列容量を超える場合、リサイズメカニズムがトリガーされ、そのプッシュ操作の時間計算量は$O(n)$になります。
+
+連結リスト実装では、リスト拡張は非常に柔軟で、配列拡張のような効率低下の問題はありません。しかし、プッシュ操作にはノードオブジェクトの初期化とポインタの変更が必要なため、効率は比較的低くなります。プッシュされる要素がすでにノードオブジェクトの場合、初期化ステップをスキップでき、効率が向上します。
+
+したがって、プッシュとポップ操作の要素が`int`や`double`などの基本データ型の場合、以下の結論を導くことができます：
+
+- 配列ベースのスタック実装は拡張時に効率が低下しますが、拡張は低頻度操作であるため、平均効率は高くなります。
+- 連結リストベースのスタック実装はより安定した効率パフォーマンスを提供します。
+
+**空間効率**
+
+リストを初期化する際、システムは「初期容量」を割り当てますが、これは実際の必要量を超える可能性があります。さらに、拡張メカニズムは通常、特定の係数（2倍など）で容量を増加させ、これも実際の必要量を超える可能性があります。したがって、**配列ベースのスタックは一部の空間を無駄にする可能性があります**。
+
+しかし、連結リストノードはポインタを格納するための追加空間が必要なため、**連結リストノードが占有する空間は比較的大きくなります**。
+
+まとめると、どちらの実装がよりメモリ効率的かを単純に判断することはできません。特定の状況に基づく分析が必要です。
+
+## スタックの典型的な応用
+
+- **ブラウザの戻ると進む、ソフトウェアの元に戻すとやり直し**。新しいWebページを開くたびに、ブラウザは前のページをスタックにプッシュし、戻る操作（本質的にはポップ操作）を通じて前のページに戻ることができます。戻ると進むの両方をサポートするには、2つのスタックが連携して動作する必要があります。
+- **プログラムのメモリ管理**。関数が呼び出されるたびに、システムはスタックのトップにスタックフレームを追加して関数のコンテキスト情報を記録します。再帰関数では、下方向の再帰フェーズはスタックへのプッシュを続け、上方向のバックトラッキングフェーズはスタックからのポップを続けます。

ja/docs/chapter_stack_and_queue/summary.md

@@ -0,0 +1,31 @@
+# まとめ
+
+### 重要なポイント
+
+- スタックは後入れ先出し（LIFO）の原則に従うデータ構造で、配列または連結リストを使って実装できます。
+- 時間効率の観点では、スタックの配列実装の方が平均的な効率が高いです。ただし、拡張時には単一のプッシュ操作の時間計算量が$O(n)$に悪化する可能性があります。対照的に、スタックの連結リスト実装はより安定した効率を提供します。
+- 空間効率に関しては、スタックの配列実装は一定程度の空間の無駄につながる可能性があります。ただし、連結リストのノードが占有するメモリ空間は一般的に配列の要素よりも大きいことに注意することが重要です。
+- キューは先入れ先出し（FIFO）の原則に従うデータ構造で、同様に配列または連結リストを使って実装できます。キューの時間と空間効率に関する結論は、スタックと似ています。
+- 両端キュー（deque）はより柔軟なキューの種類で、両端での要素の追加と削除を可能にします。
+
+### Q & A
+
+**Q**: ブラウザの進む・戻る機能は双方向連結リストで実装されているのですか？
+
+ブラウザの進む・戻るナビゲーションは本質的に「スタック」概念の現れです。ユーザーが新しいページを訪問すると、そのページがスタックの先頭に追加されます。戻るボタンをクリックすると、ページがスタックの先頭からポップされます。両端キュー（deque）は、「両端キュー」の章で述べたように、いくつかの追加操作を便利に実装できます。
+
+**Q**: スタックからポップした後、ポップされたノードのメモリを解放する必要がありますか？
+
+ポップされたノードが後で使用される場合は、そのメモリを解放する必要はありません。自動ガベージコレクションを持つJavaやPythonなどの言語では、手動のメモリ解放は必要ありません。CやC++では、手動のメモリ解放が必要です。
+
+**Q**: 両端キューは2つのスタックを結合したもののように見えます。その用途は何ですか？
+
+両端キューは、スタックとキューの組み合わせまたは2つのスタックを結合したもので、スタックとキューの両方のロジックを示します。したがって、スタックとキューのすべてのアプリケーションを実装でき、より大きな柔軟性を提供します。
+
+**Q**: 元に戻すとやり直しは具体的にどのように実装されるのですか？
+
+元に戻すとやり直しの操作は2つのスタックを使って実装されます：元に戻す用のスタック`A`とやり直し用のスタック`B`です。
+
+1. ユーザーが操作を実行するたびに、それがスタック`A`にプッシュされ、スタック`B`がクリアされます。
+2. ユーザーが「元に戻す」を実行すると、最新の操作がスタック`A`からポップされ、スタック`B`にプッシュされます。
+3. ユーザーが「やり直し」を実行すると、最新の操作がスタック`B`からポップされ、スタック`A`に戻されます。