Kth Smallest in an Unsorted Array in Java

In the given array, the task is to find the kth smallest element of the array, where k is always less than the size of the given array.

Examples:

Input:

arr[] = {56, 34, 7, 9, 0, 48, 41, 8}

k = 3

Output: The 3^rd smallest element of the array is 8.

Input:

arr[] = {90, 87, 30, 9, 12, 41, 13, 80, 67, 70}

k = 4

Output: The 4^th smallest element of the array is 30.

Approach: Sorting the array

It is a straightforward approach. One has to sort the array and return the Kth element from the left.

FileName: KthSmallestEle.java

public class KthSmallestEle
{

// method for sorting the array arr
public void sortArr(int arr[])
{
int size = arr.length;

for(int i = 0; i < size; i++)
{
int temp = i;
for(int j = i + 1; j < size; j++)
{
if(arr[temp] > arr[j])
{
temp = j;
}



}


if(temp != i)
{
int t = arr[i];
arr[i] = arr[temp];
arr[temp] = t; 
}
}
}

// find the kth smallest element of the array
public int findKthSmallest(int arr[], int k)
{
sortArr(arr);

// as an array is always a zero indexing
// therefore, the kth smallest element lies
// at the k - 1 index
return arr[k - 1];
}


// main method
public static void main(String argvs[])
{

// creating an object of the class KthSmallestEle
KthSmallestEle obj = new KthSmallestEle();

int arr[] = {56, 34, 7, 9, 0, 48, 41, 8};

int size = arr.length;
int k = 3;

System.out.println("For the array: ");
for(int i = 0; i < size; i++)
{
System.out.print(arr[i] + " ");
}

int ele = obj.findKthSmallest(arr, k);

System.out.println();
System.out.println("The " + k + "rd smallest element of the array is: " + ele);

System.out.println("\n");

int arr1[] = {90, 87, 30, 9, 12, 41, 13, 80, 67, 70};

size = arr1.length;
k = 4;

System.out.println("For the array: ");
for(int i = 0; i < size; i++)
{
System.out.print(arr1[i] + " ");
}

ele = obj.findKthSmallest(arr1, k);

System.out.println();
System.out.println("The " + k + "th smallest element of the array is: " + ele);

}
}

Output:

For the array: 
56 34 7 9 0 48 41 8 
The 3rd smallest element of the array is: 8


For the array: 
90 87 30 9 12 41 13 80 67 70 
The 4th smallest element of the array is: 30

Time-Complexity: The time-complexity of the above program lies in the sorting technique implemented in the method sortArr(). In our case, the technique used is the selection sort. Hence, the time complexity of the above program is O(n²), where n is the total number of elements present in the array.

Approach: Using Min Heap

One can also use the min-heap to find the kth minimum element of the array.

FileName: KthSmallestEle1.java

public class KthSmallestEle1
{

// A class for the minimum heap
class MinimumHeap
{
int[] h; // pointer to array of the elements in heap


// represents the capacity of the minimum heap
int c; 

// the total number of elements present in the min-heap
int heapSize; 

// a method for returning the index of the parent node
int parent(int j) 
{ 
return (j - 1) / 2; 
}

// a method for returning the index of the left node
int left(int j) 
{ 
return ((2 * j ) + 1); 

}

// a method for returning the index of the right node
int right(int j) 
{ 
return ((2 * j ) + 2); 

}

// Returning the minimum
int getMin() 
{ 
return h[0 ]; 

} 

// for replacing the root with the new node y and then heapify()
// the new root
void replaceMax(int y)
{
this.h[0 ] = y;
heapify(0 );
}

// constructor of the class
MinimumHeap(int arr[], int s)
{
heapSize = s;

// storing the array address
h = arr; 
int j = (heapSize - 1 ) / 2;
while (j >= 0)
{
heapify(j );
j = j - 1;
}
}

// Method for removing the maximum element (or the root) from the minimum heap
int extractMin()
{
if (heapSize == 0)
{
return Integer.MAX_VALUE;
}

// Storing the maximum value.
int r = h[0];

// If there are more than 1 item, move the last item to the root
// and call heapify.
if (heapSize > 1)
{
h[0] = h[heapSize - 1];
heapify(0);
}
heapSize = heapSize - 1;
return r;
}

// A recursive method for heapifying the subtree with the root at the given index
// The method is assuming that the subtrees are heapified already
void heapify(int j)
{
int lt = left(j);
int rt = right(j);
int minimum = j;
if (lt < heapSize && h[lt] < h[j])
{
minimum = lt;
}
if (rt < heapSize && h[rt ] < h[minimum ] )
{
minimum = rt;
}
if (minimum != j )
{
int t = h[j ];
h[j] = h[minimum ];
h[minimum ] = t;
heapify(minimum );
}
}
};

// Function to return k'th largest element in a given array
public int findKthSmallest(int a[], int s, int k)
{

// Building the heap of the first k elements: in the O(k ) time
// creating an object of the class MinimumHeap
MinimumHeap mHeap = new MinimumHeap(a, s );

// If the current element 
// is smaller than the root, then replace the root with the current element
for (int j = 0; j < k - 1; j++)
{
mHeap.extractMin();
}

// Returning the root
return mHeap.getMin();
}

// main method for testing the above methods
public static void main(String[] args)
{
// creating an object of the class KthSmallestEle1
KthSmallestEle1 obj = new KthSmallestEle1();

int arr[] = {56, 34, 7, 9, 0, 48, 41, 8 };

int size = arr.length;
int k = 3;

System.out.println("For the array: " );
for(int i = 0; i < size; i++)
{
System.out.print(arr[i] + " " );
}

int ele = obj.findKthSmallest(arr, size, k );

System.out.println();
System.out.println("The " + k + "rd smallest element of the array is: " + ele );

System.out.println("\n" );

int arr1[] = {90, 87, 30, 9, 12, 41, 13, 80, 67, 70 };

size = arr1.length;
k = 4;

System.out.println("For the array: ");
for(int i = 0; i < size; i++)
{
System.out.print(arr1[i] + " ");
}

ele = obj.findKthSmallest(arr1, size, k);

System.out.println();
System.out.println("The " + k + "th smallest element of the array is: " + ele);

}

}

Output:

For the array: 
56 34 7 9 0 48 41 8 
The 3rd smallest element of the array is: 8


For the array: 
90 87 30 9 12 41 13 80 67 70 
The 4th smallest element of the array is: 30

Time-Complexity: The time complexity of the above program is O(n + k * log(n)), where n is the total number of elements present in the array, and k is the rank of the smallest element that needs to be searched in the given array.

Approach: Using Max Heap

One can also use the max-heap to find the kth minimum element of the array. Observe the following algorithm.

Step 1: Using the first k elements of the input array (a[0], …, a[k - 1], create a Max-Heap.

Step 2: Compare each element that is coming after the k'th element (a[k] to a[n - 1]) with the root element of the max-heap. The following two cases will occur while doing the comparison.

Case 1: If the current element is smaller than the root element of the max-heap, then replace the root element with the current element and for the re-arrangement of the element in the max-heap, invoke the method heapify().

Case 2: If the current element is greater than the root element, then ignore that element.

FileName: KthSmallestEle2.java

public class KthSmallestEle2
{

// A class for the maximum heap
class MaximumHeap
{
int[] h; // pointer to array of the elements in heap


// represents the capacity of the minimum heap
int c; 

// the total number of elements present in the min-heap
int heapSize; 

// a method for returning the index of the parent node
int parent(int j) 
{ 
return (j - 1) / 2; 
}

// a method for returning the index of the left node
int left(int j) 
{ 
return ((2 * j ) + 1); 

}

// a method for returning the index of the right node
int right(int j) 
{ 
return ((2 * j ) + 2); 

}

// Returning the maximum
int getMax() 
{ 
return h[0 ]; 

} 

// for replacing the root with the new node y and then heapify()
// the new root
void replaceMax(int y)
{
this.h[0 ] = y;
heapify(0 );
}

// constructor of the class
MaximumHeap(int arr[], int s)
{
heapSize = s;

// storing the array address
h = arr; 
int j = (heapSize - 1 ) / 2;
while (j >= 0)
{
heapify(j );
j = j - 1;
}
}

// Method for removing the maximum element (or the root) from the minimum heap
int extractMax()
{
if (heapSize == 0)
{
return Integer.MAX_VALUE;
}

// Storing the maximum value.
int r = h[0];

// If there are more than 1 item, move the last item to the root
// and call heapify.
if (heapSize > 1)
{
h[0] = h[heapSize - 1];
heapify(0);
}
heapSize = heapSize - 1;
return r;
}


// A recursive method for heapifying the subtree with the root at the given index
// The method is assuming that the subtrees are heapified already
void heapify(int j)
{
int lt = left(j);
int rt = right(j);
int maximum = j;
if (lt < heapSize && h[lt] > h[j])
{
maximum = lt;
}
if (rt < heapSize && h[rt ] > h[maximum ] )
{
maximum = rt;
}
if (maximum != j )
{
int t = h[j ];
h[j] = h[maximum ];
h[maximum ] = t;
heapify(maximum );
}
}
};

// method to return k'th largest element in a given array
public int findKthSmallest(int a[], int s, int k)
{

// Building the heap of the first k elements: in the O(k ) time
// creating an object of the class MaximumHeap
MaximumHeap mHeap = new MaximumHeap(a, k );

// Processing the s - k elements. If the current element 
// is smaller than the root, then replace the root with the current element

for (int j = k; j < s; j++)
{
if (a[j] < mHeap.getMax())
{
mHeap.replaceMax(a[j]);
}
}

// Returning the root
return mHeap.getMax();
}

// main method for testing the above methods
public static void main(String[] args)
{
// creating an object of the class KthSmallestEle2
KthSmallestEle2 obj = new KthSmallestEle2();

int arr[] = {56, 34, 7, 9, 0, 48, 41, 8 };

int size = arr.length;
int k = 3;

System.out.println("For the array: " );
for(int i = 0; i < size; i++)
{
System.out.print(arr[i] + " " );
}

int ele = obj.findKthSmallest(arr, size, k );

System.out.println();
System.out.println("The " + k + "rd smallest element of the array is: " + ele );

System.out.println("\n" );

int arr1[] = {90, 87, 30, 9, 12, 41, 13, 80, 67, 70 };

size = arr1.length;
k = 4;

System.out.println("For the array: ");
for(int i = 0; i < size; i++)
{
System.out.print(arr1[i] + " ");
}

ele = obj.findKthSmallest(arr1, size, k);

System.out.println();
System.out.println("The " + k + "th smallest element of the array is: " + ele);

}

}

Output:

For the array: 
56 34 7 9 0 48 41 8 
The 3rd smallest element of the array is: 8


For the array: 
90 87 30 9 12 41 13 80 67 70 
The 4th smallest element of the array is: 30

Time-Complexity: Step 1 takes the O(k) time, and step 2 takes O(n - k) * log(k) time. Hence, the time complexity of the above program is O(k + (n - k) * log(k)), where n is the total number of elements present in the array, and k is the rank of the smallest element that needs to be searched in the given array.

Approach: Using QuickSort

In quicksort, we take a pivot element, and then we place the pivot element to its correct position. The pivot element then partitions the array into two unsorted sub-arrays. In this approach, we will not do the complete quicksort. In fact, we will stop at the point where the pivot element is the kth smallest element of the given array.

FileName: KthSmallestEle3.java

public class KthSmallestEle3
{
// It is the standard process of partition of the QuickSort Algorithm
// It takes the last element as the pivot element
// and moves all of the smaller elements to the left of
// it and the greater elements to the right of it
public int partition(int[] a, int l, int e)
{
int y = a[e]; 
int j = l;
for (int i = l; i <= e - 1; i++) 
{
if (a[i] <= y) 
{
// Swapping a[j] and a[i]
int temp = a[j];
a[j] = a[i];
a[i] = temp;

j = j + 1;
}
}

// Swapping a[j] and a[r]
int temp = a[j];
a[j] = a[e];
a[e] = temp;

return j;
}

// This method returns the k'th smallest 
// element in the a[l...r] using the QuickSort algorithm.
// We assume that all of the elements in the a[] are unique
public int findKthSmallest(int[] a, int s, int e, int k)
{
// If k is smaller as compared to the number of 
// elements in the array
if (k > 0 && k <= e - s + 1) 
{
// Partitioning the array a[] around the last
// element and retrieve the position of the pivot
// element in the sorted array
int position = partition(a, s, e);

// If the position is the same as k
if (position - s == k - 1)
{
return a[position];
}

// If the position is more, then recur for
// the left subarray
if (position - s > k - 1)
{
return findKthSmallest(a, s, position - 1, k);
}

// Else recurring for the right subarray
return findKthSmallest(a, position + 1, e, k - position + s - 1);
}

// If k is more than the total number of elements
// present in the array
return Integer.MAX_VALUE;
}

// main method for testing the above methods
public static void main(String[] argvs)
{
// creating an object of the class KthSmallestEle3
KthSmallestEle3 obj = new KthSmallestEle3();

int arr[] = {56, 34, 7, 9, 0, 48, 41, 8 };

int size = arr.length;
int k = 3;

System.out.println("For the array: " );
for(int i = 0; i < size; i++)
{
System.out.print(arr[i] + " " );
}

int ele = obj.findKthSmallest(arr, 0, size - 1, k );

System.out.println();
System.out.println("The " + k + "rd smallest element of the array is: " + ele );

System.out.println("\n" );

int arr1[] = {90, 87, 30, 9, 12, 41, 13, 80, 67, 70 };

size = arr1.length;
k = 4;

System.out.println("For the array: ");
for(int i = 0; i < size; i++)
{
System.out.print(arr1[i] + " ");
}

ele = obj.findKthSmallest(arr1, 0, size - 1, k);

System.out.println();
System.out.println("The " + k + "th smallest element of the array is: " + ele);

}

}

Output:

For the array: 
56 34 7 9 0 48 41 8 
The 3rd smallest element of the array is: 8


For the array: 
90 87 30 9 12 41 13 80 67 70 
The 4th smallest element of the array is: 30

Time-Complexity: As we are not completing the quick ort in most of the cases, the average time complexity of the above program is O(n). However, the worst time complexity is O(n²), where n is the total number of elements present in the input array.

Approach: Using Ordered Map and Frequency of Elements

In this approach, we will be using an ordered map and then will map each element with its frequency of occurrence. We already know that the ordered map always keeps the data in a sorted manner. Therefore, we will keep on adding the frequency of occurrence of each of the elements until it does not become equal to or more than k so that one can find the k'th element from the beginning, i.e., the smallest k'th element of the given array.

FileName: KthSmallestEle4.java

// important import statement
import java.util.*;

public class KthSmallestEle4 
{
public int findKthSmallest(TreeMap<Integer, Integer> tm, int k)
{
// counting frequency of element
int freqCount = 0;
for (Map.Entry itr : tm.entrySet())
{

// adding the frequency of occurrences of each element
freqCount = freqCount + (int)itr.getValue();

// if we find the frequency count increases or becomes
// equal to k at any point of time, then return that element
// It is because that element is the kth smallest element.
if (freqCount >= k) 
{
return (int)itr.getKey();
}
}

// control reaching here the value of k is greater than the total element
// present in the given array
return -1; 
}

// main method for testing the above methods
public static void main(String[] argvs)
{
// creating an object of the class KthSmallestEle4
KthSmallestEle4 obj = new KthSmallestEle4();

int arr[] = {56, 34, 7, 9, 0, 48, 41, 8 };

int size = arr.length;
int k = 3;



System.out.println("For the array: " );
for(int i = 0; i < size; i++)
{
System.out.print(arr[i] + " " );
}


TreeMap<Integer, Integer> tm = new TreeMap<Integer, Integer>();
for (int j = 0; j < size; j++) 
{
// mapping each and every element with it's frequency
tm.put(arr[j], tm.getOrDefault(arr[j], 0) + 1);
}

int ele = obj.findKthSmallest(tm, k );

System.out.println();
System.out.println("The " + k + "rd smallest element of the array is: " + ele );

System.out.println("\n" );

int arr1[] = {90, 87, 30, 9, 12, 41, 13, 80, 67, 70 };

size = arr1.length;
k = 4;

System.out.println("For the array: ");
for(int i = 0; i < size; i++)
{
System.out.print(arr1[i] + " ");
}


TreeMap<Integer, Integer> tm1 = new TreeMap<Integer, Integer>();
for (int j = 0; j < size; j++) 
{
// mapping each and every element with it's frequency
tm1.put(arr1[j], tm1.getOrDefault(arr1[j], 0) + 1);
}


ele = obj.findKthSmallest(tm1, k);

System.out.println();
System.out.println("The " + k + "th smallest element of the array is: " + ele);

}

}

Output:

For the array: 
56 34 7 9 0 48 41 8 
The 3rd smallest element of the array is: 8


For the array: 
90 87 30 9 12 41 13 80 67 70 
The 4th smallest element of the array is: 30

Next Topic#

← prev next →