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/python/chapter_tree/array_binary_tree.py

@@ -12,108 +12,108 @@ from modules import TreeNode, list_to_tree, print_tree
 
 
 class ArrayBinaryTree:
-    """配列表現による二分木クラス"""
+    """配列で表した二分木クラス"""
 
     def __init__(self, arr: list[int | None]):
         """コンストラクタ"""
         self._tree = list(arr)
 
     def size(self):
-        """リスト容量"""
+        """リストの容量"""
         return len(self._tree)
 
     def val(self, i: int) -> int | None:
-        """インデックス i のノードの値を取得"""
-        # インデックスが範囲外なら、空きを表す None を返す
+        """インデックス i のノードの値を取得する"""
+        # インデックスが範囲外の場合、空きを表す None を返す
         if i < 0 or i >= self.size():
             return None
         return self._tree[i]
 
     def left(self, i: int) -> int | None:
-        """インデックス i のノードの左子ノードのインデックスを取得"""
+        """インデックス i のノードの左の子ノードのインデックスを取得する"""
         return 2 * i + 1
 
     def right(self, i: int) -> int | None:
-        """インデックス i のノードの右子ノードのインデックスを取得"""
+        """インデックス i のノードの右の子ノードのインデックスを取得する"""
         return 2 * i + 2
 
     def parent(self, i: int) -> int | None:
-        """インデックス i のノードの親ノードのインデックスを取得"""
+        """インデックス i のノードの親ノードのインデックスを取得する"""
         return (i - 1) // 2
 
     def level_order(self) -> list[int]:
         """レベル順走査"""
         self.res = []
-        # 配列を直接走査する
+        # 配列をそのまま走査する
         for i in range(self.size()):
             if self.val(i) is not None:
                 self.res.append(self.val(i))
         return self.res
 
     def dfs(self, i: int, order: str):
-        """深さ優先探索"""
+        """深さ優先走査"""
         if self.val(i) is None:
             return
-        # 先行順走査
+        # 行きがけ順走査
         if order == "pre":
             self.res.append(self.val(i))
         self.dfs(self.left(i), order)
-        # 中順走査
+        # 通りがけ順走査
         if order == "in":
             self.res.append(self.val(i))
         self.dfs(self.right(i), order)
-        # 後順走査
+        # 帰りがけ順走査
         if order == "post":
             self.res.append(self.val(i))
 
     def pre_order(self) -> list[int]:
-        """先行順走査"""
+        """行きがけ順走査"""
         self.res = []
         self.dfs(0, order="pre")
         return self.res
 
     def in_order(self) -> list[int]:
-        """中順走査"""
+        """通りがけ順走査"""
         self.res = []
         self.dfs(0, order="in")
         return self.res
 
     def post_order(self) -> list[int]:
-        """後順走査"""
+        """帰りがけ順走査"""
         self.res = []
         self.dfs(0, order="post")
         return self.res
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
-    # 二分木を初期化
-    # ここでは、配列から直接二分木を生成する関数を利用する
+    # 二分木を初期化する
+    # ここでは配列から二分木を直接生成する関数を使う
     arr = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
     root = list_to_tree(arr)
-    print("\n二分木を初期化\n")
+    print("\n二分木を初期化する\n")
     print("二分木の配列表現：")
     print(arr)
     print("二分木の連結リスト表現：")
     print_tree(root)
 
-    # 配列表現による二分木クラス
+    # 配列で表した二分木クラス
     abt = ArrayBinaryTree(arr)
 
-    # ノードにアクセス
+    # ノードにアクセスする
     i = 1
     l, r, p = abt.left(i), abt.right(i), abt.parent(i)
-    print(f"\n現在のノードのインデックスは {i}、値は {abt.val(i)}")
-    print(f"その左子ノードのインデックスは {l}、値は {abt.val(l)}")
-    print(f"その右子ノードのインデックスは {r}、値は {abt.val(r)}")
-    print(f"その親ノードのインデックスは {p}、値は {abt.val(p)}")
+    print(f"\n現在のノードのインデックスは {i} 、値は {abt.val(i)}")
+    print(f"左の子ノードのインデックスは {l} 、値は {abt.val(l)}")
+    print(f"右の子ノードのインデックスは {r} 、値は {abt.val(r)}")
+    print(f"親ノードのインデックスは {p} 、値は {abt.val(p)}")
 
-    # 木を走査
+    # 木を走査する
     res = abt.level_order()
     print("\nレベル順走査：", res)
     res = abt.pre_order()
-    print("先行順走査：", res)
+    print("行きがけ順走査：", res)
     res = abt.in_order()
-    print("中間順走査：", res)
+    print("通りがけ順走査：", res)
     res = abt.post_order()
-    print("後行順走査：", res)
+    print("帰りがけ順走査：", res)

ja/codes/python/chapter_tree/avl_tree.py

@@ -19,23 +19,23 @@ class AVLTree:
         self._root = None
 
     def get_root(self) -> TreeNode | None:
-        """二分木の根ノードを取得"""
+        """二分木の根ノードを取得する"""
         return self._root
 
     def height(self, node: TreeNode | None) -> int:
-        """ノードの高さを取得"""
-        # 空ノードの高さは -1、葉ノードの高さは 0
+        """ノードの高さを取得する"""
+        # 空ノードの高さは -1 、葉ノードの高さは 0
         if node is not None:
             return node.height
         return -1
 
     def update_height(self, node: TreeNode | None):
         """ノードの高さを更新する"""
-        # ノードの高さは最も高い部分木の高さ + 1 に等しい
+        # ノードの高さは、最も高い部分木の高さ + 1
         node.height = max([self.height(node.left), self.height(node.right)]) + 1
 
     def balance_factor(self, node: TreeNode | None) -> int:
-        """平衡係数を取得"""
+        """平衡係数を取得する"""
         # 空ノードの平衡係数は 0
         if node is None:
             return 0
@@ -43,10 +43,10 @@ class AVLTree:
         return self.height(node.left) - self.height(node.right)
 
     def right_rotate(self, node: TreeNode | None) -> TreeNode | None:
-        """右回転"""
+        """右回転操作"""
         child = node.left
         grand_child = child.right
-        # child を支点として node を右回転させる
+        # child を中心に node を右回転する
         child.right = node
         node.left = grand_child
         # ノードの高さを更新する
@@ -56,10 +56,10 @@ class AVLTree:
         return child
 
     def left_rotate(self, node: TreeNode | None) -> TreeNode | None:
-        """左回転"""
+        """左回転操作"""
         child = node.right
         grand_child = child.left
-        # child を支点として node を左回転させる
+        # child を中心に node を左回転する
         child.left = node
         node.right = grand_child
         # ノードの高さを更新する
@@ -69,8 +69,8 @@ class AVLTree:
         return child
 
     def rotate(self, node: TreeNode | None) -> TreeNode | None:
-        """回転操作を行い、この部分木の平衡を回復する"""
-        # ノード node の平衡係数を取得
+        """回転操作によって、この部分木の平衡を回復する"""
+        # ノード node の平衡係数を取得する
         balance_factor = self.balance_factor(node)
         # 左に偏った木
         if balance_factor > 1:
@@ -78,7 +78,7 @@ class AVLTree:
                 # 右回転
                 return self.right_rotate(node)
             else:
-                # 左回転してから右回転
+                # 左回転してから右回転する
                 node.left = self.left_rotate(node.left)
                 return self.right_rotate(node)
         # 右に偏った木
@@ -87,42 +87,42 @@ class AVLTree:
                 # 左回転
                 return self.left_rotate(node)
             else:
-                # 右回転してから左回転
+                # 右回転してから左回転する
                 node.right = self.right_rotate(node.right)
                 return self.left_rotate(node)
-        # 平衡木なので回転不要、そのまま返す
+        # 平衡な木なので、回転せずにそのまま返す
         return node
 
     def insert(self, val):
-        """ノードを挿入"""
+        """ノードを挿入する"""
         self._root = self.insert_helper(self._root, val)
 
     def insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:
         """ノードを再帰的に挿入する（補助メソッド）"""
         if node is None:
             return TreeNode(val)
-        # 1. 挿入位置を探索してノードを挿入
+        # 1. 挿入位置を探してノードを挿入する
         if val < node.val:
             node.left = self.insert_helper(node.left, val)
         elif val > node.val:
             node.right = self.insert_helper(node.right, val)
         else:
-            # 重複ノードは挿入せず、そのまま返す
+            # 重複したノードは挿入せず、そのまま戻る
             return node
         # ノードの高さを更新する
         self.update_height(node)
-        # 2. 回転操作を行い、部分木の平衡を回復する
+        # 2. 回転操作によって、この部分木の平衡を回復する
         return self.rotate(node)
 
     def remove(self, val: int):
-        """ノードを削除"""
+        """ノードを削除する"""
         self._root = self.remove_helper(self._root, val)
 
     def remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
         """ノードを再帰的に削除する（補助メソッド）"""
         if node is None:
             return None
-        # 1. ノードを探索して削除
+        # 1. ノードを探して削除する
         if val < node.val:
             node.left = self.remove_helper(node.left, val)
         elif val > node.val:
@@ -130,14 +130,14 @@ class AVLTree:
         else:
             if node.left is None or node.right is None:
                 child = node.left or node.right
-                # 子ノード数 = 0 の場合、node をそのまま削除して返す
+                # 子ノード数 = 0 の場合、node を削除して戻る
                 if child is None:
                     return None
-                # 子ノード数 = 1 の場合、node をそのまま削除する
+                # 子ノード数 = 1 の場合、node を削除する
                 else:
                     node = child
             else:
-                # 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える
+                # 子ノード数 = 2 の場合、通りがけ順で次のノードを削除し、そのノードで現在のノードを置き換える
                 temp = node.right
                 while temp.left is not None:
                     temp = temp.left
@@ -145,53 +145,53 @@ class AVLTree:
                 node.val = temp.val
         # ノードの高さを更新する
         self.update_height(node)
-        # 2. 回転操作を行い、部分木の平衡を回復する
+        # 2. 回転操作によって、この部分木の平衡を回復する
         return self.rotate(node)
 
     def search(self, val: int) -> TreeNode | None:
-        """ノードを探索"""
+        """ノードを探索する"""
         cur = self._root
-        # ループで探索し、葉ノードを越えたら抜ける
+        # 繰り返し探索し、葉ノードを越えたら終了する
         while cur is not None:
-            # 目標ノードは cur の右部分木にある
+            # 目的のノードは cur の右部分木にある
             if cur.val < val:
                 cur = cur.right
-            # 目標ノードは cur の左部分木にある
+            # 目的のノードは cur の左部分木にある
             elif cur.val > val:
                 cur = cur.left
-            # 目標ノードが見つかったらループを抜ける
+            # 目的のノードが見つかったので、ループを終了する
             else:
                 break
-        # 目標ノードを返す
+        # 目的のノードを返す
         return cur
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
 
     def test_insert(tree: AVLTree, val: int):
         tree.insert(val)
-        print("\nノード {} を挿入した後、AVL 木は".format(val))
+        print("\nノード {} を挿入した後の AVL 木".format(val))
         print_tree(tree.get_root())
 
     def test_remove(tree: AVLTree, val: int):
         tree.remove(val)
-        print("\nノード {} を削除した後、AVL 木は".format(val))
+        print("\nノード {} を削除した後の AVL 木".format(val))
         print_tree(tree.get_root())
 
     # 空の AVL 木を初期化する
     avl_tree = AVLTree()
 
     # ノードを挿入する
-    # ノード挿入後に AVL 木がどのように平衡を保つかに注目
+    # ノード挿入後、AVL 木がどのように平衡を保つかに注目する
     for val in [1, 2, 3, 4, 5, 8, 7, 9, 10, 6]:
         test_insert(avl_tree, val)
 
-    # 重複ノードを挿入する
+    # 重複したノードを挿入する
     test_insert(avl_tree, 7)
 
     # ノードを削除する
-    # ノード削除後に AVL 木がどのように平衡を保つかに注目
+    # ノード削除後、AVL 木がどのように平衡を保つかに注目する
     test_remove(avl_tree, 8)  # 次数 0 のノードを削除する
     test_remove(avl_tree, 5)  # 次数 1 のノードを削除する
     test_remove(avl_tree, 4)  # 次数 2 のノードを削除する

ja/codes/python/chapter_tree/binary_search_tree.py

@@ -20,35 +20,35 @@ class BinarySearchTree:
         self._root = None
 
     def get_root(self) -> TreeNode | None:
-        """二分木の根ノードを取得"""
+        """二分木の根ノードを取得する"""
         return self._root
 
     def search(self, num: int) -> TreeNode | None:
-        """ノードを探索"""
+        """ノードを探索する"""
         cur = self._root
-        # ループで探索し、葉ノードを越えたら抜ける
+        # 繰り返し探索し、葉ノードを越えたら終了する
         while cur is not None:
-            # 目標ノードは cur の右部分木にある
+            # 目的のノードは cur の右部分木にある
             if cur.val < num:
                 cur = cur.right
-            # 目標ノードは cur の左部分木にある
+            # 目的のノードは cur の左部分木にある
             elif cur.val > num:
                 cur = cur.left
-            # 目標ノードが見つかったらループを抜ける
+            # 目的のノードが見つかったので、ループを終了する
             else:
                 break
         return cur
 
     def insert(self, num: int):
-        """ノードを挿入"""
-        # 木が空なら、根ノードを初期化する
+        """ノードを挿入する"""
+        # 木が空の場合、根ノードを初期化する
         if self._root is None:
             self._root = TreeNode(num)
             return
-        # ループで探索し、葉ノードを越えたら抜ける
+        # 繰り返し探索し、葉ノードを越えたら終了する
         cur, pre = self._root, None
         while cur is not None:
-            # 重複ノードが見つかったら、直ちに返す
+            # 重複したノードが見つかったので、そのまま戻る
             if cur.val == num:
                 return
             pre = cur
@@ -58,7 +58,7 @@ class BinarySearchTree:
             # 挿入位置は cur の左部分木にある
             else:
                 cur = cur.left
-        # ノードを挿入
+        # ノードを挿入する
         node = TreeNode(num)
         if pre.val < num:
             pre.right = node
@@ -66,30 +66,30 @@ class BinarySearchTree:
             pre.left = node
 
     def remove(self, num: int):
-        """ノードを削除"""
-        # 木が空なら、そのまま早期リターンする
+        """ノードを削除する"""
+        # 木が空の場合、そのまま早期リターンする
         if self._root is None:
             return
-        # ループで探索し、葉ノードを越えたら抜ける
+        # 繰り返し探索し、葉ノードを越えたら終了する
         cur, pre = self._root, None
         while cur is not None:
-            # 削除対象のノードが見つかったら、ループを抜ける
+            # 削除対象のノードが見つかったので、ループを終了する
             if cur.val == num:
                 break
             pre = cur
-            # 削除対象ノードは cur の右部分木にある
+            # 削除対象のノードは cur の右部分木にある
             if cur.val < num:
                 cur = cur.right
-            # 削除対象ノードは cur の左部分木にある
+            # 削除対象のノードは cur の左部分木にある
             else:
                 cur = cur.left
-        # 削除対象ノードがなければそのまま返す
+        # 削除対象のノードが存在しない場合、そのまま戻る
         if cur is None:
             return
 
-        # 子ノード数 = 0 or 1
+        # 子ノード数 = 0 または 1
         if cur.left is None or cur.right is None:
-            # 子ノード数が 0 / 1 のとき、child = null / その子ノード
+            # 子ノード数 = 0 / 1 の場合、child = null / その子ノード
             child = cur.left or cur.right
             # ノード cur を削除する
             if cur != self._root:
@@ -98,49 +98,49 @@ class BinarySearchTree:
                 else:
                     pre.right = child
             else:
-                # 削除ノードが根ノードなら、根ノードを再設定
+                # 削除するノードが根ノードの場合、根ノードを指定し直す
                 self._root = child
         # 子ノード数 = 2
         else:
-            # 中順走査における cur の次ノードを取得
+            # 通りがけ順で cur の次のノードを取得する
             tmp: TreeNode = cur.right
             while tmp.left is not None:
                 tmp = tmp.left
-            # ノード tmp を再帰的に削除
+            # ノード tmp を再帰的に削除する
             self.remove(tmp.val)
             # tmp で cur を上書きする
             cur.val = tmp.val
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
-    # 二分探索木を初期化
+    # 二分探索木を初期化する
     bst = BinarySearchTree()
     nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15]
-    # 注意：挿入順序が異なると異なる二分木が生成される。このシーケンスからは完全二分木を生成できる
+    # 挿入順序が異なると異なる二分木になることに注意。この順序ではパーフェクト二分木を生成できる
     for num in nums:
         bst.insert(num)
-    print("\n初期化した二分木は\n")
+    print("\n初期化した二分木\n")
     print_tree(bst.get_root())
 
-    # ノードを探索
+    # ノードを探索する
     node = bst.search(7)
     print("\n見つかったノードオブジェクトは: {}、ノードの値 = {}".format(node, node.val))
 
-    # ノードを挿入
+    # ノードを挿入する
     bst.insert(16)
-    print("\nノード 16 を挿入した後、二分木は\n")
+    print("\nノード 16 を挿入した後の二分木\n")
     print_tree(bst.get_root())
 
-    # ノードを削除
+    # ノードを削除する
     bst.remove(1)
-    print("\nノード 1 を削除した後、二分木は\n")
+    print("\nノード 1 を削除した後の二分木\n")
     print_tree(bst.get_root())
 
     bst.remove(2)
-    print("\nノード 2 を削除した後、二分木は\n")
+    print("\nノード 2 を削除した後の二分木\n")
     print_tree(bst.get_root())
 
     bst.remove(4)
-    print("\nノード 4 を削除した後、二分木は\n")
+    print("\nノード 4 を削除した後の二分木\n")
     print_tree(bst.get_root())

ja/codes/python/chapter_tree/binary_tree.py

@@ -11,7 +11,7 @@ sys.path.append(str(Path(__file__).parent.parent))
 from modules import TreeNode, print_tree
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
     # 二分木を初期化する
     # ノードを初期化する
@@ -20,22 +20,22 @@ if __name__ == "__main__":
     n3 = TreeNode(val=3)
     n4 = TreeNode(val=4)
     n5 = TreeNode(val=5)
-    # ノード間の参照（ポインタ）を構築する
+    # ノード間の参照（ポインタ）を設定する
     n1.left = n2
     n1.right = n3
     n2.left = n4
     n2.right = n5
-    print("\n二分木を初期化\n")
+    print("\n二分木を初期化する\n")
     print_tree(n1)
 
     # ノードの挿入と削除
     P = TreeNode(0)
-    # n1 -> n2 の間にノード P を挿入
+    # n1 -> n2 の間にノード P を挿入する
     n1.left = P
     P.left = n2
-    print("\nノード P を挿入した後\n")
+    print("\nノード P の挿入後\n")
     print_tree(n1)
-    # ノードを削除
+    # ノードを削除する
     n1.left = n2
-    print("\nノード P を削除した後\n")
+    print("\nノード P の削除後\n")
     print_tree(n1)

ja/codes/python/chapter_tree/binary_tree_bfs.py

@@ -14,29 +14,29 @@ from collections import deque
 
 def level_order(root: TreeNode | None) -> list[int]:
     """レベル順走査"""
-    # キューを初期化し、ルートノードを追加する
+    # キューを初期化し、根ノードを追加する
     queue: deque[TreeNode] = deque()
     queue.append(root)
-    # 走査順序を保存するためのリストを初期化する
+    # 走査順序を保存するリストを初期化する
     res = []
     while queue:
-        node: TreeNode = queue.popleft()  # デキュー
+        node: TreeNode = queue.popleft()  # キューからデキューする
         res.append(node.val)  # ノードの値を保存する
         if node.left is not None:
-            queue.append(node.left)  # 左子ノードをキューに追加
+            queue.append(node.left)  # 左の子ノードをエンキューする
         if node.right is not None:
-            queue.append(node.right)  # 右子ノードをキューに追加
+            queue.append(node.right)  # 右の子ノードをエンキューする
     return res
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
-    # 二分木を初期化
-    # ここでは、配列から直接二分木を生成する関数を利用する
+    # 二分木を初期化する
+    # ここでは配列から二分木を直接生成する関数を使う
     root: TreeNode = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7])
-    print("\n二分木を初期化\n")
+    print("\n二分木を初期化する\n")
     print_tree(root)
 
     # レベル順走査
     res: list[int] = level_order(root)
-    print("\nレベル順走査のノード出力シーケンス = ", res)
+    print("\nレベル順走査で表示するノードの順序 = ", res)

ja/codes/python/chapter_tree/binary_tree_dfs.py

@@ -12,7 +12,7 @@ from modules import TreeNode, list_to_tree, print_tree
 
 
 def pre_order(root: TreeNode | None):
-    """先行順走査"""
+    """行きがけ順走査"""
     if root is None:
         return
     # 訪問順序：根ノード -> 左部分木 -> 右部分木
@@ -22,44 +22,44 @@ def pre_order(root: TreeNode | None):
 
 
 def in_order(root: TreeNode | None):
-    """中順走査"""
+    """通りがけ順走査"""
     if root is None:
         return
-    # 訪問優先順: 左部分木 -> 根ノード -> 右部分木
+    # 訪問順序：左部分木 -> 根ノード -> 右部分木
     in_order(root=root.left)
     res.append(root.val)
     in_order(root=root.right)
 
 
 def post_order(root: TreeNode | None):
-    """後順走査"""
+    """帰りがけ順走査"""
     if root is None:
         return
-    # 訪問優先順: 左部分木 -> 右部分木 -> 根ノード
+    # 訪問順序：左部分木 -> 右部分木 -> 根ノード
     post_order(root=root.left)
     post_order(root=root.right)
     res.append(root.val)
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
-    # 二分木を初期化
-    # ここでは、配列から直接二分木を生成する関数を利用する
+    # 二分木を初期化する
+    # ここでは配列から二分木を直接生成する関数を使う
     root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7])
-    print("\n二分木を初期化\n")
+    print("\n二分木を初期化する\n")
     print_tree(root)
 
-    # 先行順走査
+    # 行きがけ順走査
     res = []
     pre_order(root)
-    print("\n先行順走査のノード出力シーケンス = ", res)
+    print("\n行きがけ順走査で表示するノードの順序 = ", res)
 
-    # 中順走査
+    # 通りがけ順走査
     res.clear()
     in_order(root)
-    print("\n中間順走査のノード出力シーケンス = ", res)
+    print("\n通りがけ順走査で表示するノードの順序 = ", res)
 
-    # 後順走査
+    # 帰りがけ順走査
     res.clear()
     post_order(root)
-    print("\n後行順走査のノード出力シーケンス = ", res)
+    print("\n帰りがけ順走査で表示するノードの順序 = ", res)