Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/swift/utils/ListNode.swift

@@ -0,0 +1,33 @@
+/**
+ * File: ListNode.swift
+ * Created Time: 2023-01-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+public class ListNode: Hashable {
+    public var val: Int // ノード値
+    public var next: ListNode? // 後続ノードへの参照
+
+    public init(x: Int) {
+        val = x
+    }
+
+    public static func == (lhs: ListNode, rhs: ListNode) -> Bool {
+        lhs.val == rhs.val && lhs.next.map { ObjectIdentifier($0) } == rhs.next.map { ObjectIdentifier($0) }
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(val)
+        hasher.combine(next.map { ObjectIdentifier($0) })
+    }
+
+    public static func arrToLinkedList(arr: [Int]) -> ListNode? {
+        let dum = ListNode(x: 0)
+        var head: ListNode? = dum
+        for val in arr {
+            head?.next = ListNode(x: val)
+            head = head?.next
+        }
+        return dum.next
+    }
+}

ja/codes/swift/utils/Pair.swift

@@ -0,0 +1,20 @@
+/**
+ * File: Pair.swift
+ * Created Time: 2023-06-28
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* キーと値の組 */
+public class Pair: Equatable {
+    public var key: Int
+    public var val: String
+
+    public init(key: Int, val: String) {
+        self.key = key
+        self.val = val
+    }
+
+    public static func == (lhs: Pair, rhs: Pair) -> Bool {
+        lhs.key == rhs.key && lhs.val == rhs.val
+    }
+}

ja/codes/swift/utils/PrintUtil.swift

@@ -0,0 +1,93 @@
+/**
+ * File: PrintUtil.swift
+ * Created Time: 2023-01-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+public enum PrintUtil {
+    private class Trunk {
+        var prev: Trunk?
+        var str: String
+
+        init(prev: Trunk?, str: String) {
+            self.prev = prev
+            self.str = str
+        }
+    }
+
+    public static func printLinkedList(head: ListNode) {
+        var head: ListNode? = head
+        var list: [String] = []
+        while head != nil {
+            list.append("\(head!.val)")
+            head = head?.next
+        }
+        print(list.joined(separator: " -> "))
+    }
+
+    public static func printTree(root: TreeNode?) {
+        printTree(root: root, prev: nil, isRight: false)
+    }
+
+    private static func printTree(root: TreeNode?, prev: Trunk?, isRight: Bool) {
+        if root == nil {
+            return
+        }
+
+        var prevStr = "    "
+        let trunk = Trunk(prev: prev, str: prevStr)
+
+        printTree(root: root?.right, prev: trunk, isRight: true)
+
+        if prev == nil {
+            trunk.str = "———"
+        } else if isRight {
+            trunk.str = "/———"
+            prevStr = "   |"
+        } else {
+            trunk.str = "\\———"
+            prev?.str = prevStr
+        }
+
+        showTrunks(p: trunk)
+        print(" \(root!.val)")
+
+        if prev != nil {
+            prev?.str = prevStr
+        }
+        trunk.str = "   |"
+
+        printTree(root: root?.left, prev: trunk, isRight: false)
+    }
+
+    private static func showTrunks(p: Trunk?) {
+        if p == nil {
+            return
+        }
+
+        showTrunks(p: p?.prev)
+        print(p!.str, terminator: "")
+    }
+
+    public static func printHashMap<K, V>(map: [K: V]) {
+        for (key, value) in map {
+            print("\(key) -> \(value)")
+        }
+    }
+
+    public static func printHeap(queue: [Int]) {
+        print("ヒープの配列表現：", terminator: "")
+        print(queue)
+        print("ヒープの木構造表現：")
+        let root = TreeNode.listToTree(arr: queue)
+        printTree(root: root)
+    }
+
+    public static func printMatrix<T>(matrix: [[T]]) {
+        print("[")
+        for row in matrix {
+            print("  \(row),")
+        }
+        print("]")
+    }
+}

ja/codes/swift/utils/TreeNode.swift

@@ -0,0 +1,71 @@
+/**
+ * File: TreeNode.swift
+ * Created Time: 2023-01-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* 二分木ノードクラス */
+public class TreeNode {
+    public var val: Int // ノード値
+    public var height: Int // ノードの高さ
+    public var left: TreeNode? // 左子ノードへの参照
+    public var right: TreeNode? // 右子ノードへの参照
+
+    /* コンストラクタ */
+    public init(x: Int) {
+        val = x
+        height = 0
+    }
+
+    // シリアライズの符号化規則は次を参照してください:
+    // https://www.hello-algo.com/chapter_tree/array_representation_of_tree/
+    // 二分木の配列表現:
+    // [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]
+    // 二分木の連結リスト表現:
+    // /——— 15
+    // /——— 7
+    // /——— 3
+    // |    \\——— 6
+    // |        \\——— 12
+    // ——— 1
+    // \\——— 2
+    // |    /——— 9
+    // \\——— 4
+    // \\——— 8
+
+    /* リストを二分木にデシリアライズする: 再帰 */
+    private static func listToTreeDFS(arr: [Int?], i: Int) -> TreeNode? {
+        if i < 0 || i >= arr.count || arr[i] == nil {
+            return nil
+        }
+        let root = TreeNode(x: arr[i]!)
+        root.left = listToTreeDFS(arr: arr, i: 2 * i + 1)
+        root.right = listToTreeDFS(arr: arr, i: 2 * i + 2)
+        return root
+    }
+
+    /* リストを二分木にデシリアライズする */
+    public static func listToTree(arr: [Int?]) -> TreeNode? {
+        listToTreeDFS(arr: arr, i: 0)
+    }
+
+    /* 二分木をリストにシリアライズする: 再帰 */
+    private static func treeToListDFS(root: TreeNode?, i: Int, res: inout [Int?]) {
+        if root == nil {
+            return
+        }
+        while i >= res.count {
+            res.append(nil)
+        }
+        res[i] = root?.val
+        treeToListDFS(root: root?.left, i: 2 * i + 1, res: &res)
+        treeToListDFS(root: root?.right, i: 2 * i + 2, res: &res)
+    }
+
+    /* 二分木をリストにシリアライズする */
+    public static func treeToList(root: TreeNode?) -> [Int?] {
+        var res: [Int?] = []
+        treeToListDFS(root: root, i: 0, res: &res)
+        return res
+    }
+}

ja/codes/swift/utils/Vertex.swift

@@ -0,0 +1,32 @@
+/**
+ * File: Vertex.swift
+ * Created Time: 2023-02-19
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* 頂点クラス */
+public class Vertex: Hashable {
+    public var val: Int
+
+    public init(val: Int) {
+        self.val = val
+    }
+
+    public static func == (lhs: Vertex, rhs: Vertex) -> Bool {
+        lhs.val == rhs.val
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(val)
+    }
+
+    /* 値リスト vals を入力し、頂点リスト vets を返す */
+    public static func valsToVets(vals: [Int]) -> [Vertex] {
+        vals.map { Vertex(val: $0) }
+    }
+
+    /* 頂点リスト vets を入力し、値リスト vals を返す */
+    public static func vetsToVals(vets: [Vertex]) -> [Int] {
+        vets.map { $0.val }
+    }
+}