From 4df120183f61c6639ea73182c829680d772d43ca Mon Sep 17 00:00:00 2001
From: Jihyun Son <sonjh1217@naver.com>
Date: Mon, 29 Sep 2025 12:03:43 +0900
Subject: [PATCH 1/3] solve

---
 missing-number/sonjh1217.swift | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 missing-number/sonjh1217.swift

diff --git a/missing-number/sonjh1217.swift b/missing-number/sonjh1217.swift
new file mode 100644
index 000000000..816dd8d16
--- /dev/null
+++ b/missing-number/sonjh1217.swift
@@ -0,0 +1,9 @@
+class Solution {
+    // O(n) time / O(1) space
+    func missingNumber(_ nums: [Int]) -> Int {
+        let count = nums.count
+        var expectedSum = count * (count + 1) / 2
+        let actualSum = nums.reduce(0, +)
+        return expectedSum - actualSum
+    }
+}

From 750a4c985b96acbe0553515b904d467fb0841f4a Mon Sep 17 00:00:00 2001
From: Jihyun Son <sonjh1217@naver.com>
Date: Thu, 2 Oct 2025 14:09:21 +0900
Subject: [PATCH 2/3] solve

---
 reorder-list/sonjh1217.swift | 97 ++++++++++++++++++++++++++++++++++++
 1 file changed, 97 insertions(+)
 create mode 100644 reorder-list/sonjh1217.swift

diff --git a/reorder-list/sonjh1217.swift b/reorder-list/sonjh1217.swift
new file mode 100644
index 000000000..c1e3833a5
--- /dev/null
+++ b/reorder-list/sonjh1217.swift
@@ -0,0 +1,97 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    // O(n) time / O(n) space
+    func reorderListUsingArray(_ head: ListNode?) {
+        var nodes = [ListNode]()
+        var node = head
+        while node != nil {
+            nodes.append(node!)
+            node = node!.next
+        }
+        
+        node = head
+        var fromFirstIndex = 1
+        var fromLastIndex = nodes.count - 1
+        
+        while fromFirstIndex <= fromLastIndex {
+            guard node != nil, nodes.last != nil else {
+                break
+            }
+            node!.next = nodes.removeLast()
+            node = node!.next
+            
+            guard fromFirstIndex < fromLastIndex else {
+                break
+            }
+            
+            fromLastIndex -= 1
+            node!.next = nodes[fromFirstIndex]
+            fromFirstIndex += 1
+            node = node!.next
+        }
+        
+        node?.next = nil
+    }
+    
+    // O(n) time / O(1) space
+    func reorderList(_ head: ListNode?) {
+        func findMiddle(_ head: ListNode?) -> ListNode? {
+            var slow = head
+            var fast = head
+            
+            while fast?.next?.next != nil {
+                slow = slow?.next
+                fast = fast?.next?.next
+            }
+            
+            return slow
+        }
+        
+        var mid = findMiddle(head)
+        
+        func reverseList(_ head: ListNode?) -> ListNode? {
+            var prev: ListNode? = nil
+            var curr: ListNode? = head
+            var next: ListNode? = curr?.next
+            
+            while curr != nil {
+                curr?.next = prev
+
+                prev = curr
+                curr = next
+                next = next?.next
+            }
+            
+            return prev
+        }
+        
+        let reversedToMid = reverseList(mid?.next)
+        mid?.next = nil
+        
+        func mergeList(first: ListNode?, second: ListNode?) {
+            var first = first
+            var second = second
+            
+            while first != nil {
+                let firstTmp = first?.next
+                first?.next = second
+                let secondTmp = second?.next
+                second?.next = firstTmp
+                
+                first = firstTmp
+                second = secondTmp
+            }
+        }
+        
+        mergeList(first: head, second: reversedToMid)
+    }
+}

From 067d26caf99de2505920d621307de82cdc3a82f9 Mon Sep 17 00:00:00 2001
From: Jihyun Son <sonjh1217@naver.com>
Date: Fri, 3 Oct 2025 15:23:04 +0900
Subject: [PATCH 3/3] solve

---
 graph-valid-tree/sonjh1217.swift | 36 ++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 graph-valid-tree/sonjh1217.swift

diff --git a/graph-valid-tree/sonjh1217.swift b/graph-valid-tree/sonjh1217.swift
new file mode 100644
index 000000000..650620834
--- /dev/null
+++ b/graph-valid-tree/sonjh1217.swift
@@ -0,0 +1,36 @@
+import Foundation
+
+class Solution {
+    // O(n) time / O(n) space
+    func validTree(_ n: Int, _ edges: [[Int]]) -> Bool {
+        guard edges.count == n - 1 else {
+            return false
+        }
+        
+        var connectedNodes = Array(repeating: [Int](), count: n)
+                
+        for edge in edges {
+            connectedNodes[edge[0]].append(edge[1])
+            connectedNodes[edge[1]].append(edge[0])
+        }
+        
+        var isVisiteds = Array(repeating: false, count: n)
+        var head = 0
+        var queue = [0]
+        isVisiteds[0] = true
+        
+        while head < queue.count {
+            let currentNode = queue[head]
+            head += 1
+            
+            for node in connectedNodes[currentNode] {
+                guard !isVisiteds[node] else { continue }
+                
+                isVisiteds[node] = true
+                queue.append(node)
+            }
+        }
+        
+        return isVisiteds.allSatisfy { $0 }
+    }
+}