Fix multilingual content typos (#1958)

ja/docs/chapter_appendix/installation.md

@@ -20,7 +20,7 @@ VS Code には強力な拡張機能のエコシステムがあり、ほとんど
 
 ### C/C++ 環境
 
-1. Windows システムでは [MinGW](https://sourceforge.net/projects/mingw-w64/files/) をインストールする必要があります（[設定チュートリアル](https://blog.csdn.net/qq_33698226/article/details/129031241)）。MacOS には Clang が標準搭載されているため、追加インストールは不要です。
+1. Windows システムでは [MinGW](https://sourceforge.net/projects/mingw-w64/files/) をインストールする必要があります（[設定チュートリアル](https://blog.csdn.net/qq_33698226/article/details/129031241)）。macOS には Clang が標準搭載されているため、追加インストールは不要です。
 2. VS Code の拡張機能マーケットプレイスで `c++` を検索し、C/C++ Extension Pack をインストールします。
 3. （任意）Settings ページを開き、コード整形オプション `Clang_format_fallback Style` を検索して、`{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }` に設定します。
 
@@ -31,7 +31,7 @@ VS Code には強力な拡張機能のエコシステムがあり、ほとんど
 
 ### C# 環境
 
-1. [.Net 8.0](https://dotnet.microsoft.com/en-us/download) をダウンロードしてインストールします。
+1. [.NET 8.0](https://dotnet.microsoft.com/en-us/download) をダウンロードしてインストールします。
 2. VS Code の拡張機能マーケットプレイスで `C# Dev Kit` を検索し、C# Dev Kit をインストールします（[設定チュートリアル](https://code.visualstudio.com/docs/csharp/get-started)）。
 3. Visual Studio を使用することもできます（[インストール手順](https://learn.microsoft.com/zh-cn/visualstudio/install/install-visual-studio?view=vs-2022)）。
 

ja/docs/chapter_appendix/terminology.md

@@ -80,7 +80,9 @@
 | level-order traversal          | レベル順走査                   |
 | breadth-first traversal        | 幅優先走査                     |
 | depth-first traversal          | 深さ優先走査                   |
-| binary search tree             | 二分探索木                     |
+| pre-order traversal            | 前順走査                       |
+| in-order traversal             | 中順走査                       |
+| post-order traversal           | 後順走査                       |
 | balanced binary search tree    | 平衡二分探索木                 |
 | balance factor                 | 平衡係数                       |
 | heap                           | ヒープ                         |

ja/docs/chapter_array_and_linkedlist/linked_list.md

@@ -166,7 +166,7 @@
     // コンストラクタ
     class ListNode(x: Int) {
         val _val: Int = x          // ノードの値
-        val next: ListNode? = null // 次のノードへの参照
+        var next: ListNode? = null // 次のノードへの参照
     }
     ```
 
@@ -658,8 +658,8 @@
     // コンストラクタ
     class ListNode(x: Int) {
         val _val: Int = x           // ノードの値
-        val next: ListNode? = null  // 後続ノードへの参照
-        val prev: ListNode? = null  // 前駆ノードへの参照
+        var next: ListNode? = null  // 後続ノードへの参照
+        var prev: ListNode? = null  // 前駆ノードへの参照
     }
     ```
 

ja/docs/chapter_backtracking/permutations_problem.md

@@ -30,7 +30,7 @@
 
 各要素が 1 回しか選ばれないようにするため、ブール配列 `selected` の導入を考えます。ここで `selected[i]` は `choices[i]` がすでに選ばれているかどうかを表し、これに基づいて次の枝刈りを行います。
 
-- 選択 `choice[i]` を行った後、`selected[i]` を $\text{True}$ に設定し、その要素が選択済みであることを表します。
+- 選択 `choices[i]` を行った後、`selected[i]` を $\text{True}$ に設定し、その要素が選択済みであることを表します。
 - 選択肢リスト `choices` を走査するとき、すでに選ばれたノードはすべてスキップします。これが枝刈りです。
 
 下図のように、1 回目に 1、2 回目に 3、3 回目に 2 を選ぶとします。このとき 2 回目では要素 1 の分岐を、3 回目では要素 1 と要素 3 の分岐を刈り取る必要があります。

ja/docs/chapter_data_structure/summary.md

@@ -10,7 +10,7 @@
 - 符号付き絶対値表現、1 の補数、2 の補数は、コンピュータで数値を符号化する 3 つの方法であり、相互に変換できます。整数の符号付き絶対値表現では最上位ビットが符号ビットで、残りのビットが数値の値です。
 - 整数はコンピュータ内では 2 の補数の形式で格納されます。2 の補数表現では、コンピュータは正数と負数の加算を同じように扱うことができ、減算のために特別なハードウェア回路を別途設計する必要がなく、さらに正負のゼロが重複する問題もありません。
 - 浮動小数点数の符号化は、1 ビットの符号部、8 ビットの指数部、23 ビットの仮数部で構成されます。指数部があるため、浮動小数点数の値域は整数よりはるかに広くなりますが、その代償として精度が犠牲になります。
-- ASCII コードは最も早く登場した英字文字集合で、長さは 1 バイト、収録文字数は 127 です。GBK 文字集合はよく使われる中国語文字集合で、2 万字以上の漢字を収録しています。Unicode は完全な文字集合標準を提供することを目指しており、世界中のさまざまな言語の文字を収録することで、文字コード方式の不一致によって生じる文字化けの問題を解決します。
+- ASCII コードは最も早く登場した英字文字集合で、長さは 1 バイト、収録文字数は 128 です。GBK 文字集合はよく使われる中国語文字集合で、2 万字以上の漢字を収録しています。Unicode は完全な文字集合標準を提供することを目指しており、世界中のさまざまな言語の文字を収録することで、文字コード方式の不一致によって生じる文字化けの問題を解決します。
 - UTF-8 は最も広く使われている Unicode の符号化方式で、汎用性が非常に高いです。可変長の符号化方式であり、拡張性に優れ、記憶領域の利用効率を効果的に高めます。UTF-16 と UTF-32 は固定長の符号化方式です。中国語を符号化する場合、UTF-16 は UTF-8 よりも使用領域が小さくなります。Java や C# などのプログラミング言語は、デフォルトで UTF-16 を使用します。
 
 ### Q & A

ja/docs/chapter_divide_and_conquer/build_binary_tree_problem.md

@@ -21,12 +21,12 @@
 定義に従うと、`preorder` と `inorder` はいずれも 3 つの部分に分けられます。
 
 - 前順走査：`[ 根ノード | 左部分木 | 右部分木 ]` ，例えば上図の木は `[ 3 | 9 | 2 1 7 ]` に対応します。
-- 中順走査：`[ 左部分木 | 根ノード ｜ 右部分木 ]` ，例えば上図の木は `[ 9 | 3 | 1 2 7 ]` に対応します。
+- 中順走査：`[ 左部分木 | 根ノード | 右部分木 ]` ，例えば上図の木は `[ 9 | 3 | 1 2 7 ]` に対応します。
 
 上図のデータを例にすると、下図の手順によって分割結果を得られます。
 
 1. 前順走査の先頭要素 3 が根ノードの値です。
-2. 根ノード 3 の `inorder` におけるインデックスを探すと、そのインデックスを用いて `inorder` を `[ 9 | 3 ｜ 1 2 7 ]` に分割できます。
+2. 根ノード 3 の `inorder` におけるインデックスを探すと、そのインデックスを用いて `inorder` を `[ 9 | 3 | 1 2 7 ]` に分割できます。
 3. `inorder` の分割結果から、左部分木と右部分木のノード数はそれぞれ 1 と 3 であることがわかり、したがって `preorder` を `[ 3 | 9 | 2 1 7 ]` に分割できます。
 
 ![前順走査と中順走査で部分木を分割する](build_binary_tree_problem.assets/build_tree_preorder_inorder_division.png)

ja/docs/chapter_dynamic_programming/edit_distance_problem.md

@@ -35,7 +35,7 @@
 
 状態 $[i, j]$ に対応する部分問題は、**$s$ の先頭 $i$ 文字を $t$ の先頭 $j$ 文字に変換するのに必要な最小編集回数**です。
 
-これにより、サイズが $(i+1) \times (j+1)$ の2次元 $dp$ テーブルが得られます。
+これにより、サイズが $(n+1) \times (m+1)$ の2次元 $dp$ テーブルが得られます。
 
 **第2ステップ：最適部分構造を見つけ、状態遷移方程式を導く**
 

ja/docs/chapter_dynamic_programming/knapsack_problem.md

@@ -134,7 +134,7 @@ $$
 
 ### 空間最適化
 
-各状態は直前の行の状態にしか依存しないため、2つの配列をローテーションして用いることで、空間計算量を $O(n^2)$ から $O(n)$ に削減できます。
+各状態は直前の行の状態にしか依存しないため、2つの配列をローテーションして用いることで、空間計算量を $O(n \times cap)$ から $O(cap)$ に削減できます。
 
 さらに考えると、1つの配列だけで空間最適化を実現できるでしょうか。観察すると、各状態は真上または左上のマスから遷移してきます。配列が1つしかないと仮定すると、$i$ 行目の走査を開始した時点では、その配列にはまだ $i-1$ 行目の状態が格納されています。
 

ja/docs/chapter_dynamic_programming/summary.md

@@ -21,5 +21,5 @@
 **編集距離問題**
 
 - 編集距離（Levenshtein 距離）は 2 つの文字列間の類似度を測るために用いられ、ある文字列を別の文字列へ変換するための最小編集回数として定義されます。編集操作には追加、削除、置換が含まれます。
-- 編集距離問題の状態は、$s$ の前 $i$ 文字を $t$ の前 $j$ 文字へ変更するのに必要な最小編集回数として定義されます。$s[i] \ne t[j]$ のときは、追加、削除、置換の 3 つの判断があり、それぞれに対応する残りの部分問題があります。これにより最適部分構造を見いだし、状態遷移方程式を構築できます。一方、$s[i] = t[j]$ のときは現在の文字を編集する必要はありません。
+- 編集距離問題の状態は、$s$ の前 $i$ 文字を $t$ の前 $j$ 文字へ変更するのに必要な最小編集回数として定義されます。$s[i-1] \ne t[j-1]$ のときは、追加、削除、置換の 3 つの判断があり、それぞれに対応する残りの部分問題があります。これにより最適部分構造を見いだし、状態遷移方程式を構築できます。一方、$s[i-1] = t[j-1]$ のときは現在の文字を編集する必要はありません。
 - 編集距離では、状態は真上、真左、左上の状態に依存します。そのため、空間最適化後は順方向でも逆方向でも正しく状態遷移できません。そこで、変数を 1 つ用いて左上の状態を一時保存し、完全ナップサック問題と等価な形へ変換することで、空間最適化後に順方向走査を行えるようにします。

ja/docs/chapter_greedy/fractional_knapsack_problem.md

@@ -33,7 +33,7 @@
 [file]{fractional_knapsack}-[class]{}-[func]{fractional_knapsack}
 ```
 
-組み込みのソートアルゴリズムの時間計算量は通常 $O(\log n)$、空間計算量は通常 $O(\log n)$ または $O(n)$ であり、具体的な値はプログラミング言語の実装に依存する。
+組み込みのソートアルゴリズムの時間計算量は通常 $O(n \log n)$、空間計算量は通常 $O(\log n)$ または $O(n)$ であり、具体的な値はプログラミング言語の実装に依存する。
 
 ソートを除けば、最悪の場合は品物リスト全体を走査する必要があるため、**時間計算量は $O(n)$** であり、ここで $n$ は品物数である。
 

ja/docs/chapter_greedy/greedy_algorithm.md

@@ -91,4 +91,4 @@
 - **分数ナップサック問題**：一群の品物と積載容量が与えられたとき、総重量が容量を超えず、かつ総価値が最大になるように品物を選ぶ問題です。毎回、価値対重量比（価値 / 重量）が最も高い品物を選ぶなら、ある条件下で貪欲法は最適解を得られます。
 - **株式売買問題**：株価の履歴が与えられ、複数回の売買が可能ですが、すでに株を保有している場合は売却前に再度購入することはできません。目標は最大利益を得ることです。
 - **ハフマン符号化**：ハフマン符号化は、可逆データ圧縮に用いられる貪欲法です。ハフマン木を構築する際、毎回出現頻度が最も低い 2 つのノードを選んで併合すると、最終的に得られるハフマン木の重み付きパス長（符号長）は最小になります。
-- **Dijkstra アルゴリズム**：与えられた始点から他の各頂点への最短経路問題を解く貪欲法です。
+- **Dijkstra アルゴリズム**：すべての辺の重みが非負であるグラフにおいて、与えられた始点から他の各頂点への最短経路問題を解く貪欲法です。

ja/docs/chapter_greedy/max_product_cutting_problem.md

@@ -51,7 +51,7 @@ $$
 1. 整数 $n$ を入力し、余りが $0$、$1$、$2$ になるまで、そこから因子 $3$ を繰り返し切り出す。
 2. 余りが $0$ のとき、$n$ は $3$ の倍数であることを表すため、何も処理しない。
 3. 余りが $2$ のときは、それ以上分割せず、そのまま残す。
-4. 余りが $1$ のとき、$2 \times 2 > 1 \times 3$ であるため、最後の $3$ を $2$ に置き換えるべきである。
+4. 余りが $1$ のとき、$2 \times 2 > 1 \times 3$ であるため、最後の $3$ と余りの $1$ を 2 つの $2$ に置き換えるべきである。
 
 ### コード実装
 

ja/docs/chapter_hashing/hash_algorithm.md

@@ -160,7 +160,7 @@ $$
     size_t hashStr = hash<string>()(str);
     // 文字列「Hello アルゴリズム」のハッシュ値は 15466937326284535026
 
-    // C++ では、組み込みの std:hash() は基本データ型のハッシュ値計算のみを提供する
+    // C++ では、組み込みの std::hash() は基本データ型のハッシュ値計算のみを提供する
     // 配列やオブジェクトのハッシュ値計算は自分で実装する必要がある
     ```
 

ja/docs/chapter_hashing/summary.md

@@ -10,7 +10,7 @@
 - 負荷率は、ハッシュテーブル内の要素数をバケット数で割ったものと定義され、ハッシュ衝突の深刻さを反映する。ハッシュテーブル拡張を発動する条件としてよく用いられる。
 - 連鎖方式では、単一要素を連結リストに変換し、衝突したすべての要素を同じ連結リストに格納する。しかし、連結リストが長すぎると検索効率が低下するため、さらに連結リストを赤黒木に変換して効率を高めることができる。
 - オープンアドレス法は複数回の探索によってハッシュ衝突を処理する。線形探索は固定のステップ幅を用いるが、要素を削除できず、クラスタリングが発生しやすいという欠点がある。二重ハッシュは複数のハッシュ関数を用いて探索するため、線形探索に比べてクラスタリングが起きにくいが、複数のハッシュ関数によって計算量が増える。
-- プログラミング言語ごとに、異なるハッシュテーブル実装が採用されている。たとえば、Java の `HashMap` は連鎖方式を使用し、Python の `Dict` はオープンアドレス法を採用している。
+- プログラミング言語ごとに、異なるハッシュテーブル実装が採用されている。たとえば、Java の `HashMap` は連鎖方式を使用し、Python の `dict` はオープンアドレス法を採用している。
 - ハッシュテーブルでは、ハッシュアルゴリズムに決定性、高効率、均一分布という特徴が求められる。暗号学では、ハッシュアルゴリズムはさらに耐衝突性とアバランシェ効果も備えるべきである。
 - ハッシュアルゴリズムは通常、大きな素数を法として用い、ハッシュ値の均一分布を最大限に保証してハッシュ衝突を減らす。
 - 一般的なハッシュアルゴリズムには MD5、SHA-1、SHA-2、SHA-3 などがある。MD5 はファイル完全性の検証によく用いられ、SHA-2 はセキュリティ用途やプロトコルでよく用いられる。

ja/docs/chapter_heap/build_heap.md

@@ -31,7 +31,7 @@
 
 以下では、2つ目のヒープ構築法の時間計算量を求めてみましょう。
 
-- 完全二分木のノード数を $n$ とすると、葉ノード数は $(n + 1) / 2$ です。ここで $/$ は切り捨て除算を表します。したがって、ヒープ化が必要なノード数は $(n - 1) / 2$ です。
+- 完全二分木のノード数を $n$ とすると、葉ノード数は $(n + 1) / 2$ です。ここで $/$ は切り捨て除算を表します。したがって、ヒープ化が必要なノード数は $n / 2$ です。
 - 上から下へのヒープ化の過程では、各ノードは最大で葉ノードまでヒープ化されるため、最大反復回数は二分木の高さ $\log n$ です。
 
 上の2つを掛け合わせると、ヒープ構築過程の時間計算量は $O(n \log n)$ となります。**しかし、この見積もりは正確ではありません。二分木では下層のノード数が上層よりはるかに多いという性質を考慮していないためです**。

ja/docs/chapter_searching/binary_search_edge.md

@@ -41,7 +41,7 @@
 
 ### 要素探索に変換する
 
-配列に `target` が含まれない場合、最終的に $i$ と $j$ はそれぞれ `target` より大きい最初の要素と、`target` より小さい最初の要素を指すことになります。
+配列に `target` が含まれない場合、最終的に $i$ と $j$ はそれぞれ `target` より大きい最初の要素と、`target` より小さい最も右の要素を指すことになります。
 
 したがって、下図のように、配列中に存在しない要素を構成して、それを使って左右の境界を探せます。
 

ja/docs/chapter_searching/binary_search_insertion.md

@@ -20,7 +20,7 @@
 
 二分探索の過程をさらに考えると、`nums[m] < target` のときは $i$ が移動します。これは、ポインタ $i$ が `target` 以上の要素へ近づいていることを意味します。同様に、ポインタ $j$ は常に `target` 以下の要素へ近づいています。
 
-したがって二分探索の終了時には、$i$ は最初の `target` より大きい要素を指し、$j$ は最初の `target` より小さい要素を指します。**よって、配列に `target` が含まれない場合、挿入インデックスは $i$ です**。コードは次のとおりです：
+したがって二分探索の終了時には、$i$ は `target` より大きい最初の要素を指し、$j$ は `target` より小さい最も右の要素を指します。**よって、配列に `target` が含まれない場合、挿入インデックスは $i$ です**。コードは次のとおりです：
 
 ```src
 [file]{binary_search_insertion}-[class]{}-[func]{binary_search_insertion_simple}
@@ -48,7 +48,7 @@
 - `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$ が挿入位置です**。
+ループ終了後、$i$ は最も左の `target` を指し、$j$ は `target` より小さい最も右の要素を指すため、**インデックス $i$ が挿入位置です**。
 
 === "<1>"
     ![重複要素に対する二分探索の挿入位置の手順](binary_search_insertion.assets/binary_search_insertion_step1.png)

ja/docs/chapter_sorting/bucket_sort.md

@@ -1,6 +1,6 @@
 # バケットソート
 
-前述のいくつかのソートアルゴリズムは、いずれも「比較ベースのソートアルゴリズム」に属し、要素間の大小を比較することで整列を実現します。この種のソートアルゴリズムの時間計算量は $O(n \log n)$ を超えられません。続いて、時間計算量が線形オーダーに達しうる「非比較ソートアルゴリズム」をいくつか見ていきます。
+前述のいくつかのソートアルゴリズムは、いずれも「比較ベースのソートアルゴリズム」に属し、要素間の大小を比較することで整列を実現します。この種のソートアルゴリズムの最悪時間計算量の下界は $\Omega(n \log n)$ です。続いて、時間計算量が線形オーダーに達しうる「非比較ソートアルゴリズム」をいくつか見ていきます。
 
 <u>バケットソート（bucket sort）</u>は分割統治戦略の典型的な応用です。大小関係をもつ複数のバケットを用意し、各バケットがあるデータ範囲に対応するようにして、データを各バケットへ均等に分配します。その後、各バケット内でそれぞれソートを行い、最後にバケットの順序に従ってすべてのデータを結合します。
 

ja/docs/chapter_sorting/selection_sort.md

@@ -51,7 +51,7 @@
 
 ## アルゴリズムの特徴
 
-- **時間計算量は $O(n^2)$、非適応ソート**：外側のループは合計 $n - 1$ 回です。最初のラウンドの未ソート区間の長さは $n$、最後のラウンドでは $2$ であり、各ラウンドの内側のループ回数はそれぞれ $n$、$n - 1$、$\dots$、$3$、$2$ となります。総和は $\frac{(n - 1)(n + 2)}{2}$ です。
+- **時間計算量は $O(n^2)$、非適応ソート**：外側のループは合計 $n - 1$ 回です。内側のループは最初のラウンドで $n - 1$ 回、最後のラウンドで $1$ 回実行されます。各ラウンドの実行回数はそれぞれ $n - 1$、$n - 2$、$\dots$、$2$、$1$ であり、総和は $\frac{n(n - 1)}{2}$ です。
 - **空間計算量は $O(1)$、インプレースソート**：ポインタ $i$ と $j$ は定数サイズの追加領域しか使用しません。
 - **不安定ソート**：次の図のように、要素 `nums[i]` がそれと等しい要素の右側へ交換され、両者の相対的な順序が変わる可能性があります。
 

ja/docs/chapter_sorting/sorting_algorithm.md

@@ -37,7 +37,7 @@
 
 **適応性**：<u>適応的ソート</u>は、入力データに既に存在する順序情報を利用して計算量を減らし、より優れた時間効率を実現できます。適応的ソートアルゴリズムの最良時間計算量は、通常、平均時間計算量より優れています。
 
-**比較ベースかどうか**：<u>比較ベースのソート</u>は、比較演算子（$<$、$=$、$>$）に依存して要素の相対順序を判定し、それによって配列全体をソートします。理論上の最良時間計算量は $O(n \log n)$ です。一方、<u>非比較ソート</u>は比較演算子を使用せず、時間計算量は $O(n)$ に達しますが、汎用性は相対的に低くなります。
+**比較ベースかどうか**：<u>比較ベースのソート</u>は、比較演算子（$<$、$=$、$>$）に依存して要素の相対順序を判定し、それによって配列全体をソートします。その最悪時間計算量の下界は $\Omega(n \log n)$ です。一方、<u>非比較ソート</u>は比較演算子を使用せず、時間計算量は $O(n)$ に達しますが、汎用性は相対的に低くなります。
 
 ## 理想的なソートアルゴリズム
 

ja/docs/chapter_stack_and_queue/queue.md

@@ -175,7 +175,7 @@
 
     /* 要素をデキュー */
     // 配列であるため、removeFirst の計算量は O(n)
-    let pool = queue.removeFirst()
+    let pop = queue.removeFirst()
 
     /* キューの長さを取得 */
     let size = queue.count
@@ -244,7 +244,7 @@
 
     ```dart title="queue.dart"
     /* キューを初期化 */
-    // Dart では、キュークラス Qeque は双方向キューであり、キューとしても使用できる
+    // Dart では、キュークラス Queue は双方向キューであり、キューとしても使用できる
     Queue<int> queue = Queue();
 
     /* 要素をエンキュー */

ja/docs/chapter_tree/avl_tree.md

@@ -205,9 +205,9 @@ AVL 木の操作ではノードの高さを取得する必要があるため、
     ```kotlin title=""
     /* AVL 木ノードクラス */
     class TreeNode(val _val: Int) {  // ノード値
-        val height: Int = 0          // ノードの高さ
-        val left: TreeNode? = null   // 左の子ノード
-        val right: TreeNode? = null  // 右の子ノード
+        var height: Int = 0          // ノードの高さ
+        var left: TreeNode? = null   // 左の子ノード
+        var right: TreeNode? = null  // 右の子ノード
     }
     ```
 

ja/docs/chapter_tree/binary_tree.md

@@ -181,8 +181,8 @@
     ```kotlin title=""
     /* 二分木ノードクラス */
     class TreeNode(val _val: Int) {  // ノード値
-        val left: TreeNode? = null   // 左子ノード参照
-        val right: TreeNode? = null  // 右子ノード参照
+        var left: TreeNode? = null   // 左子ノード参照
+        var right: TreeNode? = null  // 右子ノード参照
     }
     ```