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_searching/binary_search.md

@@ -0,0 +1,83 @@
+# 二分探索
+
+<u>二分探索</u>は分割統治戦略を用いる効率的な探索アルゴリズムです。配列内の要素の整列順序を利用し、各反復で探索区間を半分に減らしながら、目標要素が見つかるか探索区間が空になるまで続行します。
+
+!!! question
+
+    長さ$n$の配列`nums`が与えられ、要素は重複なしで昇順に配列されています。この配列内の要素`target`のインデックスを見つけて返してください。配列に要素が含まれていない場合は$-1$を返してください。例を下図に示します。
+
+![Binary search example data](binary_search.assets/binary_search_example.png)
+
+下図に示すように、まず$i = 0$と$j = n - 1$でポインタを初期化し、それぞれ配列の最初と最後の要素を指します。これらはまた全体の探索区間$[0, n - 1]$を表します。角括弧は閉区間を示し、境界値自身も含むことに注意してください。
+
+そして、以下の2つのステップをループで実行する可能性があります。
+
+1. 中点インデックス$m = \lfloor {(i + j) / 2} \rfloor$を計算します。ここで$\lfloor \: \rfloor$は床関数を表します。
+2. `nums[m]`と`target`の比較に基づいて、以下の3つのケースのうち1つを選択して実行します。
+    1. `nums[m] < target`の場合、`target`は区間$[m + 1, j]$にあることを示すため、$i = m + 1$とします。
+    2. `nums[m] > target`の場合、`target`は区間$[i, m - 1]$にあることを示すため、$j = m - 1$とします。
+    3. `nums[m] = target`の場合、`target`が見つかったことを示すため、インデックス$m$を返します。
+
+配列に目標要素が含まれていない場合、探索区間は最終的に空になり、$-1$を返して終了します。
+
+=== "<1>"
+    ![Binary search process](binary_search.assets/binary_search_step1.png)
+
+=== "<2>"
+    ![binary_search_step2](binary_search.assets/binary_search_step2.png)
+
+=== "<3>"
+    ![binary_search_step3](binary_search.assets/binary_search_step3.png)
+
+=== "<4>"
+    ![binary_search_step4](binary_search.assets/binary_search_step4.png)
+
+=== "<5>"
+    ![binary_search_step5](binary_search.assets/binary_search_step5.png)
+
+=== "<6>"
+    ![binary_search_step6](binary_search.assets/binary_search_step6.png)
+
+=== "<7>"
+    ![binary_search_step7](binary_search.assets/binary_search_step7.png)
+
+$i$と$j$が両方とも`int`型であるため、**$i + j$は`int`型の範囲を超える可能性がある**ことは注目に値します。大きな数のオーバーフローを避けるため、通常は式$m = \lfloor {i + (j - i) / 2} \rfloor$を使用して中点を計算します。
+
+コードは以下の通りです：
+
+```src
+[file]{binary_search}-[class]{}-[func]{binary_search}
+```
+
+**時間計算量は$O(\log n)$です**：二分ループにおいて、区間は各ラウンドで半分に減少するため、反復回数は$\log_2 n$となります。
+
+**空間計算量は$O(1)$です**：ポインタ$i$と$j$は定数サイズの空間を占有します。
+
+## 区間表現方法
+
+上記の閉区間の他に、もう一つの一般的な区間表現は「左閉右開」区間で、$[0, n)$として定義され、左境界は自身を含み、右境界は含みません。この表現では、$i = j$のとき区間$[i, j)$は空になります。
+
+この表現に基づいて同じ機能を持つ二分探索アルゴリズムを実装できます：
+
+```src
+[file]{binary_search}-[class]{}-[func]{binary_search_lcro}
+```
+
+下図に示すように、2つの区間表現タイプにおいて、二分探索アルゴリズムの初期化、ループ条件、区間縮小操作が異なります。
+
+「閉区間」表現では両方の境界が包含的であるため、ポインタ$i$と$j$による区間縮小操作も対称的です。これによりエラーが発生しにくくなるため、**一般的に「閉区間」アプローチの使用が推奨されます**。
+
+![Two types of interval definitions](binary_search.assets/binary_search_ranges.png)
+
+## 利点と制限
+
+二分探索は時間と空間の両方の面で良好な性能を示します。
+
+- 二分探索は時間効率が良いです。大きなデータセットでは、対数時間計算量が大きな利点を提供します。例えば、サイズ$n = 2^{20}$のデータセットが与えられた場合、線形探索は$2^{20} = 1048576$回の反復が必要ですが、二分探索は$\log_2 2^{20} = 20$回のループのみで済みます。
+- 二分探索には追加の空間が必要ありません。追加の空間に依存する探索アルゴリズム（ハッシュ探索など）と比較して、二分探索はより空間効率的です。
+
+しかし、二分探索は以下の懸念により、すべてのシナリオに適しているとは限りません。
+
+- 二分探索はソート済みデータにのみ適用できます。未ソートのデータは二分探索を適用する前にソートする必要があり、ソートアルゴリズムは通常$O(n \log n)$の時間計算量を持つため、これは価値がないかもしれません。このコストは線形探索よりも高く、二分探索自体は言うまでもありません。頻繁な挿入があるシナリオでは、配列を順序に保つコストは非常に高く、特定の位置に新しい要素を挿入する時間計算量は$O(n)$です。
+- 二分探索は配列のみを使用できます。二分探索には非連続（ジャンプ）要素アクセスが必要で、これは連結リストでは非効率的です。そのため、連結リストや連結リストに基づくデータ構造はこのアルゴリズムに適していない可能性があります。
+- 線形探索は小さなデータセットでより良い性能を示します。線形探索では各反復で1つの判定操作のみが必要ですが、二分探索では1つの加算、1つの除算、1つから3つの判定操作、1つの加算（減算）を含み、合計4つから6つの操作が必要です。そのため、データサイズ$n$が小さい場合、線形探索は二分探索よりも高速です。

ja/docs/chapter_searching/binary_search_edge.md

@@ -0,0 +1,56 @@
+# 二分探索の境界
+
+## 左境界を見つける
+
+!!! question
+
+    重複要素を含む可能性がある長さ$n$のソート済み配列`nums`が与えられ、最も左の要素`target`のインデックスを返してください。要素が配列に存在しない場合は、$-1$を返してください。
+
+挿入位置の二分探索方法を思い出すと、探索完了後、インデックス$i$は`target`の最も左の出現を指します。したがって、**挿入位置の探索は本質的に最も左の`target`のインデックスを見つけることと同じです**。
+
+挿入位置を見つける関数を使用して`target`の左境界を見つけることができます。配列に`target`が含まれていない可能性があることに注意してください。これは以下の2つの結果につながる可能性があります：
+
+- 挿入位置のインデックス$i$が範囲外です。
+- 要素`nums[i]`が`target`と等しくありません。
+
+これらの場合、単に$-1$を返します。コードは以下の通りです：
+
+```src
+[file]{binary_search_edge}-[class]{}-[func]{binary_search_left_edge}
+```
+
+## 右境界を見つける
+
+`target`の最も右の出現をどのように見つけるでしょうか？最も直接的な方法は、`nums[m] == target`の場合に探索境界を調整する方法を変更して、従来の二分探索ロジックを修正することです。コードはここでは省略されています。興味がある場合は、自分でコードを実装してみてください。
+
+以下では、さらに2つの巧妙な方法を紹介します。
+
+### 左境界探索を再利用する
+
+`target`の最も右の出現を見つけるには、最も左の`target`を見つけるために使用された関数を再利用できます。具体的には、最も右のターゲットの探索を最も左のターゲット + 1の探索に変換します。
+
+下図に示すように、探索完了後、ポインタ$i$は最も左の`target + 1`（存在する場合）を指し、ポインタ$j$は`target`の最も右の出現を指します。したがって、$j$を返すことで右境界が得られます。
+
+![Transforming the search for the right boundary into the search for the left boundary](binary_search_edge.assets/binary_search_right_edge_by_left_edge.png)
+
+返される挿入位置は$i$であることに注意してください。したがって、$j$を得るためには1を引く必要があります：
+
+```src
+[file]{binary_search_edge}-[class]{}-[func]{binary_search_right_edge}
+```
+
+### 要素探索に変換する
+
+配列に`target`が含まれていない場合、$i$と$j$は最終的に`target`より大きい最初の要素と小さい最初の要素をそれぞれ指します。
+
+したがって、下図に示すように、配列に存在しない要素を構築して、左と右の境界を探索できます。
+
+- 最も左の`target`を見つけるには：`target - 0.5`を探索することに変換でき、ポインタ$i$を返します。
+- 最も右の`target`を見つけるには：`target + 0.5`を探索することに変換でき、ポインタ$j$を返します。
+
+![Transforming the search for boundaries into the search for an element](binary_search_edge.assets/binary_search_edge_by_element.png)
+
+コードはここでは省略されていますが、このアプローチについて注意すべき2つの重要な点があります。
+
+- 与えられた配列`nums`には小数が含まれていないため、等しい場合の処理は心配ありません。
+- ただし、このアプローチで小数を導入するには、`target`変数を浮動小数点型に変更する必要があります（Pythonでは変更は不要です）。

ja/docs/chapter_searching/binary_search_insertion.md

@@ -0,0 +1,91 @@
+# 二分探索による挿入
+
+二分探索は目標要素を探索するだけでなく、目標要素の挿入位置を探索するなど、多くの変種問題を解決するためにも使用されます。
+
+## 重複要素がない場合
+
+!!! question
+
+    一意の要素を持つ長さ$n$のソート済み配列`nums`と要素`target`が与えられ、ソート順を維持しながら`target`を`nums`に挿入します。`target`が配列にすでに存在する場合は、既存の要素の左側に挿入します。挿入後の配列における`target`のインデックスを返してください。下図に示す例を参照してください。
+
+![Example data for binary search insertion point](binary_search_insertion.assets/binary_search_insertion_example.png)
+
+前のセクションの二分探索コードを再利用したい場合、以下の2つの質問に答える必要があります。
+
+**質問1**：配列にすでに`target`が含まれている場合、挿入位置は既存要素のインデックスになりますか？
+
+`target`を等しい要素の左側に挿入するという要件は、新しく挿入される`target`が元の`target`の位置を置き換えることを意味します。つまり、**配列に`target`が含まれている場合、挿入位置は確かにその`target`のインデックスです**。
+
+**質問2**：配列に`target`が含まれていない場合、どのインデックスに挿入されますか？
+
+二分探索プロセスをさらに考えてみましょう：`nums[m] < target`のとき、ポインタ$i$が移動します。これは、ポインタ$i$が`target`以上の要素に近づいていることを意味します。同様に、ポインタ$j$は常に`target`以下の要素に近づいています。
+
+したがって、二分の終了時には確実に：$i$は`target`より大きい最初の要素を指し、$j$は`target`より小さい最初の要素を指します。**配列に`target`が含まれていない場合、挿入位置は$i$であることは明らかです**。コードは以下の通りです：
+
+```src
+[file]{binary_search_insertion}-[class]{}-[func]{binary_search_insertion_simple}
+```
+
+## 重複要素がある場合
+
+!!! question
+
+    前の質問に基づいて、配列に重複要素が含まれている可能性があると仮定し、他はすべて同じとします。
+
+配列に`target`の複数の出現がある場合、通常の二分探索は`target`の1つの出現のインデックスのみを返すことができ、**その位置の左右に`target`の出現がいくつあるかを特定することはできません**。
+
+問題では目標要素を最も左の位置に挿入することが要求されているため、**配列内の最も左の`target`のインデックスを見つける必要があります**。最初に下図に示すステップを通してこれを実装することを考えてみましょう。
+
+1. 二分探索を実行して`target`の任意のインデックス、例えば$k$を見つけます。
+2. インデックス$k$から開始して、最も左の`target`の出現が見つかるまで左に線形探索を行い、このインデックスを返します。
+
+![Linear search for the insertion point of duplicate elements](binary_search_insertion.assets/binary_search_insertion_naive.png)
+
+この方法は実現可能ですが、線形探索を含むため、時間計算量は$O(n)$です。この方法は、配列に多くの重複する`target`が含まれている場合に非効率です。
+
+今度は二分探索コードを拡張することを考えてみましょう。下図に示すように、全体的なプロセスは同じままです。各ラウンドで、まず中間インデックス$m$を計算し、次に`target`と`nums[m]`の値を比較して、以下のケースになります。
+
+- `nums[m] < target`または`nums[m] > target`のとき、これは`target`がまだ見つかっていないことを意味するため、通常の二分探索を使用して探索範囲を狭め、**ポインタ$i$と$j$を`target`に近づけます**。
+- `nums[m] == target`のとき、これは`target`より小さい要素が範囲$[i, m - 1]$にあることを示すため、$j = m - 1$を使用して範囲を狭め、**ポインタ$j$を`target`より小さい要素に近づけます**。
+
+ループ後、$i$は最も左の`target`を指し、$j$は`target`より小さい最初の要素を指すため、**インデックス$i$が挿入位置です**。
+
+=== "<1>"
+    ![Steps for binary search insertion point of duplicate elements](binary_search_insertion.assets/binary_search_insertion_step1.png)
+
+=== "<2>"
+    ![binary_search_insertion_step2](binary_search_insertion.assets/binary_search_insertion_step2.png)
+
+=== "<3>"
+    ![binary_search_insertion_step3](binary_search_insertion.assets/binary_search_insertion_step3.png)
+
+=== "<4>"
+    ![binary_search_insertion_step4](binary_search_insertion.assets/binary_search_insertion_step4.png)
+
+=== "<5>"
+    ![binary_search_insertion_step5](binary_search_insertion.assets/binary_search_insertion_step5.png)
+
+=== "<6>"
+    ![binary_search_insertion_step6](binary_search_insertion.assets/binary_search_insertion_step6.png)
+
+=== "<7>"
+    ![binary_search_insertion_step7](binary_search_insertion.assets/binary_search_insertion_step7.png)
+
+=== "<8>"
+    ![binary_search_insertion_step8](binary_search_insertion.assets/binary_search_insertion_step8.png)
+
+以下のコードを観察してください。分岐`nums[m] > target`と`nums[m] == target`の操作は同じであるため、これら2つの分岐をマージできます。
+
+それでも、ロジックがより明確になり、可読性が向上するため、条件を展開したままにしておくことができます。
+
+```src
+[file]{binary_search_insertion}-[class]{}-[func]{binary_search_insertion}
+```
+
+!!! tip
+
+    このセクションのコードは「閉区間」を使用しています。「左閉右開」に興味がある場合は、自分でコードを実装してみてください。
+
+要約すると、二分探索は本質的にポインタ$i$と$j$の探索目標を設定することです。これらの目標は特定の要素（`target`など）または要素の範囲（`target`より小さいものなど）である可能性があります。
+
+二分探索の連続ループにおいて、ポインタ$i$と$j$は段階的に事前定義された目標に近づきます。最終的に、それらは答えを見つけるか、境界を越えた後に停止します。

ja/docs/chapter_searching/index.md

@@ -0,0 +1,9 @@
+# 探索
+
+![Searching](../assets/covers/chapter_searching.jpg)
+
+!!! abstract
+
+    探索は未知への冒険です。神秘的な空間の隅々まで巡る必要があるかもしれませんし、あるいはすぐに目標を見つけることができるかもしれません。
+
+    この発見の旅において、それぞれの探査は予期しない答えで終わるかもしれません。

ja/docs/chapter_searching/replace_linear_by_hashing.md

@@ -0,0 +1,47 @@
+# ハッシュ最適化戦略
+
+アルゴリズム問題において、**線形探索をハッシュベースの探索に置き換えることで、アルゴリズムの時間計算量を削減することがよくあります**。アルゴリズム問題を使用して理解を深めましょう。
+
+!!! question
+
+    整数配列`nums`と目標要素`target`が与えられ、配列内で「和」が`target`に等しい2つの要素を探索し、それらの配列インデックスを返してください。任意の解が受け入れられます。
+
+## 線形探索：時間を空間と交換
+
+すべての可能な組み合わせを直接横断することを考えてみます。下図に示すように、ネストしたループを開始し、各反復で2つの整数の和が`target`に等しいかどうかを判断します。そうであれば、それらのインデックスを返します。
+
+![Linear search solution for two-sum problem](replace_linear_by_hashing.assets/two_sum_brute_force.png)
+
+コードは以下の通りです：
+
+```src
+[file]{two_sum}-[class]{}-[func]{two_sum_brute_force}
+```
+
+この方法の時間計算量は$O(n^2)$、空間計算量は$O(1)$で、大容量データでは非常に時間がかかる可能性があります。
+
+## ハッシュ探索：空間を時間と交換
+
+ハッシュテーブルの使用を考えてみましょう。キーと値のペアはそれぞれ配列要素とそのインデックスです。配列をループし、各反復中に下図に示すステップを実行します。
+
+1. 数値`target - nums[i]`がハッシュテーブルにあるかどうかを確認します。ある場合は、これら2つの要素のインデックスを直接返します。
+2. キーと値のペア`nums[i]`とインデックス`i`をハッシュテーブルに追加します。
+
+=== "<1>"
+    ![Help hash table solve two-sum](replace_linear_by_hashing.assets/two_sum_hashtable_step1.png)
+
+=== "<2>"
+    ![two_sum_hashtable_step2](replace_linear_by_hashing.assets/two_sum_hashtable_step2.png)
+
+=== "<3>"
+    ![two_sum_hashtable_step3](replace_linear_by_hashing.assets/two_sum_hashtable_step3.png)
+
+実装コードは以下に示され、単一のループのみが必要です：
+
+```src
+[file]{two_sum}-[class]{}-[func]{two_sum_hash_table}
+```
+
+この方法は、ハッシュ探索を使用することで時間計算量を$O(n^2)$から$O(n)$に削減し、実行時効率を大幅に向上させます。
+
+追加のハッシュテーブルを維持する必要があるため、空間計算量は$O(n)$です。**それにもかかわらず、この方法は全体的により均衡のとれた時空間効率を持ち、この問題の最適解となります**。

ja/docs/chapter_searching/searching_algorithm_revisited.md

@@ -0,0 +1,84 @@
+# 探索アルゴリズムの再検討
+
+<u>探索アルゴリズム（検索アルゴリズム）</u>は、配列、連結リスト、木、グラフなどのデータ構造内で特定の基準を満たす1つ以上の要素を取得するために使用されます。
+
+探索アルゴリズムは、そのアプローチに基づいて以下の2つのカテゴリに分けることができます。
+
+- **データ構造を横断することで目標要素を特定する**：配列、連結リスト、木、グラフの横断など。
+- **データの組織構造や既存のデータを使用して効率的な要素探索を実現する**：二分探索、ハッシュ探索、二分探索木探索など。
+
+これらのトピックは前の章で紹介されたため、私たちには馴染みのないものではありません。このセクションでは、より体系的な観点から探索アルゴリズムを再検討します。
+
+## 総当たり探索
+
+総当たり探索は、データ構造のすべての要素を横断することで目標要素を特定します。
+
+- 「線形探索」は配列や連結リストなどの線形データ構造に適しています。データ構造の一端から開始し、目標要素が見つかるか、目標要素を見つけることなく他端に到達するまで、各要素に一つずつアクセスします。
+- 「幅優先探索」と「深さ優先探索」は、グラフと木の2つの横断戦略です。幅優先探索は初期ノードから開始し、層ごと（左から右へ）に探索し、近くから遠くのノードにアクセスします。深さ優先探索は初期ノードから開始し、パスの終端（上から下へ）まで追跡し、その後バックトラックして他のパスを試し、データ構造全体が横断されるまで続行します。
+
+総当たり探索の利点は、その単純さと汎用性であり、**データの前処理や追加のデータ構造の助けが不要**です。
+
+ただし、**このタイプのアルゴリズムの時間計算量は$O(n)$**で、$n$は要素数であるため、大規模なデータセットでは性能が悪くなります。
+
+## 適応的探索
+
+適応的探索は、データの固有の性質（順序など）を使用して探索プロセスを最適化し、それにより目標要素をより効率的に特定します。
+
+- 「二分探索」はデータの整列性を使用して効率的な探索を実現し、配列にのみ適用可能です。
+- 「ハッシュ探索」はハッシュテーブルを使用して探索データと目標データの間にキーと値のマッピングを確立し、それによりクエリ操作を実装します。
+- 特定の木構造（二分探索木など）での「木探索」は、ノード値の比較に基づいてノードを迅速に除外し、それにより目標要素を特定します。
+
+これらのアルゴリズムの利点は高効率であり、**時間計算量が$O(\log n)$または$O(1)$にまで達します**。
+
+ただし、**これらのアルゴリズムを使用するには、多くの場合データの前処理が必要です**。例えば、二分探索では事前に配列をソートする必要があり、ハッシュ探索と木探索の両方で追加のデータ構造の助けが必要です。これらの構造を維持することも、時間と空間の面でより多くのオーバーヘッドが必要です。
+
+!!! tip
+
+    適応的探索アルゴリズムは、多くの場合探索アルゴリズムと呼ばれ、**主に特定のデータ構造内で目標要素を迅速に取得するために使用されます**。
+
+## 探索方法の選択
+
+サイズ$n$のデータセットが与えられた場合、線形探索、二分探索、木探索、ハッシュ探索、またはその他の方法を使用して目標要素を取得できます。これらの方法の動作原理を下図に示します。
+
+![Various search strategies](searching_algorithm_revisited.assets/searching_algorithms.png)
+
+前述の方法の特性と操作効率を以下の表に示します。
+
+<p align="center"> 表 <id> &nbsp; 探索アルゴリズム効率の比較 </p>
+
+|                    | 線形探索      | 二分探索              | 木探索                      | ハッシュ探索               |
+| ------------------ | ------------- | --------------------- | --------------------------- | -------------------------- |
+| 要素探索           | $O(n)$        | $O(\log n)$           | $O(\log n)$                 | $O(1)$                     |
+| 要素挿入           | $O(1)$        | $O(n)$                | $O(\log n)$                 | $O(1)$                     |
+| 要素削除           | $O(n)$        | $O(n)$                | $O(\log n)$                 | $O(1)$                     |
+| 追加空間           | $O(1)$        | $O(1)$                | $O(n)$                      | $O(n)$                     |
+| データ前処理       | /             | ソート $O(n \log n)$  | 木構築 $O(n \log n)$        | ハッシュテーブル構築 $O(n)$ |
+| データ順序性       | 無順序        | 順序                  | 順序                        | 無順序                     |
+
+探索アルゴリズムの選択は、データ量、探索性能要件、データクエリと更新の頻度などにも依存します。
+
+**線形探索**
+
+- 汎用性が良く、データ前処理操作が不要です。データを一度だけクエリする必要がある場合、他の3つの方法のデータ前処理時間は線形探索の時間よりも長くなります。
+- 小容量のデータに適しており、時間計算量が効率に与える影響は小さいです。
+- データ更新が非常に頻繁なシナリオに適しています。この方法はデータの追加メンテナンスを必要としないためです。
+
+**二分探索**
+
+- より大きなデータ量に適しており、安定した性能と最悪ケースの時間計算量$O(\log n)$を持ちます。
+- ただし、データ量が大きすぎることはできません。配列の保存には連続したメモリ空間が必要だからです。
+- 頻繁な追加と削除があるシナリオには適していません。順序付き配列の維持に多くのオーバーヘッドが発生するためです。
+
+**ハッシュ探索**
+
+- 高速クエリ性能が不可欠なシナリオに適しており、平均時間計算量は$O(1)$です。
+- 順序付きデータや範囲探索が必要なシナリオには適していません。ハッシュテーブルはデータの順序性を維持できないためです。
+- ハッシュ関数とハッシュ衝突処理戦略への依存度が高く、性能劣化のリスクが大きいです。
+- 過度に大容量のデータには適していません。ハッシュテーブルは衝突を最小化し、良好なクエリ性能を提供するために追加の空間が必要だからです。
+
+**木探索**
+
+- 大容量データに適しています。木ノードはメモリ内に分散して保存されるためです。
+- 順序付きデータの維持や範囲探索に適しています。
+- ノードの継続的な追加と削除により、二分探索木は偏る可能性があり、時間計算量が$O(n)$に劣化する可能性があります。
+- AVL木や赤黒木を使用する場合、操作は$O(\log n)$効率で安定して実行できますが、木のバランスを維持する操作により追加のオーバーヘッドが追加されます。

ja/docs/chapter_searching/summary.md

@@ -0,0 +1,8 @@
+# まとめ
+
+- 二分探索はデータの順序に依存し、探索区間を反復的に半分にすることで探索を実行します。入力データがソート済みである必要があり、配列または配列ベースのデータ構造にのみ適用可能です。
+- 無順序データセット内のエントリを見つけるには、総当たり探索が必要な場合があります。データ構造に基づいて異なる探索アルゴリズムを適用できます：線形探索は配列と連結リストに適しており、幅優先探索（BFS）と深さ優先探索（DFS）はグラフと木に適しています。これらのアルゴリズムは非常に汎用性が高く、データの前処理が不要ですが、$O(n)$という高い時間計算量を持ちます。
+- ハッシュ探索、木探索、二分探索は効率的な探索方法で、特定のデータ構造内で目標要素を迅速に特定できます。これらのアルゴリズムは非常に効率的で、時間計算量が$O(\log n)$または$O(1)$にまで達しますが、通常は追加のデータ構造を収容するために追加の空間が必要です。
+- 実際には、データ量、探索性能要件、データクエリと更新頻度などの要因を分析して、適切な探索方法を選択する必要があります。
+- 線形探索は小さなデータや頻繁に更新される（変動性の高い）データに理想的です。二分探索は大きくてソート済みのデータに適しています。ハッシュ探索は高いクエリ効率が必要で範囲クエリが不要なデータに適しています。木探索は順序を維持し、範囲クエリをサポートする必要がある大きな動的データに最も適しています。
+- 線形探索をハッシュ探索に置き換えることは、実行時性能を最適化する一般的な戦略で、時間計算量を$O(n)$から$O(1)$に削減します。