10주차

Author: jdalma

invert-binary-tree/jdalma.kt

@@ -0,0 +1,58 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+class `invert-binary-tree` {
+
+    fun invertTree(root: TreeNode?): TreeNode? {
+        if (root == null) return null
+
+        return usingStack(root)
+    }
+
+    /**
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingDFS(node: TreeNode?): TreeNode? {
+        if (node == null) return null
+
+        val (left, right) = node.left to node.right
+        node.left = usingDFS(right)
+        node.right = usingDFS(left)
+
+        return node
+    }
+
+    /**
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingStack(node: TreeNode): TreeNode {
+        val stack= ArrayDeque<TreeNode>().apply {
+            this.add(node)
+        }
+
+        while (stack.isNotEmpty()) {
+            val now = stack.removeLast()
+            val tmp = now.left
+            now.left = now.right
+            now.right = tmp
+
+            now.left?.let { stack.add(it) }
+            now.right?.let { stack.add(it) }
+        }
+        return node
+    }
+
+    @Test
+    fun `전달된 노드의 하위 노드들의 반전된 값을 반환한다`() {
+        val actual = TreeNode.of(4,2,7,1,3,6,9)
+        val expect = TreeNode.of(4,7,2,9,6,3,1)
+        invertTree(actual) shouldBe expect
+
+        val actual1 = TreeNode.of(1,2)
+        val expect1 = TreeNode.of(1,null,2)
+
+        invertTree(actual1) shouldBe expect1
+    }
+}

search-in-rotated-sorted-array/jdalma.kt

@@ -0,0 +1,50 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+class `search-in-rotated-sorted-array` {
+
+    /**
+     * O(log n)만큼의 시간만으로 해결해야 한다.
+     * nums 배열은 정렬되어있지만 순환된 배열이므로 target 을 찾기 위한 일반적인 이분 탐색으로는 해결할 수 없다.
+     * TC: O(log n), SC: O(1)
+     */
+    fun search(nums: IntArray, target: Int): Int {
+        var (low, high) = 0 to nums.size - 1
+
+        while (low + 1 < high) {
+            val mid = (low + high) / 2
+
+            if (nums[mid] == target) {
+                return mid
+            }
+            if (nums[low] <= nums[mid]) {
+                if (target in nums[low] .. nums[mid]) {
+                    high = mid
+                } else {
+                    low = mid
+                }
+            } else {
+                if (target in nums[mid] .. nums[high]) {
+                    low = mid
+                } else {
+                    high = mid
+                }
+            }
+        }
+        return when (target) {
+            nums[low] -> low
+            nums[high] -> high
+            else -> -1
+        }
+    }
+
+    @Test
+    fun `배열에서 타겟의 인덱스를 반환한다`() {
+        search(intArrayOf(4,5,6,7,0,1,2), 0) shouldBe 4
+        search(intArrayOf(4,5,6,7,0,1,2), 3) shouldBe -1
+        search(intArrayOf(2,3,4,5,6,0,1), 1) shouldBe 6
+        search(intArrayOf(1,2,3,4,5,6,7), 6) shouldBe 5
+    }
+}