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)