Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/swift/chapter_tree/array_binary_tree.swift

@@ -0,0 +1,141 @@
+/**
+ * File: array_binary_tree.swift
+ * Created Time: 2023-07-23
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+/* 配列表現による二分木クラス */
+class ArrayBinaryTree {
+    private var tree: [Int?]
+
+    /* コンストラクタ */
+    init(arr: [Int?]) {
+        tree = arr
+    }
+
+    /* リスト容量 */
+    func size() -> Int {
+        tree.count
+    }
+
+    /* インデックス i のノードの値を取得 */
+    func val(i: Int) -> Int? {
+        // インデックスが範囲外なら、空きを表す null を返す
+        if i < 0 || i >= size() {
+            return nil
+        }
+        return tree[i]
+    }
+
+    /* インデックス i のノードの左子ノードのインデックスを取得 */
+    func left(i: Int) -> Int {
+        2 * i + 1
+    }
+
+    /* インデックス i のノードの右子ノードのインデックスを取得 */
+    func right(i: Int) -> Int {
+        2 * i + 2
+    }
+
+    /* インデックス i のノードの親ノードのインデックスを取得 */
+    func parent(i: Int) -> Int {
+        (i - 1) / 2
+    }
+
+    /* レベル順走査 */
+    func levelOrder() -> [Int] {
+        var res: [Int] = []
+        // 配列を直接走査する
+        for i in 0 ..< size() {
+            if let val = val(i: i) {
+                res.append(val)
+            }
+        }
+        return res
+    }
+
+    /* 深さ優先探索 */
+    private func dfs(i: Int, order: String, res: inout [Int]) {
+        // 空きスロットなら返す
+        guard let val = val(i: i) else {
+            return
+        }
+        // 先行順走査
+        if order == "pre" {
+            res.append(val)
+        }
+        dfs(i: left(i: i), order: order, res: &res)
+        // 中順走査
+        if order == "in" {
+            res.append(val)
+        }
+        dfs(i: right(i: i), order: order, res: &res)
+        // 後順走査
+        if order == "post" {
+            res.append(val)
+        }
+    }
+
+    /* 先行順走査 */
+    func preOrder() -> [Int] {
+        var res: [Int] = []
+        dfs(i: 0, order: "pre", res: &res)
+        return res
+    }
+
+    /* 中順走査 */
+    func inOrder() -> [Int] {
+        var res: [Int] = []
+        dfs(i: 0, order: "in", res: &res)
+        return res
+    }
+
+    /* 後順走査 */
+    func postOrder() -> [Int] {
+        var res: [Int] = []
+        dfs(i: 0, order: "post", res: &res)
+        return res
+    }
+}
+
+@main
+enum _ArrayBinaryTree {
+    /* Driver Code */
+    static func main() {
+        // 二分木を初期化
+        // ここでは、配列から直接二分木を生成する関数を利用する
+        let arr = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]
+
+        let root = TreeNode.listToTree(arr: arr)
+        print("\n二分木を初期化\n")
+        print("二分木の配列表現：")
+        print(arr)
+        print("二分木の連結リスト表現：")
+        PrintUtil.printTree(root: root)
+
+        // 配列表現による二分木クラス
+        let abt = ArrayBinaryTree(arr: arr)
+
+        // ノードにアクセス
+        let i = 1
+        let l = abt.left(i: i)
+        let r = abt.right(i: i)
+        let p = abt.parent(i: i)
+        print("\n現在のノードのインデックスは \(i) 、値は \(abt.val(i: i) as Any)")
+        print("左の子ノードのインデックスは \(l) 、値は \(abt.val(i: l) as Any)")
+        print("右の子ノードのインデックスは \(r) 、値は \(abt.val(i: r) as Any)")
+        print("親ノードのインデックスは \(p) 、値は \(abt.val(i: p) as Any)")
+
+        // 木を走査
+        var res = abt.levelOrder()
+        print("\nレベル順走査：\(res)")
+        res = abt.preOrder()
+        print("先行順走査：\(res)")
+        res = abt.inOrder()
+        print("中間順走査：\(res)")
+        res = abt.postOrder()
+        print("後順走査は：\(res)")
+    }
+}

ja/codes/swift/chapter_tree/avl_tree.swift

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

ja/codes/swift/chapter_tree/binary_search_tree.swift

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

ja/codes/swift/chapter_tree/binary_tree.swift

@@ -0,0 +1,40 @@
+/**
+ * File: binary_tree.swift
+ * Created Time: 2023-01-18
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+@main
+enum BinaryTree {
+    /* Driver Code */
+    static func main() {
+        /* 二分木を初期化 */
+        // ノードを初期化
+        let n1 = TreeNode(x: 1)
+        let n2 = TreeNode(x: 2)
+        let n3 = TreeNode(x: 3)
+        let n4 = TreeNode(x: 4)
+        let n5 = TreeNode(x: 5)
+        // ノード間の参照（ポインタ）を構築する
+        n1.left = n2
+        n1.right = n3
+        n2.left = n4
+        n2.right = n5
+        print("\n二分木を初期化\n")
+        PrintUtil.printTree(root: n1)
+
+        /* ノードの挿入と削除 */
+        let P = TreeNode(x: 0)
+        // n1 -> n2 の間にノード P を挿入
+        n1.left = P
+        P.left = n2
+        print("\nノード P を挿入後\n")
+        PrintUtil.printTree(root: n1)
+        // ノード P を削除
+        n1.left = n2
+        print("\nノード P を削除後\n")
+        PrintUtil.printTree(root: n1)
+    }
+}

ja/codes/swift/chapter_tree/binary_tree_bfs.swift

@@ -0,0 +1,42 @@
+/**
+ * File: binary_tree_bfs.swift
+ * Created Time: 2023-01-18
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+/* レベル順走査 */
+func levelOrder(root: TreeNode) -> [Int] {
+    // キューを初期化し、ルートノードを追加する
+    var queue: [TreeNode] = [root]
+    // 走査順序を保存するためのリストを初期化する
+    var list: [Int] = []
+    while !queue.isEmpty {
+        let node = queue.removeFirst() // デキュー
+        list.append(node.val) // ノードの値を保存する
+        if let left = node.left {
+            queue.append(left) // 左子ノードをキューに追加
+        }
+        if let right = node.right {
+            queue.append(right) // 右子ノードをキューに追加
+        }
+    }
+    return list
+}
+
+@main
+enum BinaryTreeBFS {
+    /* Driver Code */
+    static func main() {
+        /* 二分木を初期化 */
+        // ここでは、配列から直接二分木を生成する関数を利用する
+        let node = TreeNode.listToTree(arr: [1, 2, 3, 4, 5, 6, 7])!
+        print("\n二分木を初期化\n")
+        PrintUtil.printTree(root: node)
+
+        /* レベル順走査 */
+        let list = levelOrder(root: node)
+        print("\nレベル順走査のノード出力シーケンス = \(list)")
+    }
+}

ja/codes/swift/chapter_tree/binary_tree_dfs.swift

@@ -0,0 +1,70 @@
+/**
+ * File: binary_tree_dfs.swift
+ * Created Time: 2023-01-18
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+// 走査順序を格納するリストを初期化
+var list: [Int] = []
+
+/* 先行順走査 */
+func preOrder(root: TreeNode?) {
+    guard let root = root else {
+        return
+    }
+    // 訪問順序：根ノード -> 左部分木 -> 右部分木
+    list.append(root.val)
+    preOrder(root: root.left)
+    preOrder(root: root.right)
+}
+
+/* 中順走査 */
+func inOrder(root: TreeNode?) {
+    guard let root = root else {
+        return
+    }
+    // 訪問優先順: 左部分木 -> 根ノード -> 右部分木
+    inOrder(root: root.left)
+    list.append(root.val)
+    inOrder(root: root.right)
+}
+
+/* 後順走査 */
+func postOrder(root: TreeNode?) {
+    guard let root = root else {
+        return
+    }
+    // 訪問優先順: 左部分木 -> 右部分木 -> 根ノード
+    postOrder(root: root.left)
+    postOrder(root: root.right)
+    list.append(root.val)
+}
+
+@main
+enum BinaryTreeDFS {
+    /* Driver Code */
+    static func main() {
+        /* 二分木を初期化 */
+        // ここでは、配列から直接二分木を生成する関数を利用する
+        let root = TreeNode.listToTree(arr: [1, 2, 3, 4, 5, 6, 7])!
+        print("\n二分木を初期化\n")
+        PrintUtil.printTree(root: root)
+
+        /* 先行順走査 */
+        list.removeAll()
+        preOrder(root: root)
+        print("\n前順走査のノード出力シーケンス = \(list)")
+
+        /* 中順走査 */
+        list.removeAll()
+        inOrder(root: root)
+        print("\n中順走査のノード出力シーケンス = \(list)")
+
+        /* 後順走査 */
+        list.removeAll()
+        postOrder(root: root)
+        print("\n後順走査のノード出力シーケンス = \(list)")
+    }
+}