Kth Smallest Element in Unsorted Array

(referrence: GeeksforGeeks, Kth Largest Element in Array)

This is a common algorithm problem appearing in interviews.

There are four basic solutions.

Solution 1 -- Sort First

A Simple Solution is to sort the given array using a O(n log n) sorting algorithm like Merge Sort,Heap Sort, etc and return the element at index k-1 in the sorted array. Time Complexity of this solution is O(n log n).

Java Arrays.sort()

public class Solution{
    public int findKthSmallest(int[] nums, int k) {
        Arrays.sort(nums);
        return nums[k];
    }
}

Solution 2 -- Construct Min Heap

A simple optomization is to create a Min Heap of the given n elements and call extractMin() k times.

To build a heap, time complexity is O(n). So total time complexity is O(n + k log n).

Java Priority Queue

Using PriorityQueue(Collection<? extends E> c), we can construct a heap from array or other object in linear time.

By defaule, it will create a min-heap.

Example

public int generateHeap(int[] nums) {
        int length = nums.length;
        Integer[] newArray = new Integer[length];
        for (int i = 0; i < length; i++)
            newArray[i] = (Integer)nums[i];
        PriorityQueue<Integer> pq = new PriorityQueue<Integer>(Arrays.asList(newArray));
    }

Comparator example

Comparator cmp = Colletions.reverseOrder();

 

Solution 3 -- Use Max Heap

1. Build a max-heap of size k. Put nums[0] to nums[k - 1] to heap.

2. For each element after nums[k - 1], compare it with root of heap.

　　a. If current >= root, move on.

　　b. If current <  root, remove root, put current into heap.

3. Return root.

Time complexity is O((n - k) log k).

(Java: PriorityQueue)

(codes)

public class Solution {
    public int findKthSmallest(int[] nums, int k) {
        // Construct a max heap of size k
        int length = nums.length;
        PriorityQueue<Integer> pq = new PriorityQueue<Integer>(k, Collections.reverseOrder());
        for (int i = 0; i < k; i++)
            pq.add(nums[i]);
        for (int i = k; i < length; i++) {
            int current = nums[i];
            int root = pq.peek();
            if (current < root) {
                // Remove head
                pq.poll();
                // Add new node
                pq.add(current);
            }
        }
        return pq.peek();
    }
}

Solution 4 -- Quick Select

public class Solution {
    private void swap(int[] nums, int index1, int index2) {
        int tmp = nums[index1];
        nums[index1] = nums[index2];
        nums[index2] = tmp;
    }

    // Pick last element as pivot
    // Place all smaller elements before pivot
    // Place all bigger elements after pivot
    private int partition(int[] nums, int start, int end) {
        int pivot = nums[end];
        int currentSmaller = start - 1;
        for (int i = start; i < end; i++) {
            // If current element <= pivot, put it to right position
            if (nums[i] <= pivot) {
                currentSmaller++;
                swap(nums, i, currentSmaller);
            }
        }
        // Put pivot to right position
        currentSmaller++;
        swap(nums, end, currentSmaller);
        return currentSmaller;
    }

    public int quickSelect(int[] nums, int start, int end, int k) {
        int pos = partition(nums, start, end)
        if (pos == k - 1)
            return nums[pos];
        if (pos < k - 1)
            return quickSelect(nums, pos + 1, end, k - (pos - start + 1));
        else
            return quickSelect(nums, start, pos - 1, k);
    }
}

The worst case time complexity of this method is O(n²), but it works in O(n) on average.