K’th Smallest/Largest Element in Unsorted Array | Set 1

• Difficulty Level : Medium
• Last Updated : 22 Jul, 2022

Given an array and a number k where k is smaller than the size of the array, we need to find the k’th smallest element in the given array. It is given that all array elements are distinct.

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

We have discussed a similar problem to print k largest elements

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

C++

 `// Simple C++ program to find k'th smallest element``#include ``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 program to test above methods``int` `main()``{``    ``int` `arr[] = { 12, 3, 5, 7, 19 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]), k = 2;``    ``cout << ``"K'th smallest element is "``         ``<< kthSmallest(arr, n, k);``    ``return` `0;``}` `// This code is contributed by Sania Kumari Gupta (kriSania804)`

C

 `// Simple C program to find k'th smallest element``#include ``#include ` `// 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 program to test above methods``int` `main()``{``    ``int` `arr[] = { 12, 3, 5, 7, 19 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]), k = 2;``    ``printf``(``"K'th smallest element is %d"``,``           ``kthSmallest(arr, n, k));``    ``return` `0;``}` `// This code is contributed by Sania Kumari Gupta (kriSania804)`

Java

 `// 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 program``    ``public` `static` `void` `main(String[] args)``    ``{``        ``Integer arr[] = ``new` `Integer[] { ``12``, ``3``, ``5``, ``7``, ``19` `};``        ``int` `k = ``2``;``        ``System.out.print(``"K'th smallest element is "` `+ kthSmallest(arr, k));``    ``}``}` `// This code is contributed by Chhavi`

Python3

 `# 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``    ``print``(``"K'th smallest element is"``,``          ``kthSmallest(arr, n, k))` `# This code is contributed by``# Shrikant13`

C#

 `// 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 program``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = ``new` `int``[] { 12, 3, 5,``                                ``7, 19 };``        ``int` `k = 2;``        ``Console.Write(``"K'th smallest element"``                      ``+ ``" is "` `+ kthSmallest(arr, k));``    ``}``}` `// This code is contributed by nitin mittal.`

PHP

 ``

Javascript

 ``

Output

`K'th smallest element is 5`

Method 2 (using set from C++ STL)

we can find the kth smallest element in time complexity better than O(N log N). we know the Set in C++ STL is implemented using Binary Search Tree and we also know that the time complexity of all cases(searching, inserting, deleting ) in BST is log (n) in the average case and O(n) in the worst case. We are using set because it is mentioned in the question that all the elements in an array are distinct.

The following is the C++ implementation of the above method.

C++

 `/* the following code demonstrates how to find kth smallest``element using set from C++ STL */` `#include ``using` `namespace` `std;` `int` `main()``{` `    ``int` `arr[] = { 12, 3, 5, 7, 19 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `k = 4;` `    ``set<``int``> s(arr, arr + n);``    ``set<``int``>::iterator itr``        ``= s.begin(); ``// s.begin() returns a pointer to first``                     ``// element in the set``    ``advance(itr, k - 1); ``// itr points to kth element in set` `    ``cout << *itr << ``"\n"``;` `    ``return` `0;``}`

Java

 `/* the following code demonstrates how to find kth smallest``element using set from Java Collections */` `import` `java.util.*;` `class` `GFG {` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = { ``12``, ``3``, ``5``, ``7``, ``19``, ``1``, ``2``, ``3``, ``4` `};``        ``int` `n = arr.length;``        ``int` `k = ``4``;``          ` `          ``//since counting starts from 0 so to find kth``          ``//element we need to reduce k by 1``          ``k--;``          ` `      ` `          ``//for storing elements in sorted form``          ``//in set we will use TreeSet``        ``Set s = ``new` `TreeSet();``      ` `          ``//adding elements to set``        ``for``(``int` `i=``0``;i itr = s.iterator();``      ` `        ``while``(k>``0``)``        ``{``          ``itr.next();``          ``k--;``        ``}``//itr points to the kth element in the set``        ``System.out.println(itr.next());``    ``}``}` `//This code is contributed by Abhijeet Kumar(abhijeet19403)`

Python3

 `# the following code demonstrates how to find kth smallest``# element using set from Python` `arr ``=` `[``12``, ``3``, ``5``, ``7``, ``19``]``n ``=` `len``(arr)``k ``=` `4` `s ``=` `set``(arr)` `for` `itr ``in` `s:``  ``if` `k ``=``=` `1``:``      ``print``(itr) ``# itr is the kth element in the set``      ``break``  ``k ``-``=` `1` `#This code is contributed by Abhijeet Kumar(abhijeet19403)`

C#

 `/* the following code demonstrates how to find kth smallest``element using set from C# collections */``using` `System;``using` `System.Collections.Generic;` `class` `GFG {` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{` `        ``int``[] arr = { 12, 3, 5, 7, 19 };``        ``int` `n = arr.Length;``        ``int` `k = 4;` `        ``SortedSet<``int``> s = ``new` `SortedSet<``int``>();``        ``foreach``(``int` `i ``in` `arr) s.Add(i);` `        ``foreach``(``int` `itr ``in` `s)``        ``{``            ``if` `(k == 1) {``                ``Console.WriteLine(itr);``// itr is the kth element in the set``                ``break``;``            ``}``            ``k--;``        ``}``    ``}``}` `//This code is contributed by Abhijeet Kumar(abhijeet19403)`

Output

`12`

Time Complexity:  O(N*log N) in Average Case and O(N) in Worst Case
Auxiliary Space: O(N)

Method 3 (Using Min Heap – HeapSelect)
We can find k’th smallest element in time complexity better than O(N Log N). A simple optimization is to create a Min Heap of the given n elements and call extractMin() k times.

The following is C++ implementation of above method.

C++

 `// A C++ program to find k'th smallest element using min heap``#include ``#include ``using` `namespace` `std;` `// Prototype of a utility function to swap two integers``void` `swap(``int``* x, ``int``* y);` `// A class for Min Heap``class` `MinHeap {``    ``int``* harr; ``// pointer to array of elements in heap``    ``int` `capacity; ``// maximum possible size of min heap``    ``int` `heap_size; ``// Current number of elements in min heap``public``:``    ``MinHeap(``int` `a[], ``int` `size); ``// Constructor``    ``void` `MinHeapify(``int` `i); ``// To minheapify subtree rooted with index i``    ``int` `parent(``int` `i) { ``return` `(i - 1) / 2; }``    ``int` `left(``int` `i) { ``return` `(2 * i + 1); }``    ``int` `right(``int` `i) { ``return` `(2 * i + 2); }` `    ``int` `extractMin(); ``// extracts root (minimum) element``    ``int` `getMin() { ``return` `harr[0]; } ``// Returns minimum``};` `MinHeap::MinHeap(``int` `a[], ``int` `size)``{``    ``heap_size = size;``    ``harr = a; ``// store address of array``    ``int` `i = (heap_size - 1) / 2;``    ``while` `(i >= 0) {``        ``MinHeapify(i);``        ``i--;``    ``}``}` `// Method to remove minimum element (or root) from min heap``int` `MinHeap::extractMin()``{``    ``if` `(heap_size == 0)``        ``return` `INT_MAX;` `    ``// Store the minimum value.``    ``int` `root = harr[0];` `    ``// If there are more than 1 items, move the last item to root``    ``// and call heapify.``    ``if` `(heap_size > 1) {``        ``harr[0] = harr[heap_size - 1];``        ``MinHeapify(0);``    ``}``    ``heap_size--;` `    ``return` `root;``}` `// A recursive method to heapify a subtree with root at given index``// This method assumes that the subtrees are already heapified``void` `MinHeap::MinHeapify(``int` `i)``{``    ``int` `l = left(i);``    ``int` `r = right(i);``    ``int` `smallest = i;``    ``if` `(l < heap_size && harr[l] < harr[i])``        ``smallest = l;``    ``if` `(r < heap_size && harr[r] < harr[smallest])``        ``smallest = r;``    ``if` `(smallest != i) {``        ``swap(&harr[i], &harr[smallest]);``        ``MinHeapify(smallest);``    ``}``}` `// A utility function to swap two elements``void` `swap(``int``* x, ``int``* y)``{``    ``int` `temp = *x;``    ``*x = *y;``    ``*y = temp;``}` `// Function to return k'th smallest element in a given array``int` `kthSmallest(``int` `arr[], ``int` `n, ``int` `k)``{``    ``// Build a heap of n elements: O(n) time``    ``MinHeap mh(arr, n);` `    ``// Do extract min (k-1) times``    ``for` `(``int` `i = 0; i < k - 1; i++)``        ``mh.extractMin();` `    ``// Return root``    ``return` `mh.getMin();``}` `// Driver program to test above methods``int` `main()``{``    ``int` `arr[] = { 12, 3, 5, 7, 19 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]), k = 2;``    ``cout << ``"K'th smallest element is "` `<< kthSmallest(arr, n, k);``    ``return` `0;``}`

Java

 `// A Java program to find k'th smallest element using min heap``import` `java.util.*;``class` `GFG``{` `  ``// A class for Max Heap``  ``class` `MinHeap``  ``{``    ``int``[] harr; ``// pointer to array of elements in heap``    ``int` `capacity; ``// maximum possible size of min heap``    ``int` `heap_size; ``// Current number of elements in min heap` `    ``int` `parent(``int` `i) { ``return` `(i - ``1``) / ``2``; }``    ``int` `left(``int` `i) { ``return` `((``2` `* i )+ ``1``); }``    ``int` `right(``int` `i) { ``return` `((``2` `* i) + ``2``); }``    ``int` `getMin() { ``return` `harr[``0``]; } ``// Returns minimum` `    ``// to replace root with new node x and heapify() new root``    ``void` `replaceMax(``int` `x)``    ``{``      ``this``.harr[``0``] = x;``      ``minHeapify(``0``);``    ``}``    ``MinHeap(``int` `a[], ``int` `size)``    ``{``      ``heap_size = size;``      ``harr = a; ``// store address of array``      ``int` `i = (heap_size - ``1``) / ``2``;``      ``while` `(i >= ``0``)``      ``{``        ``minHeapify(i);``        ``i--;``      ``}``    ``}` `    ``// Method to remove maximum element (or root) from min heap``    ``int` `extractMin()``    ``{``      ``if` `(heap_size == ``0``)``        ``return` `Integer.MAX_VALUE;` `      ``// Store the maximum value.``      ``int` `root = harr[``0``];` `      ``// If there are more than 1 items, move the last item to root``      ``// and call heapify.``      ``if` `(heap_size > ``1``)``      ``{``        ``harr[``0``] = harr[heap_size - ``1``];``        ``minHeapify(``0``);``      ``}``      ``heap_size--;``      ``return` `root;``    ``}` `    ``// A recursive method to heapify a subtree with root at given index``    ``// This method assumes that the subtrees are already heapified``    ``void` `minHeapify(``int` `i)``    ``{``      ``int` `l = left(i);``      ``int` `r = right(i);``      ``int` `smallest = i;``      ``if` `(l < heap_size && harr[l] < harr[i])``        ``smallest = l;``      ``if` `(r < heap_size && harr[r] < harr[smallest])``        ``smallest = r;``      ``if` `(smallest != i)``      ``{``        ``int` `t = harr[i];``        ``harr[i] = harr[smallest];``        ``harr[smallest] = t;``        ``minHeapify(smallest);``      ``}``    ``}``  ``};` `  ``// Function to return k'th largest element in a given array``  ``int` `kthSmallest(``int` `arr[], ``int` `n, ``int` `k)``  ``{` `    ``// Build a heap of first k elements: O(k) time``    ``MinHeap mh = ``new` `MinHeap(arr, n);` `    ``// Process remaining n-k elements. If current element is``    ``// smaller than root, replace root with current element``    ``for` `(``int` `i = ``0``; i < k - ``1``; i++)``      ``mh.extractMin();` `    ``// Return root``    ``return` `mh.getMin();``  ``}` `  ``// Driver program to test above methods``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `arr[] = { ``12``, ``3``, ``5``, ``7``, ``19` `};``    ``int` `n = arr.length, k = ``2``;``    ``GFG gfg = ``new` `GFG();``    ``System.out.print(``"K'th smallest element is "` `+``                     ``gfg.kthSmallest(arr, n, k));``  ``}``}` `// This code is contributed by avanitrachhadiya2155`

Python3

 `# Python3 program to find k'th smallest element``# using min heap` `# Class for Min Heap``class` `MinHeap:``  ` `    ``# Constructor``    ``def` `__init__(``self``, a, size):``      ` `        ``# list of elements in the heap``        ``self``.harr ``=` `a``        ` `        ``# maximum possible size of min heap``        ``self``.capacity ``=` `None``        ` `        ``# current number of elements in min heap``        ``self``.heap_size ``=` `size` `        ``i ``=` `int``((``self``.heap_size ``-` `1``) ``/` `2``)``        ``while` `i >``=` `0``:``            ``self``.minHeapify(i)``            ``i ``-``=` `1` `    ``def` `parent(``self``, i):``        ``return` `(i ``-` `1``) ``/` `2` `    ``def` `left(``self``, i):``        ``return` `2` `*` `i ``+` `1` `    ``def` `right(``self``, i):``        ``return` `2` `*` `i ``+` `2` `    ``# Returns minimum``    ``def` `getMin(``self``):``        ``return` `self``.harr[``0``]` `    ``# Method to remove minimum element (or root)``    ``# from min heap``    ``def` `extractMin(``self``):``        ``if` `self``.heap_size ``=``=` `0``:``            ``return` `float``(``"inf"``)` `        ``# Store the minimum value``        ``root ``=` `self``.harr[``0``]` `        ``# If there are more than 1 items, move the last item``        ``# to root and call heapify``        ``if` `self``.heap_size > ``1``:``            ``self``.harr[``0``] ``=` `self``.harr[``self``.heap_size ``-` `1``]``            ``self``.minHeapify(``0``)``        ``self``.heap_size ``-``=` `1``        ``return` `root` `    ``# A recursive method to heapify a subtree with root at``    ``# given index. This method assumes that the subtrees``    ``# are already heapified``    ``def` `minHeapify(``self``, i):``        ``l ``=` `self``.left(i)``        ``r ``=` `self``.right(i)``        ``smallest ``=` `i``        ``if` `((l < ``self``.heap_size) ``and``            ``(``self``.harr[l] < ``self``.harr[i])):``            ``smallest ``=` `l``        ``if` `((r < ``self``.heap_size) ``and``            ``(``self``.harr[r] < ``self``.harr[smallest])):``            ``smallest ``=` `r``        ``if` `smallest !``=` `i:``            ``self``.harr[i], ``self``.harr[smallest] ``=` `(``                ``self``.harr[smallest], ``self``.harr[i])``            ``self``.minHeapify(smallest)` `# Function to return k'th smallest element in a given array``def` `kthSmallest(arr, n, k):``  ` `    ``# Build a heap of n elements in O(n) time``    ``mh ``=` `MinHeap(arr, n)` `    ``# Do extract min (k-1) times``    ``for` `i ``in` `range``(k ``-` `1``):``        ``mh.extractMin()` `    ``# Return root``    ``return` `mh.getMin()` `# Driver code``arr ``=` `[``12``, ``3``, ``5``, ``7``, ``19``]``n ``=` `len``(arr)``k ``=` `2``print``(``"K'th smallest element is"``, kthSmallest(arr, n, k))` `# This Code is contributed by Kevin Joshi`

C#

 `using` `System;``public` `class` `GFG``{` `  ``public` `class` `MinHeap``  ``{``    ``int``[] harr; ``// pointer to array of elements in heap``    ``//    int capacity; // maximum possible size of min heap``    ``int` `heap_size; ``// Current number of elements in min heap` `    ``int` `parent(``int` `i) { ``return` `(i - 1) / 2; }``    ``int` `left(``int` `i) { ``return` `((2 * i )+ 1); }``    ``int` `right(``int` `i) { ``return` `((2 * i) + 2); }``    ``public` `int` `getMin() { ``return` `harr[0]; } ``// Returns minimum` `    ``// to replace root with new node x and heapify() new root``    ``public` `void` `replaceMax(``int` `x)``    ``{``      ``this``.harr[0] = x;``      ``minHeapify(0);``    ``}` `    ``public` `MinHeap(``int``[] a, ``int` `size)``    ``{``      ``heap_size = size;``      ``harr = a; ``// store address of array``      ``int` `i = (heap_size - 1) / 2;``      ``while` `(i >= 0)``      ``{``        ``minHeapify(i);``        ``i--;``      ``}``    ``}` `    ``// Method to remove maximum element (or root) from min heap``    ``public` `int` `extractMin()``    ``{``      ``if` `(heap_size == 0)``        ``return` `Int32.MaxValue;` `      ``// Store the maximum value.``      ``int` `root = harr[0];` `      ``// If there are more than 1 items, move the last item to root``      ``// and call heapify.``      ``if` `(heap_size > 1)``      ``{``        ``harr[0] = harr[heap_size - 1];``        ``minHeapify(0);``      ``}``      ``heap_size--;``      ``return` `root;``    ``}` `    ``// A recursive method to heapify a subtree with root at given index``    ``// This method assumes that the subtrees are already heapified``    ``public` `void` `minHeapify(``int` `i)``    ``{``      ``int` `l = left(i);``      ``int` `r = right(i);``      ``int` `smallest = i;``      ``if` `(l < heap_size && harr[l] < harr[i])``        ``smallest = l;``      ``if` `(r < heap_size && harr[r] < harr[smallest])``        ``smallest = r;``      ``if` `(smallest != i)``      ``{``        ``int` `t = harr[i];``        ``harr[i] = harr[smallest];``        ``harr[smallest] = t;``        ``minHeapify(smallest);``      ``}``    ``}``  ``};` `  ``// Function to return k'th largest element in a given array``  ``int` `kthSmallest(``int``[] arr, ``int` `n, ``int` `k)``  ``{` `    ``// Build a heap of first k elements: O(k) time``    ``MinHeap mh = ``new` `MinHeap(arr, n);` `    ``// Process remaining n-k elements. If current element is``    ``// smaller than root, replace root with current element``    ``for` `(``int` `i = 0; i < k - 1; i++)``      ``mh.extractMin();` `    ``// Return root``    ``return` `mh.getMin();``  ``}` `  ``// Driver program to test above methods``  ``static` `public` `void` `Main (){``    ``int``[] arr = { 12, 3, 5, 7, 19 };``    ``int` `n = arr.Length, k = 2;``    ``GFG gfg = ``new` `GFG();``    ``Console.Write(``"K'th smallest element is "` `+``                  ``gfg.kthSmallest(arr, n, k));``  ``}``}` `// This code is contributed by rag2127`

Javascript

 ``

Output

`K'th smallest element is 5`

Time complexity: O(n + kLogn).

Space complexity: O(n) for call stack

Method 4 (Using Max-Heap)
We can also use Max Heap for finding the k’th smallest element. Following is an algorithm.
1) Build a Max-Heap MH of the first k elements (arr[0] to arr[k-1]) of the given array. O(k)
2) For each element, after the k’th element (arr[k] to arr[n-1]), compare it with root of MH.
……a) If the element is less than the root then make it root and call heapify for MH
……b) Else ignore it.
// The step 2 is O((n-k)*logk)
3) Finally, the root of the MH is the kth smallest element.
Time complexity of this solution is O(k + (n-k)*Logk)

The following is C++ implementation of the above algorithm

C++

 `// A C++ program to find k'th smallest element using max heap``#include ``#include ``using` `namespace` `std;` `// Prototype of a utility function to swap two integers``void` `swap(``int``* x, ``int``* y);` `// A class for Max Heap``class` `MaxHeap {``    ``int``* harr; ``// pointer to array of elements in heap``    ``int` `capacity; ``// maximum possible size of max heap``    ``int` `heap_size; ``// Current number of elements in max heap``public``:``    ``MaxHeap(``int` `a[], ``int` `size); ``// Constructor``    ``void` `maxHeapify(``int` `i); ``// To maxHeapify subtree rooted with index i``    ``int` `parent(``int` `i) { ``return` `(i - 1) / 2; }``    ``int` `left(``int` `i) { ``return` `(2 * i + 1); }``    ``int` `right(``int` `i) { ``return` `(2 * i + 2); }` `    ``int` `extractMax(); ``// extracts root (maximum) element``    ``int` `getMax() { ``return` `harr[0]; } ``// Returns maximum` `    ``// to replace root with new node x and heapify() new root``    ``void` `replaceMax(``int` `x)``    ``{``        ``harr[0] = x;``        ``maxHeapify(0);``    ``}``};` `MaxHeap::MaxHeap(``int` `a[], ``int` `size)``{``    ``heap_size = size;``    ``harr = a; ``// store address of array``    ``int` `i = (heap_size - 1) / 2;``    ``while` `(i >= 0) {``        ``maxHeapify(i);``        ``i--;``    ``}``}` `// Method to remove maximum element (or root) from max heap``int` `MaxHeap::extractMax()``{``    ``if` `(heap_size == 0)``        ``return` `INT_MAX;` `    ``// Store the maximum value.``    ``int` `root = harr[0];` `    ``// If there are more than 1 items, move the last item to root``    ``// and call heapify.``    ``if` `(heap_size > 1) {``        ``harr[0] = harr[heap_size - 1];``        ``maxHeapify(0);``    ``}``    ``heap_size--;` `    ``return` `root;``}` `// A recursive method to heapify a subtree with root at given index``// This method assumes that the subtrees are already heapified``void` `MaxHeap::maxHeapify(``int` `i)``{``    ``int` `l = left(i);``    ``int` `r = right(i);``    ``int` `largest = i;``    ``if` `(l < heap_size && harr[l] > harr[i])``        ``largest = l;``    ``if` `(r < heap_size && harr[r] > harr[largest])``        ``largest = r;``    ``if` `(largest != i) {``        ``swap(&harr[i], &harr[largest]);``        ``maxHeapify(largest);``    ``}``}` `// A utility function to swap two elements``void` `swap(``int``* x, ``int``* y)``{``    ``int` `temp = *x;``    ``*x = *y;``    ``*y = temp;``}` `// Function to return k'th largest element in a given array``int` `kthSmallest(``int` `arr[], ``int` `n, ``int` `k)``{``    ``// Build a heap of first k elements: O(k) time``    ``MaxHeap mh(arr, k);` `    ``// Process remaining n-k elements.  If current element is``    ``// smaller than root, replace root with current element``    ``for` `(``int` `i = k; i < n; i++)``        ``if` `(arr[i] < mh.getMax())``            ``mh.replaceMax(arr[i]);` `    ``// Return root``    ``return` `mh.getMax();``}` `// Driver program to test above methods``int` `main()``{``    ``int` `arr[] = { 12, 3, 5, 7, 19 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]), k = 4;``    ``cout << ``"K'th smallest element is "` `<< kthSmallest(arr, n, k);``    ``return` `0;``}`

Java

 `// A Java program to find k'th smallest element using max heap``import` `java.util.*;``class` `GFG``{` `  ``// A class for Max Heap``  ``class` `MaxHeap``  ``{``    ``int``[] harr; ``// pointer to array of elements in heap``    ``int` `capacity; ``// maximum possible size of max heap``    ``int` `heap_size; ``// Current number of elements in max heap` `    ``int` `parent(``int` `i) { ``return` `(i - ``1``) / ``2``; }``    ``int` `left(``int` `i) { ``return` `(``2` `* i + ``1``); }``    ``int` `right(``int` `i) { ``return` `(``2` `* i + ``2``); }``    ``int` `getMax() { ``return` `harr[``0``]; } ``// Returns maximum` `    ``// to replace root with new node x and heapify() new root``    ``void` `replaceMax(``int` `x)``    ``{``      ``this``.harr[``0``] = x;``      ``maxHeapify(``0``);``    ``}``    ``MaxHeap(``int` `a[], ``int` `size)``    ``{``      ``heap_size = size;``      ``harr = a; ``// store address of array``      ``int` `i = (heap_size - ``1``) / ``2``;``      ``while` `(i >= ``0``)``      ``{``        ``maxHeapify(i);``        ``i--;``      ``}``    ``}` `    ``// Method to remove maximum element (or root) from max heap``    ``int` `extractMax()``    ``{``      ``if` `(heap_size == ``0``)``        ``return` `Integer.MAX_VALUE;` `      ``// Store the maximum value.``      ``int` `root = harr[``0``];` `      ``// If there are more than 1 items, move the last item to root``      ``// and call heapify.``      ``if` `(heap_size > ``1``)``      ``{``        ``harr[``0``] = harr[heap_size - ``1``];``        ``maxHeapify(``0``);``      ``}``      ``heap_size--;``      ``return` `root;``    ``}` `    ``// A recursive method to heapify a subtree with root at given index``    ``// This method assumes that the subtrees are already heapified``    ``void` `maxHeapify(``int` `i)``    ``{``      ``int` `l = left(i);``      ``int` `r = right(i);``      ``int` `largest = i;``      ``if` `(l < heap_size && harr[l] > harr[i])``        ``largest = l;``      ``if` `(r < heap_size && harr[r] > harr[largest])``        ``largest = r;``      ``if` `(largest != i)``      ``{``        ``int` `t = harr[i];``        ``harr[i] = harr[largest];``        ``harr[largest] = t;``        ``maxHeapify(largest);``      ``}``    ``}``  ``};` `  ``// Function to return k'th largest element in a given array``  ``int` `kthSmallest(``int` `arr[], ``int` `n, ``int` `k)``  ``{` `    ``// Build a heap of first k elements: O(k) time``    ``MaxHeap mh = ``new` `MaxHeap(arr, k);` `    ``// Process remaining n-k elements.  If current element is``    ``// smaller than root, replace root with current element``    ``for` `(``int` `i = k; i < n; i++)``      ``if` `(arr[i] < mh.getMax())``        ``mh.replaceMax(arr[i]);` `    ``// Return root``    ``return` `mh.getMax();``  ``}` `  ``// Driver program to test above methods``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `arr[] = { ``12``, ``3``, ``5``, ``7``, ``19` `};``    ``int` `n = arr.length, k = ``4``;``    ``GFG gfg = ``new` `GFG();``    ``System.out.print(``"K'th smallest element is "` `+ ``                     ``gfg.kthSmallest(arr, n, k));``  ``}``}` `// This code is contributed by Rajput-Ji`

Python3

 `# Python3 program to find k'th smallest element``# using max heap` `# Class for Max Heap``class` `MaxHeap:``    ``# Constructor``    ``def` `__init__(``self``, a, size):``        ``# list of elements in the heap``        ``self``.harr ``=` `a``        ``# maximum possible size of max heap``        ``self``.capacity ``=` `None``        ``# current number of elements in max heap``        ``self``.heap_size ``=` `size` `        ``i ``=` `int``((``self``.heap_size ``-` `1``) ``/` `2``)``        ``while` `i >``=` `0``:``            ``self``.maxHeapify(i)``            ``i ``-``=` `1` `    ``def` `parent(``self``, i):``        ``return` `(i ``-` `1``) ``/` `2` `    ``def` `left(``self``, i):``        ``return` `2` `*` `i ``+` `1` `    ``def` `right(``self``, i):``        ``return` `2` `*` `i ``+` `2` `    ``# Returns maximum``    ``def` `getMax(``self``):``        ``return` `self``.harr[``0``]` `    ``# to replace root with new node x and heapify() new root``    ``def` `replaceMax(``self``, x):``        ``self``.harr[``0``] ``=` `x``        ``self``.maxHeapify(``0``)` `    ``# Method to remove maximum element (or root)``    ``# from max heap``    ``def` `extractMin(``self``):``        ``if` `self``.heap_size ``=``=` `0``:``            ``return` `float``(``"inf"``)` `        ``# Store the maximum value.``        ``root ``=` `self``.harr[``0``]` `        ``# If there are more than 1 items, move the``        ``# last item to root and call heapify``        ``if` `self``.heap_size > ``1``:``            ``self``.harr[``0``] ``=` `self``.harr[``self``.heap_size ``-` `1``]``            ``self``.maxHeapify(``0``)``        ``self``.heap_size ``-``=` `1``        ``return` `root` `    ``# A recursive method to heapify a subtree with root at``    ``# given index. This method assumes that the subtrees``    ``# are already heapified``    ``def` `maxHeapify(``self``, i):``        ``l ``=` `self``.left(i)``        ``r ``=` `self``.right(i)``        ``largest ``=` `i``        ``if` `((l < ``self``.heap_size) ``and``            ``(``self``.harr[l] > ``self``.harr[i])):``            ``largest ``=` `l``        ``if` `((r < ``self``.heap_size) ``and``            ``(``self``.harr[r] > ``self``.harr[largest])):``            ``largest ``=` `r``        ``if` `largest !``=` `i:``            ``self``.harr[i], ``self``.harr[largest] ``=` `(``                ``self``.harr[largest], ``self``.harr[i])``            ``self``.maxHeapify(largest)`  `# Function to return k'th smallest element in a given array``def` `kthSmallest(arr, n, k):``    ``# Build a heap of first k elements in O(k) time``    ``mh ``=` `MaxHeap(arr, k)` `    ``# Process remaining n-k elements. If current element is``    ``# smaller than root, replace root with current element``    ``for` `i ``in` `range``(k, n):``        ``if` `arr[i] < mh.getMax():``            ``mh.replaceMax(arr[i])` `    ``# Return root``    ``return` `mh.getMax()`  `# Driver code``arr ``=` `[``12``, ``3``, ``5``, ``7``, ``19``]``n ``=` `len``(arr)``k ``=` `4``print``(``"K'th smallest element is"``, kthSmallest(arr, n, k))` `# Code contributed by Kevin Joshi`

C#

 `// A C# program to find k'th smallest element using max heap``using` `System;` `public` `class` `GFG {` `    ``// A class for Max Heap``    ``public` `        ``class` `MaxHeap {``        ``public` `            ``int``[] harr; ``// pointer to array of elements in``                        ``// heap``        ``public` `            ``int` `capacity; ``// maximum possible size of max``                          ``// heap``        ``public` `            ``int` `heap_size; ``// Current number of elements in``                           ``// max heap` `        ``public` `            ``int``            ``parent(``int` `i)``        ``{``            ``return` `(i - 1) / 2;``        ``}``        ``public` `            ``int``            ``left(``int` `i)``        ``{``            ``return` `(2 * i + 1);``        ``}``        ``public` `            ``int``            ``right(``int` `i)``        ``{``            ``return` `(2 * i + 2);``        ``}``        ``public` `            ``int``            ``getMax()``        ``{``            ``return` `harr[0];``        ``} ``// Returns maximum` `        ``// to replace root with new node x and heapify() new``        ``// root``        ``public` `            ``void``            ``replaceMax(``int` `x)``        ``{``            ``this``.harr[0] = x;``            ``maxHeapify(0);``        ``}``        ``public` `            ``MaxHeap(``int``[] a, ``int` `size)``        ``{``            ``heap_size = size;``            ``harr = a; ``// store address of array``            ``int` `i = (heap_size - 1) / 2;``            ``while` `(i >= 0) {``                ``maxHeapify(i);``                ``i--;``            ``}``        ``}` `        ``// Method to remove maximum element (or root) from``        ``// max heap``        ``public` `            ``int``            ``extractMax()``        ``{``            ``if` `(heap_size == 0)``                ``return` `int``.MaxValue;` `            ``// Store the maximum value.``            ``int` `root = harr[0];` `            ``// If there are more than 1 items, move the last``            ``// item to root and call heapify.``            ``if` `(heap_size > 1) {``                ``harr[0] = harr[heap_size - 1];``                ``maxHeapify(0);``            ``}``            ``heap_size--;``            ``return` `root;``        ``}` `        ``// A recursive method to heapify a subtree with root``        ``// at given index This method assumes that the``        ``// subtrees are already heapified``        ``public` `            ``void``            ``maxHeapify(``int` `i)``        ``{``            ``int` `l = left(i);``            ``int` `r = right(i);``            ``int` `largest = i;``            ``if` `(l < heap_size && harr[l] > harr[i])``                ``largest = l;``            ``if` `(r < heap_size && harr[r] > harr[largest])``                ``largest = r;``            ``if` `(largest != i) {``                ``int` `t = harr[i];``                ``harr[i] = harr[largest];``                ``harr[largest] = t;``                ``maxHeapify(largest);``            ``}``        ``}``    ``};` `    ``// Function to return k'th largest element in a given``    ``// array``    ``int` `kthSmallest(``int``[] arr, ``int` `n, ``int` `k)``    ``{` `        ``// Build a heap of first k elements: O(k) time``        ``MaxHeap mh = ``new` `MaxHeap(arr, k);` `        ``// Process remaining n-k elements.  If current``        ``// element is smaller than root, replace root with``        ``// current element``        ``for` `(``int` `i = k; i < n; i++)``            ``if` `(arr[i] < mh.getMax())``                ``mh.replaceMax(arr[i]);` `        ``// Return root``        ``return` `mh.getMax();``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int``[] arr = { 12, 3, 5, 7, 19 };``        ``int` `n = arr.Length, k = 4;``        ``GFG gfg = ``new` `GFG();``        ``Console.Write(``"K'th smallest element is "``                      ``+ gfg.kthSmallest(arr, n, k));``    ``}``}` `// This code is contributed by gauravrajput1`

Output

`K'th smallest element is 12`

Method 5 (QuickSelect)
This is an optimization over method 1 if QuickSort is used as a sorting algorithm in first step. In QuickSort, we pick a pivot element, then move the pivot element to its correct position and partition the surrounding array. The idea is, not to do complete quicksort, but stop at the point where pivot itself is k’th smallest element. Also, not to recur for both left and right sides of pivot, but recur for one of them according to the position of pivot. The worst case time complexity of this method is O(n2), but it works in O(n) on average.

C++

 `#include ``#include ``using` `namespace` `std;` `int` `partition(``int` `arr[], ``int` `l, ``int` `r);` `// This function returns k'th smallest element in arr[l..r] using``// QuickSort based method.  ASSUMPTION: ALL ELEMENTS IN ARR[] ARE DISTINCT``int` `kthSmallest(``int` `arr[], ``int` `l, ``int` `r, ``int` `k)``{``    ``// If k is smaller than number of elements in array``    ``if` `(k > 0 && k <= r - l + 1) {``        ``// Partition the array around last element and get``        ``// position of pivot element in sorted array``        ``int` `pos = partition(arr, l, r);` `        ``// If position is same as k``        ``if` `(pos - l == k - 1)``            ``return` `arr[pos];``        ``if` `(pos - l > k - 1) ``// If position is more, recur for left subarray``            ``return` `kthSmallest(arr, l, pos - 1, k);` `        ``// Else recur for right subarray``        ``return` `kthSmallest(arr, pos + 1, r, k - pos + l - 1);``    ``}` `    ``// If k is more than number of elements in array``    ``return` `INT_MAX;``}` `void` `swap(``int``* a, ``int``* b)``{``    ``int` `temp = *a;``    ``*a = *b;``    ``*b = temp;``}` `// Standard partition process of QuickSort().  It considers the last``// element as pivot and moves all smaller element to left of it``// and greater elements to right``int` `partition(``int` `arr[], ``int` `l, ``int` `r)``{``    ``int` `x = arr[r], i = l;``    ``for` `(``int` `j = l; j <= r - 1; j++) {``        ``if` `(arr[j] <= x) {``            ``swap(&arr[i], &arr[j]);``            ``i++;``        ``}``    ``}``    ``swap(&arr[i], &arr[r]);``    ``return` `i;``}` `// Driver program to test above methods``int` `main()``{``    ``int` `arr[] = { 12, 3, 5, 7, 4, 19, 26 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]), k = 3;``    ``cout << ``"K'th smallest element is "` `<< kthSmallest(arr, 0, n - 1, k);``    ``return` `0;``}`

Java

 `// Java code for kth smallest element in an array``import` `java.util.Arrays;``import` `java.util.Collections;` `class` `GFG {``    ``// Standard partition process of QuickSort.``    ``// It considers the last element as pivot``    ``// and moves all smaller element to left of``    ``// it and greater elements to right``    ``public` `static` `int` `partition(Integer[] arr, ``int` `l,``                                ``int` `r)``    ``{``        ``int` `x = arr[r], i = l;``        ``for` `(``int` `j = l; j <= r - ``1``; j++) {``            ``if` `(arr[j] <= x) {``                ``// Swapping arr[i] and arr[j]``                ``int` `temp = arr[i];``                ``arr[i] = arr[j];``                ``arr[j] = temp;` `                ``i++;``            ``}``        ``}` `        ``// Swapping arr[i] and arr[r]``        ``int` `temp = arr[i];``        ``arr[i] = arr[r];``        ``arr[r] = temp;` `        ``return` `i;``    ``}` `    ``// This function returns k'th smallest element``    ``// in arr[l..r] using QuickSort based method.``    ``// ASSUMPTION: ALL ELEMENTS IN ARR[] ARE DISTINCT``    ``public` `static` `int` `kthSmallest(Integer[] arr, ``int` `l,``                                  ``int` `r, ``int` `k)``    ``{``        ``// If k is smaller than number of elements``        ``// in array``        ``if` `(k > ``0` `&& k <= r - l + ``1``) {``            ``// Partition the array around last``            ``// element and get position of pivot``            ``// element in sorted array``            ``int` `pos = partition(arr, l, r);` `            ``// If position is same as k``            ``if` `(pos - l == k - ``1``)``                ``return` `arr[pos];` `            ``// If position is more, recur for``            ``// left subarray``            ``if` `(pos - l > k - ``1``)``                ``return` `kthSmallest(arr, l, pos - ``1``, k);` `            ``// Else recur for right subarray``            ``return` `kthSmallest(arr, pos + ``1``, r, k - pos + l - ``1``);``        ``}` `        ``// If k is more than number of elements``        ``// in array``        ``return` `Integer.MAX_VALUE;``    ``}` `    ``// Driver program to test above methods``    ``public` `static` `void` `main(String[] args)``    ``{``        ``Integer arr[] = ``new` `Integer[] { ``12``, ``3``, ``5``, ``7``, ``4``, ``19``, ``26` `};``        ``int` `k = ``3``;``        ``System.out.print(``"K'th smallest element is "` `+ kthSmallest(arr, ``0``, arr.length - ``1``, k));``    ``}``}` `// This code is contributed by Chhavi`

Python3

 `# This function returns k'th smallest element``# in arr[l..r] using QuickSort based method.``# ASSUMPTION: ALL ELEMENTS IN ARR[] ARE DISTINCT``import` `sys` `def` `kthSmallest(arr, l, r, k):` `    ``# If k is smaller than number of``    ``# elements in array``    ``if` `(k > ``0` `and` `k <``=` `r ``-` `l ``+` `1``):``    ` `        ``# Partition the array around last``        ``# element and get position of pivot``        ``# element in sorted array``        ``pos ``=` `partition(arr, l, r)` `        ``# If position is same as k``        ``if` `(pos ``-` `l ``=``=` `k ``-` `1``):``            ``return` `arr[pos]``        ``if` `(pos ``-` `l > k ``-` `1``): ``# If position is more,``                              ``# recur for left subarray``            ``return` `kthSmallest(arr, l, pos ``-` `1``, k)` `        ``# Else recur for right subarray``        ``return` `kthSmallest(arr, pos ``+` `1``, r,``                            ``k ``-` `pos ``+` `l ``-` `1``)` `    ``# If k is more than number of``    ``# elements in array``    ``return` `sys.maxsize` `# Standard partition process of QuickSort().``# It considers the last element as pivot and``# moves all smaller element to left of it``# and greater elements to right``def` `partition(arr, l, r):` `    ``x ``=` `arr[r]``    ``i ``=` `l``    ``for` `j ``in` `range``(l, r):``        ``if` `(arr[j] <``=` `x):``            ``arr[i], arr[j] ``=` `arr[j], arr[i]``            ``i ``+``=` `1``    ``arr[i], arr[r] ``=` `arr[r], arr[i]``    ``return` `i` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``arr ``=` `[``12``, ``3``, ``5``, ``7``, ``4``, ``19``, ``26``]``    ``n ``=` `len``(arr)``    ``k ``=` `3``;``    ``print``(``"K'th smallest element is"``,``           ``kthSmallest(arr, ``0``, n ``-` `1``, k))` `# This code is contributed by ita_c`

C#

 `// C# code for kth smallest element``// in an array``using` `System;` `class` `GFG {` `    ``// Standard partition process of QuickSort.``    ``// It considers the last element as pivot``    ``// and moves all smaller element to left of``    ``// it and greater elements to right``    ``public` `static` `int` `partition(``int``[] arr,``                                ``int` `l, ``int` `r)``    ``{``        ``int` `x = arr[r], i = l;``        ``int` `temp = 0;``        ``for` `(``int` `j = l; j <= r - 1; j++) {` `            ``if` `(arr[j] <= x) {``                ``// Swapping arr[i] and arr[j]``                ``temp = arr[i];``                ``arr[i] = arr[j];``                ``arr[j] = temp;` `                ``i++;``            ``}``        ``}` `        ``// Swapping arr[i] and arr[r]``        ``temp = arr[i];``        ``arr[i] = arr[r];``        ``arr[r] = temp;` `        ``return` `i;``    ``}` `    ``// This function returns k'th smallest``    ``// element in arr[l..r] using QuickSort``    ``// based method. ASSUMPTION: ALL ELEMENTS``    ``// IN ARR[] ARE DISTINCT``    ``public` `static` `int` `kthSmallest(``int``[] arr, ``int` `l,``                                  ``int` `r, ``int` `k)``    ``{``        ``// If k is smaller than number``        ``// of elements in array``        ``if` `(k > 0 && k <= r - l + 1) {``            ``// Partition the array around last``            ``// element and get position of pivot``            ``// element in sorted array``            ``int` `pos = partition(arr, l, r);` `            ``// If position is same as k``            ``if` `(pos - l == k - 1)``                ``return` `arr[pos];` `            ``// If position is more, recur for``            ``// left subarray``            ``if` `(pos - l > k - 1)``                ``return` `kthSmallest(arr, l, pos - 1, k);` `            ``// Else recur for right subarray``            ``return` `kthSmallest(arr, pos + 1, r,``                               ``k - pos + l - 1);``        ``}` `        ``// If k is more than number``        ``// of elements in array``        ``return` `int``.MaxValue;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 12, 3, 5, 7, 4, 19, 26 };``        ``int` `k = 3;``        ``Console.Write(``"K'th smallest element is "` `+ kthSmallest(arr, 0, arr.Length - 1, k));``    ``}``}` `// This code is contributed``// by 29AjayKumar`

Javascript

 ``

Output

`K'th smallest element is 5`

Method 6 (Map STL)

A map-based STL approach is although very much similar to the quickselect and counting sort algorithm but much easier to implement. We can use an ordered map and map each element with its frequency. And as we know that an ordered map would store the data in a sorted manner, we keep on adding the frequency of each element till it does not become greater than or equal to k so that we reach the k’th element from the start i.e. the k’th smallest element.

Eg –

Array={7,0,25,6,16,17,0}

k=3

Now in order to get the k’th largest element, we need to add the frequencies till it becomes greater than or equal to 3. It is clear from the above that the frequency of 0 + frequency of 6 will become equal to 3 so the third smallest number in the array will be 6.

We can achieve the above using an iterator to traverse the map.

C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;``int` `Kth_smallest(map<``int``, ``int``> m, ``int` `k)``{``    ``int` `freq = 0;``    ``for` `(``auto` `it = m.begin(); it != m.end(); it++) {``        ``freq += (it->second); ``// adding the frequencies of``                              ``// each element``        ``if` `(freq >= k) ``// if at any point frequency becomes``                       ``// greater than or equal to k then``                       ``// return that element``        ``{``            ``return` `it->first;``        ``}``    ``}``    ``return` `-1; ``// returning -1 if k>size of the array which``               ``// is an impossible scenario``}``int` `main()``{``    ``int` `n = 5;``    ``int` `k = 2;``    ``vector<``int``> arr = { 12, 3, 5, 7, 19 };``    ``map<``int``, ``int``> m;``    ``for` `(``int` `i = 0; i < n; i++) {``        ``m[arr[i]] += 1; ``// mapping every element with it's``                        ``// frequency``    ``}``    ``int` `ans = Kth_smallest(m, k);``  ``if``(k==1){``    ``cout << ``"The "` `<< k << ``"st smallest element is "` `<< ans``         ``<< endl;``  ``}``  ``else` `if``(k==2){``    ``cout << ``"The "` `<< k << ``"nd smallest element is "` `<< ans``         ``<< endl;``  ``}``  ``else` `if``(k==3){``    ``cout << ``"The "` `<< k << ``"rd smallest element is "` `<< ans``         ``<< endl;``  ``}``  ``else``{``    ``cout << ``"The "` `<< k << ``"th smallest element is "` `<< ans``         ``<< endl;``  ``}``    ``return` `0;``}`

Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG {``    ``static` `int` `Kth_smallest(TreeMap m,``                            ``int` `k)``    ``{``        ``int` `freq = ``0``;``        ``for` `(Map.Entry it : m.entrySet())``        ``{``          ` `            ``// adding the frequencies of each element``            ``freq += (``int``)it.getValue();` `            ``// if at any point frequency becomes``            ``// greater than or equal to k then``            ``// return that element``            ``if` `(freq >= k) {``                ``return` `(``int``)it.getKey();``            ``}``        ``}` `        ``return` `-``1``; ``// returning -1 if k>size of the array``                   ``// which is an impossible scenario``    ``}``  ` `  ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``5``;``        ``int` `k = ``2``;``        ``int``[] arr = { ``12``, ``3``, ``5``, ``7``, ``19` `};``        ``TreeMap m = ``new` `TreeMap<>();``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``// mapping every element with``            ``// it's``            ``// frequency``            ``m.put(arr[i], m.getOrDefault(arr[i], ``0``) + ``1``);``        ``}``        ``int` `ans = Kth_smallest(m, k);``        ``if``(k==``1``){``    ``System.out.println(``            ``"The "` `+ k + ``"st smallest element is "` `+ ans);``  ``}``  ``else` `if``(k==``2``){``    ``System.out.println(``            ``"The "` `+ k + ``"nd smallest element is "` `+ ans);``  ``}``  ``else` `if``(k==``3``){``    ``System.out.println(``            ``"The "` `+ k + ``"rd smallest element is "` `+ ans);``  ``}``  ``else``{``    ``System.out.println(``            ``"The "` `+ k + ``"th smallest element is "` `+ ans);``  ``}``        ` `    ``}``}` `// This code is contributed by harshit17.`

Python3

 `# Python3 program for the above approach` `def` `Kth_smallest(m, k):` `    ``freq ``=` `0``    ``for` `it ``in` `sorted``(m.keys()):``        ``freq ``+``=` `m[it] ``# adding the frequencies of``                      ``# each element``        ``if` `freq >``=` `k: ``# if at any point frequency becomes``            ``return` `it   ``# greater than or equal to k then``                        ``# return that element``    ``return` `-``1`  `# returning -1 if k>size of the array which``               ``# is an impossible scenario``    ` `    ` `# driver code``n ``=` `5``;``k ``=` `2``;``arr ``=` `[ ``12``, ``3``, ``5``, ``7``, ``19` `]``m ``=` `{}``for` `i ``in` `range``(n):``    ``if` `arr[i] ``in` `m:    ``# mapping every element with it's                     ``        ``m[arr[i]] ``=` `m[arr[i]] ``+` `1`  `# frequency``    ``else``:``        ``m[arr[i]] ``=` `1``          ` `ans ``=` `Kth_smallest(m, k)``if``(k``=``=``1``):``    ``print``(``"The "` `, k ,``"st smallest element is "` `,ans)``elif``(k``=``=``2``):``    ``print``(``"The "` `, k ,``"nd smallest element is "` `,ans)``elif``(k``=``=``2``):``    ``print``(``"The "` `, k ,``"rd smallest element is "` `,ans)``else``:``    ``print``(``"The "` `, k ,``"th smallest element is "` `,ans)``    ` `# This code is contributed by Abhijeet Kumar(abhijeet19403)`

C#

 `// C# program for the above approach` `using` `System;``using` `System.Collections;``using` `System.Collections.Generic;` `public` `class` `GFG {``    ``static` `int` `Kth_smallest(SortedDictionary<``int``, ``int``> m,``                            ``int` `k)``    ``{``        ``int` `freq = 0;``        ``foreach``(``var` `it ``in` `m) {` `            ``// adding the frequencies of each element``            ``freq += (``int``)it.Value;` `            ``// if at any point frequency becomes``            ``// greater than or equal to k then``            ``// return that element``            ``if` `(freq >= k) {``                ``return` `(``int``)it.Key;``            ``}``        ``}` `        ``return` `-1; ``// returning -1 if k>size of the array``                   ``// which is an impossible scenario``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `n = 5;``        ``int` `k = 2;``        ``int``[] arr = { 12, 3, 5, 7, 19 };``        ``SortedDictionary<``int``, ``int``> m =``            ``new` `SortedDictionary<``int``, ``int``>();``        ``for` `(``int` `i = 0; i < n; i++) {``            ``// mapping every element with``            ``// it's``            ``// frequency``            ``m.Add(arr[i], m.ContainsKey(arr[i])?m[arr[i]]+1:1);``        ``}``        ``int` `ans = Kth_smallest(m, k);``        ``if` `(k == 1) {``            ``Console.WriteLine(``"The "` `+ k``                              ``+ ``"st smallest element is "``                              ``+ ans);``        ``}``        ``else` `if` `(k == 2) {``            ``Console.WriteLine(``"The "` `+ k``                              ``+ ``"nd smallest element is "``                              ``+ ans);``        ``}``        ``else` `if` `(k == 3) {``            ``Console.WriteLine(``"The "` `+ k``                              ``+ ``"rd smallest element is "``                              ``+ ans);``        ``}``        ``else` `{``            ``Console.WriteLine(``"The "` `+ k``                              ``+ ``"th smallest element is "``                              ``+ ans);``        ``}``    ``}``}` `// This code is contributed by Abhijeet Kumar(abhijeet19403)`

Output

`The 2nd smallest element is 5`

There are two more solutions that are better than the above-discussed ones: One solution is to do a randomized version of quickSelect() and the other solution is the worst-case linear time algorithm (see the following posts).

Method 7 (Max heap using STL):

We can implement max and min heap using a priority queue.
To find the kth minimum element in an array we will max heapify the array until the size of the heap becomes k.
After that for each entry we will pop the top element from the heap/Priority Queue.

Below is the implementation of the above approach:

C++

 `// C++ code to implement the approach``#include``using` `namespace` `std;` `// Function to find the kth smallest array element``int` `kthSmallest(``int` `arr[], ``int` `n, ``int` `k) {``  ` `    ``// For finding min element we need (Max heap)priority queue``    ``priority_queue<``int``> pq;``    ` `    ``for``(``int` `i = 0; i < k; i++)``    ``{           ``        ``// First push first K elememts into heap``        ``pq.push(arr[i]); ``    ``}``    ``// Now check from k to last element``    ``for``(``int` `i = k; i < n; i++) ``    ``{``      ` `        ``// If current element is < top that means``        ``// there are  other k-1 lesser elements``        ``// are present at bottom thus, pop that element``        ``// and add kth largest element into the heap till curr``        ``// at last all the greater element than kth element will get pop off``          ``// and at the top of heap there will be kth smallest element``        ``if``(arr[i] < pq.top())``        ``{``            ``pq.pop();``            ``// Push curr element``            ``pq.push(arr[i]);  ``        ``}``    ``}``  ` `    ``// Return top of element``    ``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;``    ``cout<< ``"Kth Smallest Element is: "``<

Java

 `// Java code to implement the approach``import` `java.util.*;` `//Custom comparator class to form the Max heap``class` `MinHeapComparator ``implements` `Comparator {` `    ``@Override``    ``public` `int` `compare(Integer number1, Integer number2) {``        ``int` `value = number1.compareTo(number2);``    ` `        ``// Elements are sorted in reverse order``        ``if` `(value > ``0``) {``            ``return` `-``1``;``        ``}``        ``else` `if` `(value < ``0``) {``            ``return` `1``;``        ``}``        ``else` `{``            ``return` `0``;``        ``}``    ``}``}``class` `GFG{` `// Function to find kth smallest array element``static` `int` `kthSmallest(``int` `[]v, ``int` `N, ``int` `K)``{``     ``//For finding min element we need (Max heap)priority queue``    ``PriorityQueue heap1 = ``new` `PriorityQueue(``new` `MinHeapComparator());``   ` `    ``for` `(``int` `i = ``0``; i < N; ++i) {` `        ``// Insert elements into``        ``// the priority queue``        ``heap1.add(v[i]);` `        ``//If current element is less than top, that means there are``        ``//other k-1 lesser elements are present at bottom``        ``// thus pop that element and add kth largest element into the heap till curr``        ``// at last all the greater element than kth element will get pop off``        ``// and at the top of heap there will be kth smallest element``        ``if` `(heap1.size() > K) {``            ``heap1.remove();``        ``}``    ``}` `    ``//Return the top of the heap as kth smallest element``    ``return` `heap1.peek();``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``// Given array``    ``int` `[]vec = {``10``, ``5``, ``4` `, ``3` `,``48``, ``15``, ``6` `, ``2` `, ``33``, ``53``, ``10``};` `    ``// Size of array``    ``int` `N = vec.length;` `    ``// Given K``    ``int` `K = ``4``;` `    ``// Function Call``    ``System.out.println(``"Kth Smallest Element: "` `+ kthSmallest(vec, N, K)) ;``}``}`

Python3

 `# Python code to implement the approach``import` `heapq` `# Function to find the kth smallest array element``def` `kthSmallest(arr, n, k):``  ` `    ``# For finding min element we need (Max heap)priority queue``    ``pq ``=` `[]``    ``for` `i ``in` `range``(k):``      ` `        ``# First push first K elememts into heap``        ``heapq.heappush(pq, arr[i])``        ``heapq._heapify_max(pq)``        ` `    ``# Now check from k to last element``    ``for` `i ``in` `range``(k, n):``      ` `        ``# If current element is < first that means``        ``# there are  other k-1 lesser elements``        ``# are present at bottom thus, pop that element``        ``# and add kth largest element into the heap till curr``        ``# at last all the greater element than kth element will get pop off``        ``# and at the top of heap there will be kth smallest element``        ``if` `arr[i] < pq[``0``]:``            ``heapq.heappop(pq)``            ` `            ``# Push curr element``            ``heapq.heappush(pq, arr[i])``            ``heapq._heapify_max(pq)``    ``# Return first of element``    ``return` `pq[``0``]` `# Driver's code:``n ``=` `10``arr ``=` `[``10``, ``5``, ``4``, ``3``, ``48``, ``6``, ``2``, ``33``, ``53``, ``10``]``k ``=` `4``print``(``"Kth Smallest Element is:"``, kthSmallest(arr, n, k))`  `# This code is contributed by Tapesh(tapeshdua420)`

C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``  ``// Function to find the kth smallest array element``  ``static` `int` `kthSmallest(``int``[] arr, ``int` `n, ``int` `k) {` `    ``// For finding min element we need (Max heap)priority queue``    ``List<``int``> pq = ``new` `List<``int``>();` `    ``for``(``int` `i = 0; i < k; i++)``    ``{          ``      ``// First push first K elememts into heap``      ``pq.Add(arr[i]);``    ``}``    ``// Now check from k to last element``    ``for``(``int` `i = k; i < n; i++)``    ``{` `      ``// If current element is < top that means``      ``// there are  other k-1 lesser elements``      ``// are present at bottom thus, pop that element``      ``// and add kth largest element into the heap till curr``      ``// at last all the greater element than kth element will get pop off``      ``// and at the top of heap there will be kth smallest element``      ``if``(arr[i] < pq[0])``      ``{``        ``pq.Sort();``        ``pq.Reverse();` `        ``pq.RemoveAt(0);``        ``// Push curr element``        ``pq.Add(arr[i]); ``      ``}``    ``}` `    ``// Return top of element``    ``return` `pq[0];  ``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main()``  ``{``    ``// Given array``    ``int` `[]vec = {10, 5, 4 , 3 ,48, 15, 6 , 2 , 33, 53, 10};` `    ``// Size of array``    ``int` `N = vec.Length;` `    ``// Given K``    ``int` `K = 4;` `    ``// Function Call``    ``Console.WriteLine(``"Kth Smallest Element: "` `+ kthSmallest(vec, N, K)) ;``  ``}``}` `// This code is contributed by sanjoy_62.`

Output

`Kth Smallest Element is: 5`

Time complexity: O(nlogk)
Auxiliary Space: O(logK)

This method is contributed by rupeshsk30.

Method 8(Using Binary Search):
The idea to solve this problem is that the Kth smallest element would be the element at the kth position if the array was sorted in increasing order. Using this logic, we use binary search to predict the index of an element as if the array was sorted but without actually sorting the array.
Example: {1, 4, 5, 3, 19, 3} & k = 2
Here we find that element which has exactly k + 1 elements (including itself) lesser to it. Hence, the kth smallest element would be 3 in this case.
Follow the steps below to implement the above idea:

1. Find low and high that is the range where our answer can lie.
2.  Apply Binary Search on this range.
3.  If the selected element which would be mid has less than k elements lesser to it then increase the number that is low = mid + 1.
4. Otherwise, Decrement the number and try to find a better answer (to understand this please try running on an array containing duplicates).
5. The Binary Search will end when only one element remains in the answer space which would be our answer.

Below is the implementation of the above approach:

C++

 `#include ``#include``using` `namespace` `std;` `int` `count(vector <``int``>& nums, ``int``& mid)``{``//function to calculate number of elements less than equal to mid``        ``int` `cnt = 0;``        ` `        ``for``(``int` `i = 0; i < nums.size(); i++)``           ``if``(nums[i] <= mid)``              ``cnt++;``        ` `        ``return` `cnt;``}``    `  `int` `kthSmallest(vector <``int``> nums, ``int``& k)``{``        ``int` `low = INT_MAX;``        ``int` `high = INT_MIN;``        ``//calculate minimum and maximum the array.``        ``for``(``int` `i = 0; i < nums.size(); i++)``        ``{``            ``low = min(low, nums[i]);``            ``high = max(high, nums[i]);``        ``}``        ``//Our answer range lies between minimum and maximum element of the array on which Binary Search is Applied``        ``while``(low < high)``        ``{``            ``int` `mid = low + (high - low) / 2;``           ``/*if the count of number of elements in the array less than equal to mid is less than k``             ``then increase the number. Otherwise decrement the number and try to find a better answer.``           ``*/``            ``if``(count(nums, mid) < k)``               ``low = mid + 1;``               ` `            ``else``                ``high = mid;``        ``}``        ` `        ``return` `low;``}` `int` `main()``{` `    ``vector <``int``> nums{1, 4, 5, 3, 19, 3};``    ``int` `k = 3;``    ``cout << ``"K'th smallest element is "` `<< kthSmallest(nums, k);``    ``return` `0;``}` `// This code is contributed by garvjuneja98`

Java

 `// Java code for kth smallest element in an array``import` `java.util.Arrays;``import` `java.util.Collections;` `class` `GFG {``    ``static` `int` `count(``int` `[] nums, ``int` `mid)``    ``{``        ``// function to calculate number of elements less than equal to mid``            ``int` `cnt = ``0``;``             ` `            ``for``(``int` `i = ``0``; i < nums.length; i++)``               ``if``(nums[i] <= mid)``                  ``cnt++;``             ` `            ``return` `cnt;``    ``}``         ` `     ` `    ``static` `int` `kthSmallest(``int` `[] nums, ``int` `k)``    ``{``            ``int` `low = Integer.MAX_VALUE;``            ``int` `high = Integer.MIN_VALUE;``            ``//calculate minimum and maximum the array.``            ``for``(``int` `i = ``0``; i < nums.length; i++)``            ``{``                ``low = Math.min(low, nums[i]);``                ``high = Math.max(high, nums[i]);``            ``}``            ``//Our answer range lies between minimum and maximum element of the array on which Binary Search is Applied``            ``while``(low < high)``            ``{``                ``int` `mid = low + (high - low) / ``2``;``               ``/*if the count of number of elements in the array less than equal to mid is less than k``                 ``then increase the number. Otherwise decrement the number and try to find a better answer.``               ``*/``                ``if``(count(nums, mid) < k)``                   ``low = mid + ``1``;``                    ` `                ``else``                    ``high = mid;``            ``}``             ` `            ``return` `low;``    ``}` `    ``// Driver program to test above methods``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = {``1``, ``4``, ``5``, ``3``, ``19``, ``3``};``        ``int` `k = ``3``;``        ``System.out.print(``"Kth smallest element is "` `+ kthSmallest(arr, k));``    ``}``}` `// This code is contributed by CodeWithMini`

Python3

 `# Python code for kth smallest element in an array``import` `sys` `# function to calculate number of elements``# less than equal to mid``def` `count(nums, mid):``    ``cnt ``=` `0``    ``for` `i ``in` `range``(``len``(nums)):``        ``if` `nums[i] <``=` `mid:``            ``cnt ``+``=` `1``    ``return` `cnt` `def` `kthSmallest(nums, k):``    ``low ``=` `sys.maxsize``    ``high ``=` `-``sys.maxsize ``-` `1``    ` `    ``# calculate minimum and maximum the array.``    ``for` `i ``in` `range``(``len``(nums)):``        ``low ``=` `min``(low, nums[i])``        ``high ``=` `max``(high, nums[i])` `        ``# Our answer range lies between minimum and maximum element``        ``# of the array on which Binary Search is Applied``    ``while` `low < high:``        ``mid ``=` `low ``+` `(high ``-` `low) ``/``/` `2``        ``# if the count of number of elements in the array less than equal``        ``# to mid is less than k then increase the number. Otherwise decrement``        ``# the number and try to find a better answer.``        ``if` `count(nums, mid) < k:``            ``low ``=` `mid ``+` `1``        ``else``:``            ``high ``=` `mid``    ``return` `low` `nums ``=` `[``1``, ``4``, ``5``, ``3``, ``19``, ``3``]``k ``=` `3``print``(``"K'th smallest element is"``, kthSmallest(nums, k))` `# This code is contributed by Tapesh(tapeshdua420)`

C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``  ``static` `int` `count(``int` `[]nums, ``int` `mid)``  ``{``    ``// function to calculate number of elements less than equal to mid``    ``int` `cnt = 0;` `    ``for``(``int` `i = 0; i < nums.Length; i++)``      ``if``(nums[i] <= mid)``        ``cnt++;` `    ``return` `cnt;``  ``}`  `  ``static` `int` `kthSmallest(``int` `[]nums, ``int` `k)``  ``{``    ``int` `low = Int32.MaxValue;``    ``int` `high = Int32.MinValue;` `    ``// calculate minimum and maximum the array.``    ``for``(``int` `i = 0; i < nums.Length; i++)``    ``{``      ``low = Math.Min(low, nums[i]);``      ``high = Math.Max(high, nums[i]);``    ``}``    ``// Our answer range lies between minimum``    ``// and maximum element of the array on which Binary Search is Applied``    ``while``(low < high)``    ``{``      ``int` `mid = low + (high - low) / 2;``      ``/*if the count of number of elements in the``               ``array less than equal to mid is less than k``                 ``then increase the number. Otherwise``                 ``decrement the number and try to find a better answer.``               ``*/``      ``if``(count(nums, mid) < k)``        ``low = mid + 1;` `      ``else``        ``high = mid;``    ``}` `    ``return` `low;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main()``  ``{` `    ``// Given array``    ``int` `[]vec = {1, 4, 5, 3, 19, 3};` `    ``// Given K``    ``int` `K = 3;` `    ``// Function Call``    ``Console.WriteLine(``"Kth Smallest Element: "` `+ kthSmallest(vec, K)) ;``  ``}``}` `// This code is contributed by CodeWithMini`

Javascript

 ``

Output

`K'th smallest element is 3`

Time complexity: O((mx-mn)(log(mx-mn))), where mn be minimum and mx be maximum.
Auxiliary Space: O(1)
K’th Smallest/Largest Element in Unsorted Array | Set 2 (Expected Linear Time)
K’th Smallest/Largest Element in Unsorted Array | Set 3 (Worst-Case Linear Time)

My Personal Notes arrow_drop_up