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

Given an array and a number k where k is smaller than size of array, we need to find the k’th smallest element in the given array. It is given that ll 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.

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

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

Time Complexity of this solution is O(N Log N)

## C++

 `// Simple C++ program to find k'th smallest element ` `#include ` `#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), k = 2; ` `    ``cout << ``"K'th smallest element is "` `<<  kthSmallest(arr, n, k); ` `    ``return` `0; ` `} `

## 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

 ` `

Output:

`K'th smallest element is 5 `

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

The following is C++ implementation of above method.

 `// 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; } ``// 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 vakue. ` `    ``int` `root = harr; ` ` `  `    ``// If there are more than 1 items, move the last item to root ` `    ``// and call heapify. ` `    ``if` `(heap_size > 1) ` `    ``{ ` `        ``harr = 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

Output:

`K'th smallest element is 5 `

Time complexity of this solution is O(n + kLogn).

Method 3 (Using Max-Heap)
We can also use Max Heap for finding the k’th smallest element. Following is algorithm.
1) Build a Max-Heap MH of the first k elements (arr 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, 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 above algorithm

 `// 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; } ``// Returns maximum ` ` `  `    ``// to replace root with new node x and heapify() new root ` `    ``void` `replaceMax(``int` `x) { harr = 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 vakue. ` `    ``int` `root = harr; ` ` `  `    ``// If there are more than 1 items, move the last item to root ` `    ``// and call heapify. ` `    ``if` `(heap_size > 1) ` `    ``{ ` `        ``harr = 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

Output:

`K'th smallest element is 5 `

Method 4 (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 array around it. 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), 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 `

## Python 3

 `# 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 `

Output:

`K'th smallest element is 5 `

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