K'th Smallest/Largest Element in Unsorted Array | Set 1 - GeeksforGeeks

12 May, 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++
Java
Python3
C#
PHP
Javascript
// Simple C++ program to find k'th smallest element#include <algorithm>#include <iostream>using namespace std; // Function to return k'th smallest element in a given arrayint 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 methodsint 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 code for kth smallest element// in an arrayimport 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 program to find k'th smallest# element # Function to return k'th smallest# element in a given arraydef kthSmallest(arr, n, k):     # Sort the given array    arr.sort()     # Return k'th element in the    # sorted array    return arr[k-1] # Driver codeif __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# code for kth smallest element// in an arrayusing 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// Simple PHP program to find// k'th smallest element // Function to return k'th smallest// element in a given arrayfunction kthSmallest($arr, $n, $k){         // Sort the given array    sort($arr);     // Return k'th element    // in the sorted array    return $arr[$k - 1];}     // Driver Code    $arr = array(12, 3, 5, 7, 19);    $n =count($arr);    $k = 2;    echo "K'th smallest element is ", kthSmallest($arr, $n, $k); // This code is contributed by anuj_67.?>
<script> // Simple Javascript program to find k'th smallest element // Function to return k'th smallest element in a given arrayfunction 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;    document.write("K'th smallest element is " + kthSmallest(arr, n, k)); //This code is contributed by Mayank Tyagi</script>
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 smallestelement using set from C++ STL */ #include <bits/stdc++.h>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;}
12
Time Complexity:  O( log N) in Average Case and O(N) in Worst CaseAuxiliary 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++
Java
Python3
C#
// A C++ program to find k'th smallest element using min heap#include <climits>#include <iostream>using namespace std; // Prototype of a utility function to swap two integersvoid swap(int* x, int* y); // A class for Min Heapclass 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 heappublic:    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 heapint 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 heapifiedvoid 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 elementsvoid swap(int* x, int* y){    int temp = *x;    *x = *y;    *y = temp;} // Function to return k'th smallest element in a given arrayint 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 methodsint 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;}
// A Java program to find k'th smallest element using min heapimport 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 program to find k'th smallest element# using min heap # Class for Min Heapclass 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 arraydef 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 codearr = [12, 3, 5, 7, 19]n = len(arr)k = 2print("K'th smallest element is", kthSmallest(arr, n, k)) # This Code is contributed by Kevin Joshi
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
K'th smallest element is 5
Time complexity of this solution is O(n + kLogn).
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++
Java
Python3
C#
// A C++ program to find k'th smallest element using max heap#include <climits>#include <iostream>using namespace std; // Prototype of a utility function to swap two integersvoid swap(int* x, int* y); // A class for Max Heapclass 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 heappublic:    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 heapint 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 heapifiedvoid 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 elementsvoid swap(int* x, int* y){    int temp = *x;    *x = *y;    *y = temp;} // Function to return k'th largest element in a given arrayint 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 methodsint 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;}
// A Java program to find k'th smallest element using max heapimport 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 program to find k'th smallest element# using max heap # Class for Max Heapclass 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 arraydef 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 codearr = [12, 3, 5, 7, 19]n = len(arr)k = 4print("K'th smallest element is", kthSmallest(arr, n, k)) # Code contributed by Kevin Joshi
// A C# program to find k'th smallest element using max heapusing 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
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++
Java
Python3
C#
Javascript
#include <climits>#include <iostream>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 DISTINCTint 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 rightint 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 methodsint 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 code for kth smallest element in an arrayimport 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
# This function returns k'th smallest element# in arr[l..r] using QuickSort based method.# ASSUMPTION: ALL ELEMENTS IN ARR[] ARE DISTINCTimport 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 rightdef 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 Codeif __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# code for kth smallest element// in an arrayusing 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
<script> // JavaScript code for kth smallest// element in an array     // 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    function partition( arr , l , r)    {        var x = arr[r], i = l;        for (j = l; j <= r - 1; j++) {            if (arr[j] <= x) {                // Swapping arr[i] and arr[j]                var temp = arr[i];                arr[i] = arr[j];                arr[j] = temp;                 i++;            }        }         // Swapping arr[i] and arr[r]        var 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    function kthSmallest( arr , l , r , 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            var 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 Number.MAX_VALUE;    }     // Driver program to test above methods             var arr = [ 12, 3, 5, 7, 4, 19, 26 ];        var k = 3;        document.write("K'th smallest element is " +        kthSmallest(arr, 0, arr.length - 1, k)); // This code contributed by Rajput-Ji </script>
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++
Java
#include <bits/stdc++.h>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 program for the above approachimport java.util.*; class GFG {    static int Kth_smallest(TreeMap<Integer, Integer> 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<Integer, Integer> 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.
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++
Java
// C++ code to implement the approach#include<bits/stdc++.h>using namespace std; // Function to find the kth smallest array elementint 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: "<<kthSmallest(arr, n, k); }
// Java code to implement the approachimport java.util.*; //Custom comparator class to form the Max heapclass MinHeapComparator implements Comparator<Integer> {     @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 elementstatic int kthSmallest(int []v, int N, int K){     //For finding min element we need (Max heap)priority queue    PriorityQueue<Integer> heap1 = new PriorityQueue<Integer>(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 codepublic 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)) ;}}
Kth Smallest Element is: 5
Time complexity: O(nlogk)Auxiliary Space Complexity: O(logK)
This method is contributed by rupeshsk30.
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)
 
 
 
nitin mittal
vt_m
shrikanth13
29AjayKumar
ukasp
velli_chor
arpit2205
Rajput-Ji
GauravRajput1
avanitrachhadiya2155
rag2127
mayanktyagi1709
adityamutharia
moneshsannareddy
sumitgumber28
rajsanghavi9
abhishek0719kadiyan
kevinjoshi46b
harshit17
rupeshsk30
krishjindalrock
ABCO
Accolite
Amazon
Cisco
Microsoft
Order-Statistics
Rockstand
SAP Labs
Snapdeal
VMWare
Arrays
Heap
Searching
VMWare
Accolite
Amazon
Microsoft
Snapdeal
ABCO
SAP Labs
Cisco
Rockstand
Arrays
Searching
Heap
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Arrays
Multidimensional Arrays in Java
Linked List vs Array
Python | Using 2D arrays/lists the right way
Search an element in a sorted and rotated array
HeapSort
Binary Heap
Huffman Coding | Greedy Algo-3
Building Heap from Array
Insertion and Deletion in Heaps