복잡도 정리 및 1주차 4번 문제 추가

Author: jdalma

contains-duplicate/jdalma.kt

@@ -10,6 +10,7 @@ class `contains-duplicate`{
     }
 
     // 시간초과
+    // 시간복잡도: O(n^2), 공간복잡도: O(1)
     private fun first(nums: IntArray): Boolean {
         nums.forEachIndexed { i, e1 ->
             nums.forEachIndexed { j, e2 ->
@@ -21,8 +22,9 @@ class `contains-duplicate`{
         return false
     }
 
+    // 시간복잡도:  O(n * log(n)), 공간복잡도: O(1)
     private fun second(nums: IntArray): Boolean {
-        nums.sort() // DualPivotQuicksort
+        nums.sort() // DualPivotQuicksort -> O(n log(n))
         for (index in 1 until nums.size) {
             val prev = nums[index - 1]
             val curr = nums[index]
@@ -33,6 +35,7 @@ class `contains-duplicate`{
         return false
     }
 
+    // 시간복잡도: O(n), 공간복잡도: O(n)
     private fun third(nums: IntArray): Boolean {
         val set = nums.toSet()
         return nums.size != set.size

kth-smallest-element-in-a-bst/jdalma.kt

@@ -0,0 +1,98 @@
+package leetcode_study
+
+import io.kotest.matchers.equals.shouldBeEqual
+import org.junit.jupiter.api.Test
+import java.util.PriorityQueue
+
+class `kth-smallest-element-in-a-bst` {
+
+    fun kthSmallest(root: TreeNode?, k: Int): Int {
+        return inorderTraversal(root, k)
+    }
+
+    // 1. 재귀 호출로 모든 트리를 조회 후 정렬
+    // 시간복잡도: O(n * log(n)), 공간복잡도: O(n)
+    private fun recursionAndSort(root: TreeNode?, k: Int) = mutableSetOf<Int>().apply {
+        dfs(root, this)
+    }.sorted()[k - 1]
+
+    private fun dfs(node: TreeNode?, set: MutableSet<Int>) {
+        if (node == null) return
+
+        set.add(node.`val`)
+        dfs(node.left, set)
+        dfs(node.right, set)
+    }
+
+    // 2. 재귀 호출로 모든 트리의 값을 우선순위 큐에 삽입하고 작은 값으로 계속 큐를 갱신
+    // 시간복잡도: O(n * log(k)), 공간복잡도: O(n + k)
+    // 트리 순회 : O(n), 우선순위 큐 삽입: O(log k)
+    private fun usingPriorityQueue(node: TreeNode?, k: Int): Int {
+        fun dfs(node: TreeNode, k: Int, pq: PriorityQueue<Int>) {
+            pq.offer(node.`val`)
+
+            if (pq.size > k) {
+                pq.poll()
+            }
+            if (node.left != null) {
+                dfs(node.left!!, k, pq)
+            }
+            if (node.right != null) {
+                dfs(node.right!!, k, pq)
+            }
+        }
+
+        val pq = PriorityQueue { v1: Int, v2: Int -> v2 - v1 }
+        dfs(node!!, k, pq)
+        return pq.first()
+    }
+
+    // 3. 문제의 전제가 이진탐색트리이기에, 중위순회로 탐색하여 값을 누적하면 오름차순의 값이 된다.
+    // 시간복잡도: O(n), 공간복잡도: O(n)
+    private fun inorderTraversal(node: TreeNode?, k: Int): Int {
+        fun dfs(node: TreeNode, k: Int, list: MutableList<Int>) {
+            if (node.left != null) {
+                dfs(node.left!!, k, list)
+            }
+            list.add(node.`val`)
+            if (node.right != null) {
+                dfs(node.right!!, k, list)
+            }
+        }
+
+        return mutableListOf<Int>().apply {
+            dfs(node!!, k, this)
+        }[k - 1]
+    }
+
+    @Test
+    fun `루트와 정수 k가 주어지면 트리에 있는 모든 노드의 값 중 가장 작은 값을 반환한다`() {
+        kthSmallest(TreeNode.of(listOf(0, 3,1,4,null,2)), 1) shouldBeEqual 1
+        kthSmallest(TreeNode.of(listOf(0, 5,3,6,2,4,null,null,1)), 3) shouldBeEqual 3
+    }
+}
+
+class TreeNode(var `val`: Int) {
+    var left: TreeNode? = null
+    var right: TreeNode? = null
+
+    companion object {
+        fun of(numbers: List<Int?>): TreeNode? {
+            fun setChild(node: TreeNode?, nums: List<Int?>, index: Int): TreeNode? {
+                if (node == null) return null
+                val (leftIndex, rightIndex) = index * 2 to index * 2 + 1
+
+                if (leftIndex < nums.size && nums[leftIndex] != null) {
+                    node.left = TreeNode(nums[leftIndex]!!)
+                    setChild(node.left, nums, leftIndex)
+                }
+                if (rightIndex < nums.size && nums[rightIndex] != null) {
+                    node.right = TreeNode(nums[rightIndex]!!)
+                    setChild(node.right, nums, rightIndex)
+                }
+                return node
+            }
+            return setChild(TreeNode(numbers[1]!!), numbers, 1)
+        }
+    }
+}

number-of-1-bits/jdalma.kt

@@ -9,6 +9,7 @@ class `number-of-1-bits` {
         return second(n)
     }
 
+    // 시간복잡도: O(log n), 공간복잡도: O(1)
     private fun first(n: Int): Int {
         var calc = n
         var count = 0
@@ -21,6 +22,7 @@ class `number-of-1-bits` {
         return count
     }
 
+    // 시간복잡도: O(log n), 공간복잡도: O(1)
     private fun second(n: Int): Int {
         var calc = n
         var count = 0

top-k-frequent-elements/jdalma.kt

@@ -11,6 +11,7 @@ class `top-k-frequent-elements` {
     }
 
     // Map 정렬
+    // 시간복잡도: O(n * log(n)), 공간복잡도: O(n)
     private fun first(nums: IntArray, k: Int): IntArray {
         val map = mutableMapOf<Int, Int>()
 
@@ -27,7 +28,8 @@ class `top-k-frequent-elements` {
             .toIntArray()
     }
 
-    // 우선순위 큐 사용
+    // 우선순위 큐
+    // 시간복잡도: O(n * log(k)), 공간복잡도: O(n + k)
     private fun second(nums: IntArray, k: Int): IntArray {
         val map = mutableMapOf<Int, Int>()
 
@@ -43,6 +45,7 @@ class `top-k-frequent-elements` {
     }
 
     // 이차원배열로 빈번도 저장
+    // 시간복잡도: O(n), 공간복잡도: O(n)
     private fun third(nums: IntArray, k: Int): IntArray {
         val map = mutableMapOf<Int, Int>()
 
@@ -74,5 +77,6 @@ class `top-k-frequent-elements` {
         topKFrequent(intArrayOf(1,1,1,2,2,3,3,4), 3) shouldBe intArrayOf(1,2,3)
         topKFrequent(intArrayOf(2,2,3,3,1,1,4), 3) shouldBe intArrayOf(2,3,1)
         topKFrequent(intArrayOf(4,1,-1,2,-1,2,3), 2) shouldBe intArrayOf(-1,2)
+
     }
 }