Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/kotlin/chapter_tree/array_binary_tree.kt

@@ -0,0 +1,127 @@
+/**
+ * File: array_binary_tree.kt
+ * Created Time: 2024-01-25
+ * Author: curtishd (1023632660@qq.com)
+ */
+
+package chapter_tree
+
+import utils.TreeNode
+import utils.printTree
+
+/* 配列表現による二分木クラス */
+class ArrayBinaryTree(private val tree: MutableList<Int?>) {
+    /* リスト容量 */
+    fun size(): Int {
+        return tree.size
+    }
+
+    /* インデックス i のノードの値を取得 */
+    fun _val(i: Int): Int? {
+        // インデックスが範囲外なら、空きを表す null を返す
+        if (i < 0 || i >= size()) return null
+        return tree[i]
+    }
+
+    /* インデックス i のノードの左子ノードのインデックスを取得 */
+    fun left(i: Int): Int {
+        return 2 * i + 1
+    }
+
+    /* インデックス i のノードの右子ノードのインデックスを取得 */
+    fun right(i: Int): Int {
+        return 2 * i + 2
+    }
+
+    /* インデックス i のノードの親ノードのインデックスを取得 */
+    fun parent(i: Int): Int {
+        return (i - 1) / 2
+    }
+
+    /* レベル順走査 */
+    fun levelOrder(): MutableList<Int?> {
+        val res = mutableListOf<Int?>()
+        // 配列を直接走査する
+        for (i in 0..<size()) {
+            if (_val(i) != null)
+                res.add(_val(i))
+        }
+        return res
+    }
+
+    /* 深さ優先探索 */
+    fun dfs(i: Int, order: String, res: MutableList<Int?>) {
+        // 空きスロットなら返す
+        if (_val(i) == null)
+            return
+        // 先行順走査
+        if ("pre" == order)
+            res.add(_val(i))
+        dfs(left(i), order, res)
+        // 中順走査
+        if ("in" == order)
+            res.add(_val(i))
+        dfs(right(i), order, res)
+        // 後順走査
+        if ("post" == order)
+            res.add(_val(i))
+    }
+
+    /* 先行順走査 */
+    fun preOrder(): MutableList<Int?> {
+        val res = mutableListOf<Int?>()
+        dfs(0, "pre", res)
+        return res
+    }
+
+    /* 中順走査 */
+    fun inOrder(): MutableList<Int?> {
+        val res = mutableListOf<Int?>()
+        dfs(0, "in", res)
+        return res
+    }
+
+    /* 後順走査 */
+    fun postOrder(): MutableList<Int?> {
+        val res = mutableListOf<Int?>()
+        dfs(0, "post", res)
+        return res
+    }
+}
+
+/* Driver Code */
+fun main() {
+    // 二分木を初期化する
+    // ここでは、リストから二分木を直接生成する関数を利用する
+    val arr = mutableListOf(1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15)
+
+    val root = TreeNode.listToTree(arr)
+    println("\n二分木を初期化\n")
+    println("二分木の配列表現：")
+    println(arr)
+    println("二分木の連結リスト表現：")
+    printTree(root)
+
+    // 配列表現による二分木クラス
+    val abt = ArrayBinaryTree(arr)
+
+    // ノードにアクセス
+    val i = 1
+    val l = abt.left(i)
+    val r = abt.right(i)
+    val p = abt.parent(i)
+    println("現在のノードのインデックスは $i 、値は ${abt._val(i)}")
+    println("左の子ノードのインデックスは $l 、値は ${abt._val(l)}")
+    println("右の子ノードのインデックスは $r 、値は ${abt._val(r)}")
+    println("親ノードのインデックスは $p 、値は ${abt._val(p)}")
+
+    // 木を走査
+    var res = abt.levelOrder()
+    println("\nレベル順走査：$res")
+    res = abt.preOrder()
+    println("先行順走査：$res")
+    res = abt.inOrder()
+    println("中間順走査：$res")
+    res = abt.postOrder()
+    println("後行順走査：$res")
+}

ja/codes/kotlin/chapter_tree/avl_tree.kt

@@ -0,0 +1,223 @@
+/**
+ * File: avl_tree.kt
+ * Created Time: 2024-01-25
+ * Author: curtishd (1023632660@qq.com)
+ */
+
+package chapter_tree
+
+import utils.TreeNode
+import utils.printTree
+import kotlin.math.max
+
+/* AVL 木 */
+class AVLTree {
+    var root: TreeNode? = null // 根ノード
+
+    /* ノードの高さを取得 */
+    fun height(node: TreeNode?): Int {
+        // 空ノードの高さは -1、葉ノードの高さは 0
+        return node?.height ?: -1
+    }
+
+    /* ノードの高さを更新する */
+    private fun updateHeight(node: TreeNode?) {
+        // ノードの高さは最も高い部分木の高さ + 1 に等しい
+        node?.height = max(height(node?.left), height(node?.right)) + 1
+    }
+
+    /* 平衡係数を取得 */
+    fun balanceFactor(node: TreeNode?): Int {
+        // 空ノードの平衡係数は 0
+        if (node == null) return 0
+        // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ
+        return height(node.left) - height(node.right)
+    }
+
+    /* 右回転 */
+    private fun rightRotate(node: TreeNode?): TreeNode {
+        val child = node!!.left
+        val grandChild = child!!.right
+        // child を支点として node を右回転させる
+        child.right = node
+        node.left = grandChild
+        // ノードの高さを更新する
+        updateHeight(node)
+        updateHeight(child)
+        // 回転後の部分木の根ノードを返す
+        return child
+    }
+
+    /* 左回転 */
+    private fun leftRotate(node: TreeNode?): TreeNode {
+        val child = node!!.right
+        val grandChild = child!!.left
+        // child を支点として node を左回転させる
+        child.left = node
+        node.right = grandChild
+        // ノードの高さを更新する
+        updateHeight(node)
+        updateHeight(child)
+        // 回転後の部分木の根ノードを返す
+        return child
+    }
+
+    /* 回転操作を行い、この部分木の平衡を回復する */
+    private fun rotate(node: TreeNode): TreeNode {
+        // ノード node の平衡係数を取得
+        val balanceFactor = balanceFactor(node)
+        // 左に偏った木
+        if (balanceFactor > 1) {
+            if (balanceFactor(node.left) >= 0) {
+                // 右回転
+                return rightRotate(node)
+            } else {
+                // 左回転してから右回転
+                node.left = leftRotate(node.left)
+                return rightRotate(node)
+            }
+        }
+        // 右に偏った木
+        if (balanceFactor < -1) {
+            if (balanceFactor(node.right) <= 0) {
+                // 左回転
+                return leftRotate(node)
+            } else {
+                // 右回転してから左回転
+                node.right = rightRotate(node.right)
+                return leftRotate(node)
+            }
+        }
+        // 平衡木なので回転不要、そのまま返す
+        return node
+    }
+
+    /* ノードを挿入 */
+    fun insert(_val: Int) {
+        root = insertHelper(root, _val)
+    }
+
+    /* ノードを再帰的に挿入する（補助メソッド） */
+    private fun insertHelper(n: TreeNode?, _val: Int): TreeNode {
+        if (n == null)
+            return TreeNode(_val)
+        var node = n
+        /* 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
+    }
+
+    /* ノードを削除 */
+    fun remove(_val: Int) {
+        root = removeHelper(root, _val)
+    }
+
+    /* ノードを再帰的に削除する（補助メソッド） */
+    private fun removeHelper(n: TreeNode?, _val: Int): TreeNode? {
+        var node = n ?: 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) {
+                val child = if (node.left != null)
+                    node.left
+                else
+                    node.right
+                // 子ノード数 = 0 の場合、node をそのまま削除して返す
+                if (child == null)
+                    return null
+                // 子ノード数 = 1 の場合、node をそのまま削除する
+                else
+                    node = child
+            } else {
+                // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える
+                var 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
+    }
+
+    /* ノードを探索 */
+    fun search(_val: Int): TreeNode? {
+        var cur = root
+        // ループで探索し、葉ノードを越えたら抜ける
+        while (cur != null) {
+            // 目標ノードは cur の右部分木にある
+            cur = if (cur._val < _val)
+                cur.right!!
+            // 目標ノードは cur の左部分木にある
+            else if (cur._val > _val)
+                cur.left
+            // 目標ノードが見つかったらループを抜ける
+            else
+                break
+        }
+        // 目標ノードを返す
+        return cur
+    }
+}
+
+fun testInsert(tree: AVLTree, _val: Int) {
+    tree.insert(_val)
+    println("\nノード $_val を挿入後、AVL 木は")
+    printTree(tree.root)
+}
+
+fun testRemove(tree: AVLTree, _val: Int) {
+    tree.remove(_val)
+    println("\nノード $_val を削除後、AVL 木は")
+    printTree(tree.root)
+}
+
+/* Driver Code */
+fun main() {
+    /* 空の AVL 木を初期化する */
+    val 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 のノードを削除する
+
+    /* ノードを検索 */
+    val node = avlTree.search(7)
+    println("\n 見つかったノードオブジェクトは $node、ノードの値 = ${node?._val}")
+}

ja/codes/kotlin/chapter_tree/binary_search_tree.kt

@@ -0,0 +1,157 @@
+/**
+ * File: binary_search_tree.kt
+ * Created Time: 2024-01-25
+ * Author: curtishd (1023632660@qq.com)
+ */
+
+package chapter_tree
+
+import utils.TreeNode
+import utils.printTree
+
+/* 二分探索木 */
+class BinarySearchTree {
+    // 空の木を初期化する
+    private var root: TreeNode? = null
+
+    /* 二分木の根ノードを取得 */
+    fun getRoot(): TreeNode? {
+        return root
+    }
+
+    /* ノードを探索 */
+    fun search(num: Int): TreeNode? {
+        var cur = root
+        // ループで探索し、葉ノードを越えたら抜ける
+        while (cur != null) {
+            // 目標ノードは cur の右部分木にある
+            cur = if (cur._val < num)
+                cur.right
+            // 目標ノードは cur の左部分木にある
+            else if (cur._val > num)
+                cur.left
+            // 目標ノードが見つかったらループを抜ける
+            else
+                break
+        }
+        // 目標ノードを返す
+        return cur
+    }
+
+    /* ノードを挿入 */
+    fun insert(num: Int) {
+        // 木が空なら、根ノードを初期化する
+        if (root == null) {
+            root = TreeNode(num)
+            return
+        }
+        var cur = root
+        var pre: TreeNode? = null
+        // ループで探索し、葉ノードを越えたら抜ける
+        while (cur != null) {
+            // 重複ノードが見つかったら、直ちに返す
+            if (cur._val == num)
+                return
+            pre = cur
+            // 挿入位置は cur の右部分木にある
+            cur = if (cur._val < num)
+                cur.right
+            // 挿入位置は cur の左部分木にある
+            else
+                cur.left
+        }
+        // ノードを挿入
+        val node = TreeNode(num)
+        if (pre?._val!! < num)
+            pre.right = node
+        else
+            pre.left = node
+    }
+
+    /* ノードを削除 */
+    fun remove(num: Int) {
+        // 木が空なら、そのまま早期リターンする
+        if (root == null)
+            return
+        var cur = root
+        var pre: TreeNode? = null
+        // ループで探索し、葉ノードを越えたら抜ける
+        while (cur != null) {
+            // 削除対象のノードが見つかったら、ループを抜ける
+            if (cur._val == num)
+                break
+            pre = cur
+            // 削除対象ノードは cur の右部分木にある
+            cur = if (cur._val < num)
+                cur.right
+            // 削除対象ノードは cur の左部分木にある
+            else
+                cur.left
+        }
+        // 削除対象ノードがなければそのまま返す
+        if (cur == null)
+            return
+        // 子ノード数 = 0 or 1
+        if (cur.left == null || cur.right == null) {
+            // 子ノード数が 0 / 1 のとき、child = null / その子ノード
+            val child = if (cur.left != null)
+                cur.left
+            else
+                cur.right
+            // ノード cur を削除する
+            if (cur != root) {
+                if (pre!!.left == cur)
+                    pre.left = child
+                else
+                    pre.right = child
+            } else {
+                // 削除ノードが根ノードなら、根ノードを再設定
+                root = child
+            }
+            // 子ノード数 = 2
+        } else {
+            // 中順走査における cur の次ノードを取得
+            var tmp = cur.right
+            while (tmp!!.left != null) {
+                tmp = tmp.left
+            }
+            // ノード tmp を再帰的に削除
+            remove(tmp._val)
+            // tmp で cur を上書きする
+            cur._val = tmp._val
+        }
+    }
+}
+
+/* Driver Code */
+fun main() {
+    /* 二分探索木を初期化 */
+    val bst = BinarySearchTree()
+    // 注意：挿入順序が異なると異なる二分木が生成される。このシーケンスからは完全二分木を生成できる
+    val nums = intArrayOf(8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15)
+    for (num in nums) {
+        bst.insert(num)
+    }
+    println("\n初期化した二分木は\n")
+    printTree(bst.getRoot())
+
+    /* ノードを探索 */
+    val node = bst.search(7)
+    println("見つかったノードオブジェクトは $node、ノードの値 = ${node?._val}")
+
+    /* ノードを挿入 */
+    bst.insert(16)
+    println("\nノード 16 を挿入後、二分木は\n")
+    printTree(bst.getRoot())
+
+    /* ノードを削除 */
+    bst.remove(1)
+    println("\nノード 1 を削除後、二分木は\n")
+    printTree(bst.getRoot())
+    bst.remove(2)
+    println("\nノード 2 を削除後、二分木は\n")
+    printTree(bst.getRoot())
+    bst.remove(4)
+    println("\nノード 4 を削除後、二分木は\n")
+    printTree(bst.getRoot())
+}

ja/codes/kotlin/chapter_tree/binary_tree.kt

@@ -0,0 +1,40 @@
+/**
+ * File: binary_tree.kt
+ * Created Time: 2024-01-25
+ * Author: curtishd (1023632660@qq.com)
+ */
+
+package chapter_tree
+
+import utils.TreeNode
+import utils.printTree
+
+/* Driver Code */
+fun main() {
+    /* 二分木を初期化 */
+    // ノードを初期化
+    val n1 = TreeNode(1)
+    val n2 = TreeNode(2)
+    val n3 = TreeNode(3)
+    val n4 = TreeNode(4)
+    val n5 = TreeNode(5)
+    // ノード間の参照（ポインタ）を構築する
+    n1.left = n2
+    n1.right = n3
+    n2.left = n4
+    n2.right = n5
+    println("\n二分木を初期化\n")
+    printTree(n1)
+
+    /* ノードの挿入と削除 */
+    val P = TreeNode(0)
+    // n1 -> n2 の間にノード P を挿入
+    n1.left = P
+    P.left = n2
+    println("\nノード P を挿入後\n")
+    printTree(n1)
+    // ノード P を削除
+    n1.left = n2
+    println("\nノード P を削除後\n")
+    printTree(n1)
+}

ja/codes/kotlin/chapter_tree/binary_tree_bfs.kt

@@ -0,0 +1,42 @@
+/**
+ * File: binary_tree_bfs.kt
+ * Created Time: 2024-01-25
+ * Author: curtishd (1023632660@qq.com)
+ */
+
+package chapter_tree
+
+import utils.TreeNode
+import utils.printTree
+import java.util.*
+
+/* レベル順走査 */
+fun levelOrder(root: TreeNode?): MutableList<Int> {
+    // キューを初期化し、ルートノードを追加する
+    val queue = LinkedList<TreeNode?>()
+    queue.add(root)
+    // 走査順序を保存するためのリストを初期化する
+    val list = mutableListOf<Int>()
+    while (queue.isNotEmpty()) {
+        val node = queue.poll()      // デキュー
+        list.add(node?._val!!)       // ノードの値を保存する
+        if (node.left != null)
+            queue.offer(node.left)   // 左子ノードをキューに追加
+        if (node.right != null)
+            queue.offer(node.right)  // 右子ノードをキューに追加
+    }
+    return list
+}
+
+/* Driver Code */
+fun main() {
+    /* 二分木を初期化 */
+    // ここではリストから直接二分木を生成する関数を利用する
+    val root = TreeNode.listToTree(mutableListOf(1, 2, 3, 4, 5, 6, 7))
+    println("\n二分木を初期化\n")
+    printTree(root)
+
+    /* レベル順走査 */
+    val list = levelOrder(root)
+    println("\nレベル順走査のノード出力順 = $list")
+}

ja/codes/kotlin/chapter_tree/binary_tree_dfs.kt

@@ -0,0 +1,64 @@
+/**
+ * File: binary_tree_dfs.kt
+ * Created Time: 2024-01-25
+ * Author: curtishd (1023632660@qq.com)
+ */
+
+package chapter_tree
+
+import utils.TreeNode
+import utils.printTree
+
+// 走査順序を格納するリストを初期化
+var list = mutableListOf<Int>()
+
+/* 先行順走査 */
+fun preOrder(root: TreeNode?) {
+    if (root == null) return
+    // 訪問順序：根ノード -> 左部分木 -> 右部分木
+    list.add(root._val)
+    preOrder(root.left)
+    preOrder(root.right)
+}
+
+/* 中順走査 */
+fun inOrder(root: TreeNode?) {
+    if (root == null) return
+    // 訪問優先順: 左部分木 -> 根ノード -> 右部分木
+    inOrder(root.left)
+    list.add(root._val)
+    inOrder(root.right)
+}
+
+/* 後順走査 */
+fun postOrder(root: TreeNode?) {
+    if (root == null) return
+    // 訪問優先順: 左部分木 -> 右部分木 -> 根ノード
+    postOrder(root.left)
+    postOrder(root.right)
+    list.add(root._val)
+}
+
+/* Driver Code */
+fun main() {
+    /* 二分木を初期化 */
+    // ここではリストから直接二分木を生成する関数を利用する
+    val root = TreeNode.listToTree(mutableListOf(1, 2, 3, 4, 5, 6, 7))
+    println("\n二分木を初期化\n")
+    printTree(root)
+
+    /* 先行順走査 */
+    list.clear()
+    preOrder(root)
+    println("\n先行順走査のノード出力順 = $list")
+
+    /* 中順走査 */
+    list.clear()
+    inOrder(root)
+    println("\n中間順走査のノード出力順 = $list")
+
+    /* 後順走査 */
+    list.clear()
+    postOrder(root)
+    println("\n後行順走査のノード出力順 = $list")
+}