Kotlin - Chapter 8: Heaps

* Combine Sorted Linked List
* K Most Frequent Strings (Min/Max Heap)
* Median of an Integer Stream
* Sort a K Sorted Array

Author: marttp

kotlin/Heaps/CombineSortedLinkedList.kt

@@ -0,0 +1,36 @@
+import java.util.PriorityQueue
+import ds.ListNode
+
+/*
+    Definition of ListNode:
+    data class ListNode(var value: Int, var next: ListNode? = null)
+*/
+
+fun combineSortedLinkedLists(lists: List<ListNode?>): ListNode? {
+    // Define a custom comparator for 'ListNode', enabling the min-heap
+    // to prioritize nodes with smaller values.
+    val heap = PriorityQueue<ListNode> { a, b -> a.value - b.value }
+    // Push the head of each linked list into the heap.
+    for (head in lists) {
+        if (head != null) {
+            heap.add(head)
+        }
+    }
+    // Set a dummy node to point to the head of the output linked list.
+    val dummy = ListNode(-1)
+    // Create a pointer to iterate through the combined linked list as
+    // we add nodes to it.
+    var curr = dummy
+    while (heap.isNotEmpty()) {
+        // Pop the node with the smallest value from the heap and add it
+        // to the output linked list.
+        val smallestNode = heap.poll()
+        curr.next = smallestNode
+        curr = curr.next!!
+        // Push the popped node's subsequent node to the heap.
+        if (smallestNode.next != null) {
+            heap.add(smallestNode.next)
+        }
+    }
+    return dummy.next
+}

kotlin/Heaps/KMostFrequentStringsMaxHeap.kt

@@ -0,0 +1,22 @@
+import java.util.PriorityQueue
+
+data class Pair(val str: String, val freq: Int)
+
+fun kMostFrequentStringsMaxHeap(strs: List<String>, k: Int): List<String> {
+    // We use 'groupingBy' to create a hash map that counts the frequency
+    // of each string.
+    val freqs = strs.groupingBy { it }.eachCount()
+    // Create the max heap by performing heapify on all string-frequency
+    val maxHeap =
+            PriorityQueue<Pair> { a, b -> // Define a custom comparator.
+                // Prioritize lexicographical order for strings with equal
+                // frequencies.
+                if (a.freq == b.freq) b.str.compareTo(a.str)
+                // Otherwise, prioritize strings with higher frequencies.
+                else b.freq.compareTo(a.freq)
+            }
+    maxHeap.addAll(freqs.map { Pair(it.key, it.value) })
+    // Pop the most frequent string off the heap 'k' times and return
+    // these 'k' most frequent strings.
+    return List(k) { maxHeap.poll().str }
+}

kotlin/Heaps/KMostFrequentStringsMinHeap.kt

@@ -0,0 +1,28 @@
+import java.util.PriorityQueue
+
+data class Pair(val str: String, val freq: Int)
+
+fun kMostFrequentStringsMinHeap(strs: List<String>, k: Int): List<String> {
+    val freqs = strs.groupingBy { it }.eachCount()
+    val minHeap =
+            PriorityQueue<Pair> { a, b ->
+                // Since this is a min-heap comparator, we can use the same
+                // comparator as the one used in the max-heap, but reversing the
+                // inequality signs to invert the priority.
+                if (a.freq == b.freq) a.str.compareTo(b.str) else a.freq.compareTo(b.freq)
+            }
+    for ((str, freq) in freqs) {
+        minHeap.add(Pair(str, freq))
+        // If heap size exceeds 'k', pop the lowest frequency string to
+        // ensure the heap only contains the 'k' most frequent words so
+        // far.
+        if (minHeap.size > k) {
+            minHeap.poll()
+        }
+    }
+    // Return the 'k' most frequent strings by popping the remaining 'k'
+    // strings from the heap. Since we're using a min-heap, we need to
+    // reverse the result after popping the elements to ensure the most
+    // frequent strings are listed first.
+    return List(k) { minHeap.poll().str }.reversed()
+}

kotlin/Heaps/MedianOfAnIntegerStream.kt

@@ -0,0 +1,34 @@
+import java.util.PriorityQueue
+
+class MedianOfAnIntegerStream {
+    private val leftHalf = PriorityQueue<Int>(reverseOrder()) // Max-heap
+    private val rightHalf = PriorityQueue<Int>() // Min-heap
+
+    fun add(num: Int) {
+        // If 'num' is less than or equal to the max of 'left_half', it
+        // belongs to the left half.
+        if (leftHalf.isEmpty() || num <= leftHalf.peek()) {
+            leftHalf.add(num)
+            // Rebalance the heaps if the size of the 'left_half'
+            // exceeds the size of the 'right_half' by more than one.
+            if (leftHalf.size > rightHalf.size + 1) {
+                rightHalf.add(leftHalf.poll())
+            }
+            // Otherwise, it belongs to the right half.
+        } else {
+            rightHalf.add(num)
+            // Rebalance the heaps if 'right_half' is larger than
+            // 'left_half'.
+            if (leftHalf.size < rightHalf.size) {
+                leftHalf.add(rightHalf.poll())
+            }
+        }
+    }
+
+    fun getMedian(): Double {
+        if (leftHalf.size == rightHalf.size) {
+            return (leftHalf.peek().toDouble() + rightHalf.peek().toDouble()) / 2.0
+        }
+        return leftHalf.peek().toDouble()
+    }
+}

kotlin/Heaps/SortAKSortedArray.kt

@@ -0,0 +1,22 @@
+import java.util.PriorityQueue
+
+fun sortAKSortedArray(nums: IntArray, k: Int): IntArray {
+    val nums = IntArray(nums.size)
+    // Populate a min-heap with the first k + 1 values in 'nums'.
+    val minHeap = PriorityQueue<Int>()
+    for (i in 0 until k + 1) {
+        minHeap.add(nums[i])
+    }
+    // Replace elements in the array with the minimum from the heap at each
+    // iteration.
+    var index = 0
+    for (i in k + 1 until nums.size) {
+        nums[index++] = minHeap.poll()
+        minHeap.add(nums[i])
+    }
+    // Pop the remaining elements from the heap to finish sorting the array.
+    while (minHeap.isNotEmpty()) {
+        nums[index++] = minHeap.poll()
+    }
+    return nums
+}