Kotlin - Chapter 17: Sort and Search

* Dutch National Flag
* Kth Largest Integer
* Counting Sort
* Quick Sort
* Quick Sort [Optimized]
* Sort Linked List

Author: marttp

kotlin/Sort and Search/DutchNationalFlag.kt

@@ -0,0 +1,19 @@
+fun dutchNationalFlag(nums: MutableList<Int>) {
+    var i = 0
+    var left = 0
+    var right = nums.size - 1
+    while (i <= right) {
+        // Swap 0s with the element at the left pointer.
+        if (nums[i] == 0) {
+            nums[i] = nums[left].also { nums[left] = nums[i] }
+            left++
+            i++
+        // Swap 2s with the element at the right pointer.
+        } else if (nums[i] == 2) {
+            nums[i] = nums[right].also { nums[right] = nums[i] }
+            right--
+        } else {
+            i++
+        }
+    }
+}

kotlin/Sort and Search/KthLargestIntegerMinHeap.kt

@@ -0,0 +1,17 @@
+import java.util.PriorityQueue
+
+fun kthLargestIntegerMinHeap(nums: List<Int>, k: Int): Int {
+    val minHeap = PriorityQueue<Int>()
+    for (num in nums) {
+        // Ensure the heap has at least 'k' integers.
+        if (minHeap.size < k) {
+            minHeap.offer(num)
+        // If 'num' is greater than the smallest integer in the heap, poll
+        // off this smallest integer from the heap and offer 'num'.
+        } else if (num > minHeap.peek()) {
+            minHeap.poll()
+            minHeap.offer(num)
+        }
+    }
+    return minHeap.peek()
+}

kotlin/Sort and Search/KthLargestIntegerQuickselect.kt

@@ -0,0 +1,40 @@
+fun kthLargestIntegerQuickselect(nums: List<Int>, k: Int): Int {
+    return quickselect(nums.toMutableList(), 0, nums.size - 1, k)
+}
+
+fun quickselect(nums: MutableList<Int>, left: Int, right: Int, k: Int): Int {
+    val n = nums.size
+    if (left >= right) {
+        return nums[left]
+    }
+    val randomIndex = (left..right).random()
+    nums[randomIndex] = nums[right].also { nums[right] = nums[randomIndex] }
+    val pivotIndex = partition(nums, left, right)
+    // If the pivot comes before 'n - k', the ('n - k')th smallest
+    // integer is somewhere to its right. Perform quickselect on the
+    // right part.
+    if (pivotIndex < n - k) {
+        return quickselect(nums, pivotIndex + 1, right, k)
+    // If the pivot comes after 'n - k', the ('n - k')th smallest integer
+    // is somewhere to its left. Perform quickselect on the left part.
+    } else if (pivotIndex > n - k) {
+        return quickselect(nums, left, pivotIndex - 1, k)
+    // If the pivot is at index 'n - k', it's the ('n - k')th smallest
+    // integer.
+    } else {
+        return nums[pivotIndex]
+    }
+}
+
+fun partition(nums: MutableList<Int>, left: Int, right: Int): Int {
+    val pivot = nums[right]
+    var lo = left
+    for (i in left until right) {
+        if (nums[i] < pivot) {
+            nums[lo] = nums[i].also { nums[i] = nums[lo] }
+            lo++
+        }
+    }
+    nums[lo] = nums[right].also { nums[right] = nums[lo] }
+    return lo
+}

kotlin/Sort and Search/SortArrayCountingSort.kt

@@ -0,0 +1,17 @@
+fun sortArrayCountingSort(nums: List<Int>): List<Int> {
+    if (nums.isEmpty()) return emptyList()
+    val res = mutableListOf<Int>()
+    // Count occurrences of each element in 'nums'.
+    val counts = IntArray(nums.maxOrNull()!! + 1)
+    for (num in nums) {
+        counts[num]++
+    }
+    // Build the sorted array by appending each index 'i' to it a total
+    // of 'counts[i]' times.
+    for (i in counts.indices) {
+        val count = counts[i]
+        repeat(count) { res.add(i) }
+    }
+    // counts.forEachIndexed { i, count -> repeat(count) { res.add(i) } }
+    return res
+}

kotlin/Sort and Search/SortArrayQuicksort.kt

@@ -0,0 +1,36 @@
+fun sortArray(nums: List<Int>): List<Int> {
+    quicksort(nums.toMutableList(), 0, nums.size - 1)
+    return nums
+}
+
+fun quicksort(nums: MutableList<Int>, left: Int, right: Int) {
+    // Base case: if the subarray has 0 or 1 element, it's already
+    // sorted.
+    if (left >= right) {
+        return
+    }
+    // Partition the array and retrieve the pivot index.
+    val pivotIndex = partition(nums, left, right)
+    // Call quicksort on the left and right parts to recursively sort
+    // them.
+    quicksort(nums, left, pivotIndex - 1)
+    quicksort(nums, pivotIndex + 1, right)
+}
+
+fun partition(nums: MutableList<Int>, left: Int, right: Int): Int {
+    val pivot = nums[right]
+    var lo = left
+    // Move all numbers less than the pivot to the left, which
+    // consequently positions all numbers greater than or equal to the
+    // pivot to the right.
+    for (i in left until right) {
+        if (nums[i] < pivot) {
+            nums[lo] = nums[i].also { nums[i] = nums[lo] }
+            lo++
+        }
+    }
+    // After partitioning, 'lo' will be positioned where the pivot should
+    // be. So, swap the pivot number with the number at the 'lo' pointer.
+    nums[lo] = nums[right].also { nums[right] = nums[lo] }
+    return lo
+}

kotlin/Sort and Search/SortArrayQuicksortOptimized.kt

@@ -0,0 +1,36 @@
+fun sortArray(nums: List<Int>): List<Int> {
+    quicksortOptimized(nums.toMutableList(), 0, nums.size - 1)
+    return nums
+}
+
+fun quicksortOptimized(nums: MutableList<Int>, left: Int, right: Int) {
+    if (left >= right) {
+        return
+    }
+    // Choose a pivot at a random index.
+    val randomIndex = (left..right).random()
+    // Swap the randomly chosen pivot with the rightmost element to
+    // position the pivot at the rightmost index.
+    nums[right] = nums[randomIndex].also { nums[randomIndex] = nums[right] }
+    val pivotIndex = partition(nums, left, right)
+    quicksortOptimized(nums, left, pivotIndex - 1)
+    quicksortOptimized(nums, pivotIndex + 1, right)
+}
+
+fun partition(nums: MutableList<Int>, left: Int, right: Int): Int {
+    val pivot = nums[right]
+    var lo = left
+    // Move all numbers less than the pivot to the left, which
+    // consequently positions all numbers greater than or equal to the
+    // pivot to the right.
+    for (i in left until right) {
+        if (nums[i] < pivot) {
+            nums[lo] = nums[i].also { nums[i] = nums[lo] }
+            lo++
+        }
+    }
+    // After partitioning, 'lo' will be positioned where the pivot should
+    // be. So, swap the pivot number with the number at the 'lo' pointer.
+    nums[lo] = nums[right].also { nums[right] = nums[lo] }
+    return lo
+}

kotlin/Sort and Search/SortLinkedList.kt

@@ -0,0 +1,60 @@
+import ds.ListNode
+
+/*
+    Definition of ListNode:
+    data class ListNode(var value: Int = 0, var next: ListNode? = null)
+*/
+
+fun sortLinkedList(head: ListNode?): ListNode? {
+    // If the linked list is empty or has only one element, it's already
+    // sorted.
+    if (head == null || head.next == null) {
+        return head
+    }
+    // Split the linked list into halves using the fast and slow pointer
+    // technique.
+    val secondHead = splitList(head)
+    // Recursively sort both halves.
+    val firstHalfSorted = sortLinkedList(head)
+    val secondHalfSorted = sortLinkedList(secondHead)
+    // Merge the sorted sublists.
+    return merge(firstHalfSorted, secondHalfSorted)
+}
+
+fun splitList(head: ListNode): ListNode {
+    var slow = head
+    var fast = head
+    while (fast.next != null && fast.next!!.next != null) {
+        slow = slow.next!!
+        fast = fast.next!!.next!!
+    }
+    val secondHead = slow.next
+    slow.next = null
+    return secondHead!!
+}
+
+fun merge(l1: ListNode?, l2: ListNode?): ListNode? {
+    val dummy = ListNode()
+    // This pointer will be used to append nodes to the tail of the
+    // merged linked list.
+    var tail = dummy
+    var list1 = l1
+    var list2 = l2
+    // Continually append the node with the smaller value from each
+    // linked list to the merged linked list until one of the linked
+    // lists has no more nodes to merge.
+    while (list1 != null && list2 != null) {
+        if (list1.value < list2.value) {
+            tail.next = list1
+            list1 = list1.next
+        } else {
+            tail.next = list2
+            list2 = list2.next
+        }
+        tail = tail.next!!
+    }
+    // One of the two linked lists could still have nodes remaining.
+    // Attach those nodes to the end of the merged linked list.
+    tail.next = list1 ?: list2
+    return dummy.next
+}