Skip to content
Related Articles
K’th Smallest/Largest Element in Unsorted Array | Set 2 (Expected Linear Time)
• Difficulty Level : Medium
• Last Updated : 06 May, 2021

We recommend to read following post as a prerequisite of this post.
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 largest 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 three different solutions here.
In this post method 4 is discussed which is mainly an extension of method 3 (QuickSelect) discussed in the previous post.

## C++

 `// C++ program of above implementation``#include``using` `namespace` `std;` `// Standard partition process of QuickSort().``// It considers the last element as pivot and``// oves 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;``}` `int` `randomPartition(``int` `*arr, ``int` `l, ``int` `r)``{``    ``int` `n = r - l + 1;``    ``int` `pivot =  (``rand``() % 100 + 1) % n;``    ``swap(arr[l + pivot], arr[r]);``    ``return` `partition(arr, l, 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 = randomPartition(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_MAX;``}` `// Driver Code``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);``}` `// This code is contributed by Surbhi Tyagi.`

## Java

 `// Java program of above implementation``import` `java.util.Random;` `public` `class` `GFG {` `// This function returns k'th smallest element in arr[l..r] using``// QuickSort based method. ASSUMPTION: ALL ELEMENTS IN ARR[] ARE DISTINCT``    ``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 = randomPartition(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` `Integer.MAX_VALUE;``    ``}` `    ``static` `void` `swap(``int``[] arr, ``int` `i, ``int` `j) {``        ``int` `temp = arr[i];``        ``arr[i] = arr[j];``        ``arr[j] = 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``    ``static` `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, j);``                ``i++;``            ``}``        ``}``        ``swap(arr, i, r);``        ``return` `i;``    ``}` `    ``static` `int` `randomPartition(``int` `arr[], ``int` `l, ``int` `r) {``        ``int` `n = r - l + ``1``;``        ``int` `pivot = ``new` `Random().nextInt(``1``);``        ``swap(arr, l + pivot, r);``        ``return` `partition(arr, l, r);``    ``}` `// Driver program to test above methods``    ``public` `static` `void` `main(String args[]) {``        ``int` `arr[] = {``12``, ``3``, ``5``, ``7``, ``4``, ``19``, ``26``};``        ``int` `n = arr.length, k = ``3``;``        ``System.out.println(``"K'th smallest element is "` `+ kthSmallest(arr, ``0``, n - ``1``, k));``    ``}``}` `/*This code is contributed by 29AjayKumar*/`

## Python3

 `# Python3 implementation of above implementation` `# This function returns k'th smallest element``# in arr[l..r] using QuickSort based method.``# ASSUMPTION: ALL ELEMENTS IN ARR[] ARE DISTINCT``from` `random ``import` `randint` `def` `randomPartition(arr, l, r):``    ``n ``=` `r ``-` `l ``+` `1``    ``pivot ``=` `randint(``1``, ``100``) ``%` `n``    ``arr[l ``+` `pivot], arr[r] ``=` `arr[l ``+` `pivot], arr[r]``    ``return` `partition(arr, l, r)` `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 ``=` `randomPartition(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` `10``*``*``9` `# 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``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 Mohit Kumar`

## C#

 `// C# program of above implementation``using` `System;` `class` `GFG``{` `// This function returns k'th smallest``// element in arr[l..r] using``// QuickSort based method. ASSUMPTION:``// ALL ELEMENTS IN ARR[] ARE DISTINCT``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 = randomPartition(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;``}` `static` `void` `swap(``int``[] arr, ``int` `i, ``int` `j)``{``    ``int` `temp = arr[i];``    ``arr[i] = arr[j];``    ``arr[j] = temp;``}` `// Standard partition process of QuickSort().``// It considers the last element as pivot and``// oves all smaller element to left of it``// and greater elements to right``static` `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, j);``            ``i++;``        ``}``    ``}``    ``swap(arr, i, r);``    ``return` `i;``}` `static` `int` `randomPartition(``int` `[]arr, ``int` `l, ``int` `r)``{``    ``int` `n = r - l + 1;``    ``int` `pivot = ``new` `Random().Next(1);``    ``swap(arr, l + pivot, r);``    ``return` `partition(arr, l, r);``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `[]arr = {12, 3, 5, 7, 4, 19, 26};``    ``int` `n = arr.Length, k = 3;``    ``Console.WriteLine(``"K'th smallest element is "` `+``                    ``kthSmallest(arr, 0, n - 1, k));``}``}` `// his code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`K'th smallest element is 5`

References:
https://www.geeksforgeeks.org/kth-smallestlargest-element-unsorted-array/
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up