Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/dart/chapter_tree/array_binary_tree.dart

@@ -0,0 +1,152 @@
+/**
+ * File: array_binary_tree.dart
+ * Created Time: 2023-08-15
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* 配列表現による二分木クラス */
+class ArrayBinaryTree {
+  late List<int?> _tree;
+
+  /* コンストラクタ */
+  ArrayBinaryTree(this._tree);
+
+  /* リスト容量 */
+  int size() {
+    return _tree.length;
+  }
+
+  /* インデックス i のノードの値を取得 */
+  int? val(int i) {
+    // インデックスが範囲外なら、空きを表す null を返す
+    if (i < 0 || i >= size()) {
+      return null;
+    }
+    return _tree[i];
+  }
+
+  /* インデックス i のノードの左子ノードのインデックスを取得 */
+  int? left(int i) {
+    return 2 * i + 1;
+  }
+
+  /* インデックス i のノードの右子ノードのインデックスを取得 */
+  int? right(int i) {
+    return 2 * i + 2;
+  }
+
+  /* インデックス i のノードの親ノードのインデックスを取得 */
+  int? parent(int i) {
+    return (i - 1) ~/ 2;
+  }
+
+  /* レベル順走査 */
+  List<int> levelOrder() {
+    List<int> res = [];
+    for (int i = 0; i < size(); i++) {
+      if (val(i) != null) {
+        res.add(val(i)!);
+      }
+    }
+    return res;
+  }
+
+  /* 深さ優先探索 */
+  void dfs(int i, String order, List<int?> res) {
+    // 空きスロットなら返す
+    if (val(i) == null) {
+      return;
+    }
+    // 先行順走査
+    if (order == 'pre') {
+      res.add(val(i));
+    }
+    dfs(left(i)!, order, res);
+    // 中順走査
+    if (order == 'in') {
+      res.add(val(i));
+    }
+    dfs(right(i)!, order, res);
+    // 後順走査
+    if (order == 'post') {
+      res.add(val(i));
+    }
+  }
+
+  /* 先行順走査 */
+  List<int?> preOrder() {
+    List<int?> res = [];
+    dfs(0, 'pre', res);
+    return res;
+  }
+
+  /* 中順走査 */
+  List<int?> inOrder() {
+    List<int?> res = [];
+    dfs(0, 'in', res);
+    return res;
+  }
+
+  /* 後順走査 */
+  List<int?> postOrder() {
+    List<int?> res = [];
+    dfs(0, 'post', res);
+    return res;
+  }
+}
+
+/* Driver Code */
+void main() {
+  // 二分木を初期化
+  // ここでは、配列から直接二分木を生成する関数を利用する
+  List<int?> arr = [
+    1,
+    2,
+    3,
+    4,
+    null,
+    6,
+    7,
+    8,
+    9,
+    null,
+    null,
+    12,
+    null,
+    null,
+    15
+  ];
+
+  TreeNode? root = listToTree(arr);
+  print("\n二分木を初期化\n");
+  print("二分木の配列表現：");
+  print(arr);
+  print("二分木の連結リスト表現：");
+  printTree(root);
+
+  // 配列表現による二分木クラス
+  ArrayBinaryTree abt = ArrayBinaryTree(arr);
+
+  // ノードにアクセス
+  int i = 1;
+  int? l = abt.left(i);
+  int? r = abt.right(i);
+  int? p = abt.parent(i);
+  print("\n現在のノードのインデックスは $i ，値は ${abt.val(i)}");
+  print("その左子ノードのインデックスは $l ，値は ${(l == null ? "null" : abt.val(l))}");
+  print("その右子ノードのインデックスは $r ，値は ${(r == null ? "null" : abt.val(r))}");
+  print("その親ノードのインデックスは $p ，値は ${(p == null ? "null" : abt.val(p))}");
+
+  // 木を走査
+  List<int?> res = abt.levelOrder();
+  print("\nレベル順走査：$res");
+  res = abt.preOrder();
+  print("先行順走査は $res");
+  res = abt.inOrder();
+  print("中間順走査は $res");
+  res = abt.postOrder();
+  print("後行順走査は $res");
+}

ja/codes/dart/chapter_tree/avl_tree.dart

@@ -0,0 +1,218 @@
+/**
+ * File: avl_tree.dart
+ * Created Time: 2023-04-04
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+class AVLTree {
+  TreeNode? root;
+
+  /* コンストラクタ */
+  AVLTree() {
+    root = null;
+  }
+
+  /* ノードの高さを取得 */
+  int height(TreeNode? node) {
+    // 空ノードの高さは -1、葉ノードの高さは 0
+    return node == null ? -1 : node.height;
+  }
+
+  /* ノードの高さを更新する */
+  void updateHeight(TreeNode? node) {
+    // ノードの高さは最も高い部分木の高さ + 1 に等しい
+    node!.height = max(height(node.left), height(node.right)) + 1;
+  }
+
+  /* 平衡係数を取得 */
+  int balanceFactor(TreeNode? node) {
+    // 空ノードの平衡係数は 0
+    if (node == null) return 0;
+    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ
+    return height(node.left) - height(node.right);
+  }
+
+  /* 右回転 */
+  TreeNode? rightRotate(TreeNode? node) {
+    TreeNode? child = node!.left;
+    TreeNode? grandChild = child!.right;
+    // child を支点として node を右回転させる
+    child.right = node;
+    node.left = grandChild;
+    // ノードの高さを更新する
+    updateHeight(node);
+    updateHeight(child);
+    // 回転後の部分木の根ノードを返す
+    return child;
+  }
+
+  /* 左回転 */
+  TreeNode? leftRotate(TreeNode? node) {
+    TreeNode? child = node!.right;
+    TreeNode? grandChild = child!.left;
+    // child を支点として node を左回転させる
+    child.left = node;
+    node.right = grandChild;
+    // ノードの高さを更新する
+    updateHeight(node);
+    updateHeight(child);
+    // 回転後の部分木の根ノードを返す
+    return child;
+  }
+
+  /* 回転操作を行い、この部分木の平衡を回復する */
+  TreeNode? rotate(TreeNode? node) {
+    // ノード node の平衡係数を取得
+    int factor = balanceFactor(node);
+    // 左に偏った木
+    if (factor > 1) {
+      if (balanceFactor(node!.left) >= 0) {
+        // 右回転
+        return rightRotate(node);
+      } else {
+        // 左回転してから右回転
+        node.left = leftRotate(node.left);
+        return rightRotate(node);
+      }
+    }
+    // 右に偏った木
+    if (factor < -1) {
+      if (balanceFactor(node!.right) <= 0) {
+        // 左回転
+        return leftRotate(node);
+      } else {
+        // 右回転してから左回転
+        node.right = rightRotate(node.right);
+        return leftRotate(node);
+      }
+    }
+    // 平衡木なので回転不要、そのまま返す
+    return node;
+  }
+
+  /* ノードを挿入 */
+  void insert(int val) {
+    root = insertHelper(root, val);
+  }
+
+  /* ノードを再帰的に挿入する（補助メソッド） */
+  TreeNode? insertHelper(TreeNode? node, int val) {
+    if (node == null) return TreeNode(val);
+    /* 1. 挿入位置を探索してノードを挿入 */
+    if (val < node.val)
+      node.left = insertHelper(node.left, val);
+    else if (val > node.val)
+      node.right = insertHelper(node.right, val);
+    else
+      return node; // 重複ノードは挿入せず、そのまま返す
+    updateHeight(node); // ノードの高さを更新する
+    /* 2. 回転操作を行い、部分木の平衡を回復する */
+    node = rotate(node);
+    // 部分木の根ノードを返す
+    return node;
+  }
+
+  /* ノードを削除 */
+  void remove(int val) {
+    root = removeHelper(root, val);
+  }
+
+  /* ノードを再帰的に削除する（補助メソッド） */
+  TreeNode? removeHelper(TreeNode? node, int val) {
+    if (node == null) return null;
+    /* 1. ノードを探索して削除 */
+    if (val < node.val)
+      node.left = removeHelper(node.left, val);
+    else if (val > node.val)
+      node.right = removeHelper(node.right, val);
+    else {
+      if (node.left == null || node.right == null) {
+        TreeNode? child = node.left ?? node.right;
+        // 子ノード数 = 0 の場合、node をそのまま削除して返す
+        if (child == null)
+          return null;
+        // 子ノード数 = 1 の場合、node をそのまま削除する
+        else
+          node = child;
+      } else {
+        // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える
+        TreeNode? temp = node.right;
+        while (temp!.left != null) {
+          temp = temp.left;
+        }
+        node.right = removeHelper(node.right, temp.val);
+        node.val = temp.val;
+      }
+    }
+    updateHeight(node); // ノードの高さを更新する
+    /* 2. 回転操作を行い、部分木の平衡を回復する */
+    node = rotate(node);
+    // 部分木の根ノードを返す
+    return node;
+  }
+
+  /* ノードを探索 */
+  TreeNode? search(int val) {
+    TreeNode? cur = root;
+    // ループで探索し、葉ノードを越えたら抜ける
+    while (cur != null) {
+      // 目標ノードは cur の右部分木にある
+      if (val < cur.val)
+        cur = cur.left;
+      // 目標ノードは cur の左部分木にある
+      else if (val > cur.val)
+        cur = cur.right;
+      // 対象ノードが現在のノードと等しい
+      else
+        break;
+    }
+    return cur;
+  }
+}
+
+void testInsert(AVLTree tree, int val) {
+  tree.insert(val);
+  print("\nノード $val を挿入後、AVL 木は");
+  printTree(tree.root);
+}
+
+void testRemove(AVLTree tree, int val) {
+  tree.remove(val);
+  print("\nノード $val を削除後、AVL 木は");
+  printTree(tree.root);
+}
+
+/* Driver Code */
+void main() {
+  /* 空の AVL 木を初期化する */
+  AVLTree avlTree = AVLTree();
+  /* ノードを挿入 */
+  // ノード挿入後に AVL 木がどのように平衡を保つかに注目してほしい
+  testInsert(avlTree, 1);
+  testInsert(avlTree, 2);
+  testInsert(avlTree, 3);
+  testInsert(avlTree, 4);
+  testInsert(avlTree, 5);
+  testInsert(avlTree, 8);
+  testInsert(avlTree, 7);
+  testInsert(avlTree, 9);
+  testInsert(avlTree, 10);
+  testInsert(avlTree, 6);
+
+  /* 重複ノードを挿入する */
+  testInsert(avlTree, 7);
+
+  /* ノードを削除 */
+  // ノード削除後に AVL 木がどのように平衡を保つかに注目してほしい
+  testRemove(avlTree, 8); // 次数 0 のノードを削除する
+  testRemove(avlTree, 5); // 次数 1 のノードを削除する
+  testRemove(avlTree, 4); // 次数 2 のノードを削除する
+
+  /* ノードを検索 */
+  TreeNode? node = avlTree.search(7);
+  print("\n見つかったノードオブジェクトは $node ，ノードの値 = ${node!.val}");
+}

ja/codes/dart/chapter_tree/binary_search_tree.dart

@@ -0,0 +1,153 @@
+/**
+ * File: binary_search_tree.dart
+ * Created Time: 2023-04-04
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* 二分探索木 */
+class BinarySearchTree {
+  late TreeNode? _root;
+
+  /* コンストラクタ */
+  BinarySearchTree() {
+    // 空の木を初期化する
+    _root = null;
+  }
+
+  /* 二分木の根ノードを取得する */
+  TreeNode? getRoot() {
+    return _root;
+  }
+
+  /* ノードを探索 */
+  TreeNode? search(int _num) {
+    TreeNode? cur = _root;
+    // ループで探索し、葉ノードを越えたら抜ける
+    while (cur != null) {
+      // 目標ノードは cur の右部分木にある
+      if (cur.val < _num)
+        cur = cur.right;
+      // 目標ノードは cur の左部分木にある
+      else if (cur.val > _num)
+        cur = cur.left;
+      // 目標ノードが見つかったらループを抜ける
+      else
+        break;
+    }
+    // 目標ノードを返す
+    return cur;
+  }
+
+  /* ノードを挿入 */
+  void insert(int _num) {
+    // 木が空なら、根ノードを初期化する
+    if (_root == null) {
+      _root = TreeNode(_num);
+      return;
+    }
+    TreeNode? cur = _root;
+    TreeNode? pre = null;
+    // ループで探索し、葉ノードを越えたら抜ける
+    while (cur != null) {
+      // 重複ノードが見つかったら、直ちに返す
+      if (cur.val == _num) return;
+      pre = cur;
+      // 挿入位置は cur の右部分木にある
+      if (cur.val < _num)
+        cur = cur.right;
+      // 挿入位置は cur の左部分木にある
+      else
+        cur = cur.left;
+    }
+    // ノードを挿入
+    TreeNode? node = TreeNode(_num);
+    if (pre!.val < _num)
+      pre.right = node;
+    else
+      pre.left = node;
+  }
+
+  /* ノードを削除 */
+  void remove(int _num) {
+    // 木が空なら、そのまま早期リターンする
+    if (_root == null) return;
+    TreeNode? cur = _root;
+    TreeNode? pre = null;
+    // ループで探索し、葉ノードを越えたら抜ける
+    while (cur != null) {
+      // 削除対象のノードが見つかったら、ループを抜ける
+      if (cur.val == _num) break;
+      pre = cur;
+      // 削除対象ノードは cur の右部分木にある
+      if (cur.val < _num)
+        cur = cur.right;
+      // 削除対象ノードは cur の左部分木にある
+      else
+        cur = cur.left;
+    }
+    // 削除対象ノードがない場合は、そのまま返す
+    if (cur == null) return;
+    // 子ノード数 = 0 or 1
+    if (cur.left == null || cur.right == null) {
+      // 子ノード数が 0 / 1 のとき、child = null / その子ノード
+      TreeNode? child = cur.left ?? cur.right;
+      // ノード cur を削除する
+      if (cur != _root) {
+        if (pre!.left == cur)
+          pre.left = child;
+        else
+          pre.right = child;
+      } else {
+        // 削除ノードが根ノードなら、根ノードを再設定
+        _root = child;
+      }
+    } else {
+      // 子ノード数 = 2
+      // 中順走査における cur の次のノードを取得
+      TreeNode? tmp = cur.right;
+      while (tmp!.left != null) {
+        tmp = tmp.left;
+      }
+      // ノード tmp を再帰的に削除
+      remove(tmp.val);
+      // tmp で cur を上書きする
+      cur.val = tmp.val;
+    }
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* 二分探索木を初期化 */
+  BinarySearchTree bst = BinarySearchTree();
+  // 注意：挿入順序が異なると異なる二分木が生成される。このシーケンスからは完全二分木を生成できる
+  List<int> nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15];
+  for (int _num in nums) {
+    bst.insert(_num);
+  }
+  print("\n初期化した二分木は\n");
+  printTree(bst.getRoot());
+
+  /* ノードを探索 */
+  TreeNode? node = bst.search(7);
+  print("\n見つかったノードオブジェクトは $node ，ノードの値 = ${node?.val}");
+
+  /* ノードを挿入 */
+  bst.insert(16);
+  print("\nノード 16 を挿入後、二分木は\n");
+  printTree(bst.getRoot());
+
+  /* ノードを削除 */
+  bst.remove(1);
+  print("\nノード 1 を削除後、二分木は\n");
+  printTree(bst.getRoot());
+  bst.remove(2);
+  print("\nノード 2 を削除後、二分木は\n");
+  printTree(bst.getRoot());
+  bst.remove(4);
+  print("\nノード 4 を削除後、二分木は\n");
+  printTree(bst.getRoot());
+}

ja/codes/dart/chapter_tree/binary_tree.dart

@@ -0,0 +1,37 @@
+/**
+ * File: binary_tree.dart
+ * Created Time: 2023-04-03
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+void main() {
+  /* 二分木を初期化 */
+  // ノードをヒープ化
+  TreeNode n1 = TreeNode(1);
+  TreeNode n2 = TreeNode(2);
+  TreeNode n3 = TreeNode(3);
+  TreeNode n4 = TreeNode(4);
+  TreeNode n5 = TreeNode(5);
+  // ノード間の参照（ポインタ）を構築する
+  n1.left = n2;
+  n1.right = n3;
+  n2.left = n4;
+  n2.right = n5;
+  print("\n二分木を初期化\n");
+  printTree(n1);
+
+  /* ノードの挿入と削除 */
+  TreeNode p = TreeNode(0);
+  // n1 -> n2 の間にノード p を挿入する
+  n1.left = p;
+  p.left = n2;
+  print("\nノード P を挿入後\n");
+  printTree(n1);
+  // ノード P を削除
+  n1.left = n2;
+  print("\nノード P を削除後\n");
+  printTree(n1);
+}

ja/codes/dart/chapter_tree/binary_tree_bfs.dart

@@ -0,0 +1,38 @@
+/**
+ * File: binary_tree_bfs.dart
+ * Created Time: 2023-04-03
+ * Author: liuyuxin (gvenusleo@gmai.com)
+ */
+
+import 'dart:collection';
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* レベル順走査 */
+List<int> levelOrder(TreeNode? root) {
+  // キューを初期化し、ルートノードを追加する
+  Queue<TreeNode?> queue = Queue();
+  queue.add(root);
+  // 走査順序を保存するためのリストを初期化する
+  List<int> res = [];
+  while (queue.isNotEmpty) {
+    TreeNode? node = queue.removeFirst(); // デキュー
+    res.add(node!.val); // ノードの値を保存する
+    if (node.left != null) queue.add(node.left); // 左子ノードをキューに追加
+    if (node.right != null) queue.add(node.right); // 右子ノードをキューに追加
+  }
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  /* 二分木を初期化 */
+  // ここでは、配列から直接二分木を生成する関数を利用する
+  TreeNode? root = listToTree([1, 2, 3, 4, 5, 6, 7]);
+  print("\n二分木を初期化\n");
+  printTree(root);
+
+  // レベル順走査
+  List<int> res = levelOrder(root);
+  print("\nレベル順走査のノード出力順 = $res");
+}

ja/codes/dart/chapter_tree/binary_tree_dfs.dart

@@ -0,0 +1,62 @@
+/**
+ * File: binary_tree_dfs.dart
+ * Created Time: 2023-04-04
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+// 走査順序を格納するリストを初期化
+List<int> list = [];
+
+/* 先行順走査 */
+void preOrder(TreeNode? node) {
+  if (node == null) return;
+  // 訪問順序：根ノード -> 左部分木 -> 右部分木
+  list.add(node.val);
+  preOrder(node.left);
+  preOrder(node.right);
+}
+
+/* 中順走査 */
+void inOrder(TreeNode? node) {
+  if (node == null) return;
+  // 訪問優先順: 左部分木 -> 根ノード -> 右部分木
+  inOrder(node.left);
+  list.add(node.val);
+  inOrder(node.right);
+}
+
+/* 後順走査 */
+void postOrder(TreeNode? node) {
+  if (node == null) return;
+  // 訪問優先順: 左部分木 -> 右部分木 -> 根ノード
+  postOrder(node.left);
+  postOrder(node.right);
+  list.add(node.val);
+}
+
+/* Driver Code */
+void main() {
+  /* 二分木を初期化 */
+  // ここでは、配列から直接二分木を生成する関数を利用する
+  TreeNode? root = listToTree([1, 2, 3, 4, 5, 6, 7]);
+  print("\n二分木を初期化\n");
+  printTree(root);
+
+  /* 先行順走査 */
+  list.clear();
+  preOrder(root);
+  print("\n先行順走査のノード出力順 = $list");
+
+  /* 中順走査 */
+  list.clear();
+  inOrder(root);
+  print("\n中間順走査のノード出力順 = $list");
+
+  /* 後順走査 */
+  list.clear();
+  postOrder(root);
+  print("\n後行順走査のノード出力順 = $list");
+}