K’th Smallest Element in Unsorted Array
Last Updated : 14 Aug, 2024
Given an array arr[] of N distinct elements and a number K, where K is smaller than the size of the array. Find the K’th smallest element in the given array.
Examples:
Input: arr[] = {7, 10, 4, 3, 20, 15}, K = 3
Output: 7
Input: arr[] = {7, 10, 4, 3, 20, 15}, K = 4
Output: 10
[Naive Approach] Using Sorting – O(n log(n)) time and O(1) auxiliary space:
The very basic approach is to sort the given array and return the element at the index K – 1.
Below is the Implementation of the above approach:
C++ // C++ program to find K'th smallest element #include <bits/stdc++.h> using namespace std; // Function to return K'th smallest element in a given array int kthSmallest(int arr[], int N, int K) { // Sort the given array sort(arr, arr + N); // Return k'th element in the sorted array return arr[K - 1]; } // Driver's code int main() { int arr[] = { 12, 3, 5, 7, 19 }; int N = sizeof(arr) / sizeof(arr[0]), K = 2; // Function call cout << "K'th smallest element is " << kthSmallest(arr, N, K); return 0; } // C program to find K'th smallest element #include <stdio.h> #include <stdlib.h> // Compare function for qsort int cmpfunc(const void* a, const void* b) { return (*(int*)a - *(int*)b); } // Function to return K'th smallest // element in a given array int kthSmallest(int arr[], int N, int K) { // Sort the given array qsort(arr, N, sizeof(int), cmpfunc); // Return k'th element in the sorted array return arr[K - 1]; } // Driver's code int main() { int arr[] = { 12, 3, 5, 7, 19 }; int N = sizeof(arr) / sizeof(arr[0]), K = 2; // Function call printf("K'th smallest element is %d", kthSmallest(arr, N, K)); return 0; } // Java code for Kth smallest element // in an array import java.util.Arrays; import java.util.Collections; class GFG { // Function to return K'th smallest // element in a given array public static int kthSmallest(Integer[] arr, int K) { // Sort the given array Arrays.sort(arr); // Return K'th element in // the sorted array return arr[K - 1]; } // driver's code public static void main(String[] args) { Integer arr[] = new Integer[] { 12, 3, 5, 7, 19 }; int K = 2; // Function call System.out.print("K'th smallest element is " + kthSmallest(arr, K)); } } # Python3 program to find K'th smallest # element # Function to return K'th smallest # element in a given array def kthSmallest(arr, N, K): # Sort the given array arr.sort() # Return k'th element in the # sorted array return arr[K-1] # Driver code if __name__ == '__main__': arr = [12, 3, 5, 7, 19] N = len(arr) K = 2 # Function call print("K'th smallest element is", kthSmallest(arr, N, K)) // C# code for Kth smallest element // in an array using System; class GFG { // Function to return K'th smallest // element in a given array public static int kthSmallest(int[] arr, int K) { // Sort the given array Array.Sort(arr); // Return k'th element in // the sorted array return arr[K - 1]; } // driver's program public static void Main() { int[] arr = new int[] { 12, 3, 5, 7, 19 }; int K = 2; // Function call Console.Write("K'th smallest element" + " is " + kthSmallest(arr, K)); } } // Simple Javascript program to find K'th smallest element // Function to return K'th smallest element in a given array function kthSmallest(arr, N, K) { // Sort the given array arr.sort((a,b) => a-b); // Return k'th element in the sorted array return arr[K - 1]; } // Driver program to test above methods let arr = [12, 3, 5, 7, 19]; let N = arr.length, K = 2; console.log("K'th smallest element is " + kthSmallest(arr, N, K)); <?php // Simple PHP program to find // K'th smallest element // Function to return K'th smallest // element in a given array function kthSmallest($arr, $N, $K) { // Sort the given array sort($arr); // Return k'th element // in the sorted array return $arr[$K - 1]; } // Driver's Code $arr = array(12, 3, 5, 7, 19); $N =count($arr); $K = 2; // Function call echo "K'th smallest element is ", kthSmallest($arr, $N, $K); ?> OutputK'th smallest element is 5
Time Complexity: O(N log N)
Auxiliary Space: O(1)
[Expected Approach] Using Priority Queue(Max-Heap) – O(N * log(K)) time and O(K) auxiliary space:
The intuition behind this approach is to maintain a max heap (priority queue) of size K while iterating through the array. Doing this ensures that the max heap always contains the K smallest elements encountered so far. If the size of the max heap exceeds K, remove the largest element this step ensures that the heap maintains the K smallest elements encountered so far. In the end, the max heap’s top element will be the Kth smallest element.
Code Implementation:
C++ #include <bits/stdc++.h> using namespace std; // Function to find the kth smallest array element int kthSmallest(int arr[], int N, int K) { // Create a max heap (priority queue) priority_queue<int> pq; // Iterate through the array elements for (int i = 0; i < N; i++) { // Push the current element onto the max heap pq.push(arr[i]); // If the size of the max heap exceeds K, remove the largest element if (pq.size() > K) pq.pop(); } // Return the Kth smallest element (top of the max heap) return pq.top(); } // Driver's code: int main() { int N = 10; int arr[N] = { 10, 5, 4, 3, 48, 6, 2, 33, 53, 10 }; int K = 4; // Function call cout << "Kth Smallest Element is: " << kthSmallest(arr, N, K); } import java.util.PriorityQueue; public class KthSmallestElement { // Function to find the kth smallest array element public static int kthSmallest(int[] arr, int N, int K) { // Create a max heap (priority queue) PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a); // Iterate through the array elements for (int i = 0; i < N; i++) { // Push the current element onto the max heap pq.offer(arr[i]); // If the size of the max heap exceeds K, remove the largest element if (pq.size() > K) pq.poll(); } // Return the Kth smallest element (top of the max heap) return pq.peek(); } // Driver's code: public static void main(String[] args) { int N = 10; int[] arr = { 10, 5, 4, 3, 48, 6, 2, 33, 53, 10 }; int K = 4; // Function call System.out.println("Kth Smallest Element is: " + kthSmallest(arr, N, K)); } } import heapq # Function to find the kth smallest array element def kthSmallest(arr, K): # Create a max heap (priority queue) max_heap = [] # Iterate through the array elements for num in arr: # Push the negative of the current element onto the max heap heapq.heappush(max_heap, -num) # If the size of the max heap exceeds K, remove the largest element if len(max_heap) > K: heapq.heappop(max_heap) # Return the Kth smallest element (top of the max heap, negated) return -max_heap[0] # Driver's code: if __name__ == "__main__": arr = [10, 5, 4, 3, 48, 6, 2, 33, 53, 10] K = 4 # Function call print("Kth Smallest Element is:", kthSmallest(arr, K)) using System; using System.Collections.Generic; public class KthSmallestElement { // Function to find the kth smallest array element public static int KthSmallest(int[] arr, int K) { // Create a max heap (priority queue) using a SortedSet var maxHeap = new SortedSet<int>(Comparer<int>.Create((a, b) => b.CompareTo(a))); // Iterate through the array elements foreach (var num in arr) { // Add the current element to the max heap maxHeap.Add(-num); // If the size of the max heap exceeds K, remove the largest element if (maxHeap.Count > K) maxHeap.Remove(maxHeap.Max); } // Return the Kth smallest element (top of the max heap) return -maxHeap.Max; } // Driver's code: public static void Main() { int[] arr = { 10, 5, 4, 3, 48, 6, 2, 33, 53, 10 }; int K = 4; // Function call Console.WriteLine("Kth Smallest Element is: " + KthSmallest(arr, K)); } } // Function to find the kth smallest array element function kthSmallest(arr, K) { // Create a max heap (priority queue) let pq = new MaxHeap(); // Iterate through the array elements for (let i = 0; i < arr.length; i++) { // Push the current element onto the max heap pq.push(arr[i]); // If the size of the max heap exceeds K, remove the largest element if (pq.size() > K) pq.pop(); } // Return the Kth smallest element (top of the max heap) return pq.top(); } // MaxHeap class definition class MaxHeap { constructor() { this.heap = []; } push(val) { this.heap.push(val); this.heapifyUp(this.heap.length - 1); } pop() { if (this.heap.length === 0) { return null; } if (this.heap.length === 1) { return this.heap.pop(); } const root = this.heap[0]; this.heap[0] = this.heap.pop(); this.heapifyDown(0); return root; } top() { if (this.heap.length === 0) { return null; } return this.heap[0]; } size() { return this.heap.length; } heapifyUp(index) { while (index > 0) { const parentIndex = Math.floor((index - 1) / 2); if (this.heap[parentIndex] >= this.heap[index]) { break; } this.swap(parentIndex, index); index = parentIndex; } } heapifyDown(index) { const leftChildIndex = 2 * index + 1; const rightChildIndex = 2 * index + 2; let largestIndex = index; if ( leftChildIndex < this.heap.length && this.heap[leftChildIndex] > this.heap[largestIndex] ) { largestIndex = leftChildIndex; } if ( rightChildIndex < this.heap.length && this.heap[rightChildIndex] > this.heap[largestIndex] ) { largestIndex = rightChildIndex; } if (index !== largestIndex) { this.swap(index, largestIndex); this.heapifyDown(largestIndex); } } swap(i, j) { [this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]]; } } // Driver's code: const arr = [10, 5, 4, 3, 48, 6, 2, 33, 53, 10]; const K = 4; // Function call console.log("Kth Smallest Element is: " + kthSmallest(arr, K)); OutputKth Smallest Element is: 5
Time Complexity: O(N * log(K)), The approach efficiently maintains a container of the K smallest elements while iterating through the array, ensuring a time complexity of O(N * log(K)), where N is the number of elements in the array.
Auxiliary Space: O(K)
[QuickSelect] Works best in Practice:
The algorithm is similar to QuickSort. The difference is, instead of recurring for both sides (after finding pivot), it recurs only for the part that contains the k-th smallest element. The logic is simple, if index of the partitioned element is more than k, then we recur for the left part. If index is the same as k, we have found the k-th smallest element and we return. If index is less than k, then we recur for the right part. This reduces the expected complexity from O(n log n) to O(n), with a worst-case of O(n^2).
function quickSelect(list, left, right, k) if left = right return list[left] Select a pivotIndex between left and right pivotIndex := partition(list, left, right, pivotIndex) if k = pivotIndex return list[k] else if k < pivotIndex right := pivotIndex - 1 else left := pivotIndex + 1
Please refer Quickselect for implementation,
Time Complexity : O(n^2) in the worst case, but on average works in O(n Log n) time and performs better than priority queue based algorithm.
Auxiliary Space : O(n) for recursion call stack in worst case. On average : O(Log n)
[Other Approach] Using Counting Sort (Not efficient for large range of elements)
Counting sort is a linear time sorting algorithm that counts the occurrences of each element in an array and uses this information to determine the sorted order. The idea behind using counting sort to find the K’th smallest element is to use the counting phase, which essentially calculates the cumulative frequencies of elements. By tracking these cumulative frequencies, we can efficiently determine the K’th smallest element.
Note: This approach is particularly useful when the range of elements is small, this is because we are declaring a array of size maximum element. If the range of elements is very large, the counting sort approach may not be the most efficient choice.
Code Implementation:
C++ #include <iostream> using namespace std; // This function returns the kth smallest element in an array int kthSmallest(int arr[], int n, int k) { // First, find the maximum element in the array int max_element = arr[0]; for (int i = 1; i < n; i++) { if (arr[i] > max_element) { max_element = arr[i]; } } // Create an array to store the frequency of each // element in the input array int freq[max_element + 1] = {0}; for (int i = 0; i < n; i++) { freq[arr[i]]++; } // Keep track of the cumulative frequency of elements // in the input array int count = 0; for (int i = 0; i <= max_element; i++) { if (freq[i] != 0) { count += freq[i]; if (count >= k) { // If we have seen k or more elements, // return the current element return i; } } } return -1; } // Driver Code int main() { int arr[] = {12,3,5,7,19}; int n = sizeof(arr) / sizeof(arr[0]); int k = 2; cout << "The " << k << "th smallest element is " << kthSmallest(arr, n, k) << endl; return 0; } import java.util.Arrays; public class GFG { // This function returns the kth smallest element in an // array static int kthSmallest(int[] arr, int n, int k) { // First, find the maximum element in the array int max_element = arr[0]; for (int i = 1; i < n; i++) { if (arr[i] > max_element) { max_element = arr[i]; } } // Create an array to store the frequency of each // element in the input array int[] freq = new int[max_element + 1]; Arrays.fill(freq, 0); for (int i = 0; i < n; i++) { freq[arr[i]]++; } // Keep track of the cumulative frequency of // elements in the input array int count = 0; for (int i = 0; i <= max_element; i++) { if (freq[i] != 0) { count += freq[i]; if (count >= k) { // If we have seen k or more elements, // return the current element return i; } } } return -1; } // Driver Code public static void main(String[] args) { int[] arr = { 12, 3, 5, 7, 19 }; int n = arr.length; int k = 2; System.out.println("The " + k + "th smallest element is " + kthSmallest(arr, n, k)); } } # Python3 code for kth smallest element in an array # function returns the kth smallest element in an array def kth_smallest(arr, k): # First, find the maximum element in the array max_element = max(arr) # Create a dictionary to store the frequency of each # element in the input array freq = {} for num in arr: freq[num] = freq.get(num, 0) + 1 # Keep track of the cumulative frequency of elements # in the input array count = 0 for i in range(max_element + 1): if i in freq: count += freq[i] if count >= k: # If we have seen k or more elements, # return the current element return i return -1 # Driver Code arr = [12, 3, 5, 7, 19] k = 2 print("The", k,"th smallest element is", kth_smallest(arr, k)) using System; public class GFG { // This function returns the kth smallest element in an array static int KthSmallest(int[] arr, int n, int k) { // First, find the maximum element in the array int maxElement = arr[0]; for (int i = 1; i < n; i++) { if (arr[i] > maxElement) { maxElement = arr[i]; } } // Create an array to store the frequency of each // element in the input array int[] freq = new int[maxElement + 1]; for (int i = 0; i < n; i++) { freq[arr[i]]++; } // Keep track of the cumulative frequency of elements // in the input array int count = 0; for (int i = 0; i <= maxElement; i++) { if (freq[i] != 0) { count += freq[i]; if (count >= k) { // If we have seen k or more elements, // return the current element return i; } } } return -1; } // Driver Code static void Main(string[] args) { int[] arr = { 12, 3, 5, 7, 19 }; int n = arr.Length; int k = 2; Console.WriteLine("The " + k + "th smallest element is " + KthSmallest(arr, n, k)); } } // Function to find the kth smallest element in an array function kthSmallest(arr, k) { // First, find the maximum element in the array let maxElement = arr[0]; for (let i = 1; i < arr.length; i++) { if (arr[i] > maxElement) { maxElement = arr[i]; } } // Create an array to store the frequency of each element in the input array let freq = new Array(maxElement + 1).fill(0); for (let i = 0; i < arr.length; i++) { freq[arr[i]]++; } // Keep track of the cumulative frequency of elements in the input array let count = 0; for (let i = 0; i <= maxElement; i++) { if (freq[i] !== 0) { count += freq[i]; if (count >= k) { // If we have seen k or more elements, return the current element return i; } } } return -1; // kth smallest element not found } // Driver code const arr = [12, 3, 5, 7, 19]; const k = 2; console.log(`The ${k}th smallest element is ${kthSmallest(arr, k)}`); OutputThe 2th smallest element is 5
Time Complexity: O(N + max_element), where max_element is the maximum element of the array.
Auxiliary Space: O(max_element)
Related Articles:
Similar Reads
Heap Data Structure
A Heap is a complete binary tree data structure that satisfies the heap property: for every node, the value of its children is greater than or equal to its own value. Heaps are usually used to implement priority queues, where the smallest (or largest) element is always at the root of the tree. Basic
2 min read
Introduction to Heap - Data Structure and Algorithm Tutorials
A Heap is a special Tree-based Data Structure that has the following properties. It is a Complete Binary Tree.It either follows max heap or min heap property.Max-Heap: The value of the root node must be the greatest among all its descendant nodes and the same thing must be done for its left and righ
15+ min read
Binary Heap
A Binary Heap is a complete binary tree that stores data efficiently, allowing quick access to the maximum or minimum element, depending on the type of heap. It can either be a Min Heap or a Max Heap. In a Min Heap, the key at the root must be the smallest among all the keys in the heap, and this pr
13 min read
Advantages and Disadvantages of Heap
Advantages of Heap Data StructureTime Efficient: Heaps have an average time complexity of O(log n) for inserting and deleting elements, making them efficient for large datasets. We can convert any array to a heap in O(n) time. The most important thing is, we can get the min or max in O(1) timeSpace
2 min read
Time Complexity of building a heap
Consider the following algorithm for building a Heap of an input array A. A quick look over the above implementation suggests that the running time is [Tex]O(n * lg(n)) [/Tex] since each call to Heapify costs [Tex]O(lg(n)) [/Tex]and Build-Heap makes [Tex]O(n) [/Tex]such calls. This upper bound, thou
2 min read
Applications of Heap Data Structure
Heap Data Structure is generally taught with Heapsort. Heapsort algorithm has limited uses because Quicksort is better in practice. Nevertheless, the Heap data structure itself is enormously used. Priority Queues: Heaps are commonly used to implement priority queues, where elements with higher prior
2 min read
Comparison between Heap and Tree
What is Heap? A Heap is a special Tree-based data structure in which the tree is a complete binary tree. Types of Heap Data Structure: Generally, Heaps can be of two types: Max-Heap: In a Max-Heap the key present at the root node must be greatest among the keys present at all of its children. The sa
3 min read
When building a Heap, is the structure of Heap unique?
What is Heap? A heap is a tree based data structure where the tree is a complete binary tree that maintains the property that either the children of a node are less than itself (max heap) or the children are greater than the node (min heap). Properties of Heap: Structural Property: This property sta
4 min read
Easy problems on Heap
Check if a given Binary Tree is a Heap
Given a binary tree, check if it has heap property or not, Binary tree needs to fulfil the following two conditions for being a heap: It should be a complete tree (i.e. Every level of the tree, except possibly the last, is completely filled, and all nodes are as far left as possible.).Every node’s v
15+ min read
How to check if a given array represents a Binary Heap?
Given an array, how to check if the given array represents a Binary Max-Heap.Examples: Input: arr[] = {90, 15, 10, 7, 12, 2} Output: True The given array represents below tree 90 / \ 15 10 / \ / 7 12 2 The tree follows max-heap property as every node is greater than all of its descendants. Input: ar
11 min read
Iterative HeapSort
HeapSort is a comparison-based sorting technique where we first build Max Heap and then swap the root element with the last element (size times) and maintains the heap property each time to finally make it sorted. Examples: Input : 10 20 15 17 9 21 Output : 9 10 15 17 20 21 Input: 12 11 13 5 6 7 15
11 min read
Find k largest elements in an array
Given an array arr[] and an integer k, the task is to find k largest elements in the given array. Elements in the output array should be in decreasing order. Examples: Input: [1, 23, 12, 9, 30, 2, 50], k = 3Output: [50, 30, 23] Input: [11, 5, 12, 9, 44, 17, 2], k = 2Output: [44, 17] Table of Content
15+ min read
K’th Smallest Element in Unsorted Array
Given an array arr[] of N distinct elements and a number K, where K is smaller than the size of the array. Find the K'th smallest element in the given array. Examples: Input: arr[] = {7, 10, 4, 3, 20, 15}, K = 3 Output: 7 Input: arr[] = {7, 10, 4, 3, 20, 15}, K = 4 Output: 10 Table of Content [Naive
15+ min read
Height of a complete binary tree (or Heap) with N nodes
Consider a Binary Heap of size N. We need to find the height of it. Examples: Input : N = 6 Output : 2 () / \ () () / \ / () () () Input : N = 9 Output : 3 () / \ () () / \ / \ () () () () / \ () ()Recommended PracticeHeight of HeapTry It! Let the size of the heap be N and the height be h. If we tak
3 min read
Heap Sort for decreasing order using min heap
Given an array of elements, sort the array in decreasing order using min heap. Examples: Input : arr[] = {5, 3, 10, 1}Output : arr[] = {10, 5, 3, 1}Input : arr[] = {1, 50, 100, 25}Output : arr[] = {100, 50, 25, 1} Prerequisite: Heap sort using min heap. Using Min Heap Implementation - O(n Log n) Tim
11 min read