GFG App
Open App
Browser
Continue

# K’th Smallest/Largest Element in Unsorted Array | Expected Linear Time

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 three different solutions here.

### Approach 1:

1. Select a random element from an array as a pivot.
2. Then partition to the array around the pivot, its help to all the smaller elements were placed before the pivot and all greater elements are placed after the pivot.
3. then Check the position of the pivot. If it is the kth element then return it.
4. If it is less than the kth element then repeat the process of the subarray.
5. If it is greater than the kth element then repeat the process of the left subarray.

That Algorithm is the QuickSelect and It is similar to the QuickSort.

In this post method 5 is discussed which is mainly an extension of method 5 (QuickSelect) discussed in the previous post. The idea is to randomly pick a pivot element. To implement a randomized partition, we use a random function, rand() to generate an index between l and r, swap the element at the randomly generated index with the last element, and finally call the standard partition process which uses the last element as pivot.

Steps to solve the problem:

1. Check if k>0&& k<=r-l+1:

```declare pos as randomPartition(arr,l,r).
check if pos-1==k-1 than return arr[pos].
check if pos-1>k-1 than recursively call kthsmallest(arr,l,pos-1,k).
return recursively call kthsmallest(arr,pos+1,r,k-pos+l-1).```

2. Return INT_MAX.

Following is an implementation of the above Randomized QuickSelect.

## C++

 `// C++ implementation of randomized quickSelect ` `#include ` `#include ` `#include ` `using` `namespace` `std; `   `int` `randomPartition(``int` `arr[], ``int` `l, ``int` `r); `   `// This function returns k'th smallest element in arr[l..r] using ` `// QuickSort based method. ASSUMPTION: 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 a random 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 the number of elements in the 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. This function is used by randomPartition() ` `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; ` `} `   `// Picks a random pivot element between l and r and partitions ` `// arr[l..r] around the randomly picked element using partition() ` `int` `randomPartition(``int` `arr[], ``int` `l, ``int` `r) ` `{ ` `    ``int` `n = r-l+1; ` `    ``int` `pivot = ``rand``() % n; ` `    ``swap(&arr[l + pivot], &arr[r]); ` `    ``return` `partition(arr, l, r); ` `} `   `// 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 program to find k'th smallest element in expected ` `// linear time ` `class` `KthSmallst ` `{ ` `    ``// 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 a random 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` `Integer.MAX_VALUE; ` `    ``} `   `    ``// Utility method to swap arr[i] and arr[j] ` `    ``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. This function ` `    ``// is used by randomPartition() ` `    ``int` `partition(``int` `arr[], ``int` `l, ``int` `r) ` `    ``{ ` `        ``int` `x = arr[r], i = l; ` `        ``for` `(``int` `j = l; j < r; j++) ` `        ``{ ` `            ``if` `(arr[j] <= x) ` `            ``{ ` `                ``swap(arr, i, j); ` `                ``i++; ` `            ``} ` `        ``} ` `        ``swap(arr, i, r); ` `        ``return` `i; ` `    ``} `   `    ``// Picks a random pivot element between l and r and ` `    ``// partitions arr[l..r] arount the randomly picked ` `    ``// element using partition() ` `    ``int` `randomPartition(``int` `arr[], ``int` `l, ``int` `r) ` `    ``{ ` `        ``int` `n = r - l + ``1``; ` `        ``int` `pivot = (``int``)(Math.random() * (n - ``1``)); ` `        ``swap(arr, l + pivot, r); ` `        ``return` `partition(arr, l, r); ` `    ``} `   `    ``// Driver method to test above ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``KthSmallst ob = ``new` `KthSmallst(); ` `        ``int` `arr[] = {``12``, ``3``, ``5``, ``7``, ``4``, ``19``, ``26``}; ` `        ``int` `n = arr.length,k = ``3``; ` `        ``System.out.println(``"K'th smallest element is "``+ ` `                        ``ob.kthSmallest(arr, ``0``, n-``1``, k)); ` `    ``} ` `} ` `/*This code is contributed by Rajat Mishra*/`

## Python3

 `# Python3 implementation of randomized ` `# quickSelect ` `import` `random `   `# This function returns k'th smallest ` `# element in arr[l..r] using QuickSort ` `# based method. ASSUMPTION: ELEMENTS ` `# IN ARR[] ARE DISTINCT ` `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 a random ` `        ``# 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` `(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 the number of ` `    ``# elements in the array ` `    ``return` `999999999999`   `def` `swap(arr, a, b): ` `    ``temp ``=` `arr[a] ` `    ``arr[a] ``=` `arr[b] ` `    ``arr[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. This function ` `# is used by randomPartition() ` `def` `partition(arr, l, r): ` `    ``x ``=` `arr[r] ` `    ``i ``=` `l ` `    ``for` `j ``in` `range``(l, r): ` `        ``if` `(arr[j] <``=` `x): ` `            ``swap(arr, i, j) ` `            ``i ``+``=` `1` `    ``swap(arr, i, r) ` `    ``return` `i `   `# Picks a random pivot element between l and r ` `# and partitions arr[l..r] around the randomly ` `# picked element using partition() ` `def` `randomPartition(arr, l, r): ` `    ``n ``=` `r ``-` `l ``+` `1` `    ``pivot ``=` `int``(random.random() ``*` `n) ` `    ``swap(arr, l ``+` `pivot, r) ` `    ``return` `partition(arr, l, r) `   `# 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 PranchalK `

## C#

 `// C# program to find k'th smallest ` `// element in expected linear time ` `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 ` `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 a ` `        ``// random 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; ` `} `   `// Utility method to swap arr[i] and arr[j] ` `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. This function ` `// is used by randomPartition() ` `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; ` `} `   `// Picks a random pivot element between ` `// l and r and partitions arr[l..r] ` `// around the randomly picked element ` `// using partition() ` `int` `randomPartition(``int` `[]arr, ``int` `l, ``int` `r) ` `{ ` `    ``int` `n = r - l + 1; ` `    ``Random rnd = ``new` `Random(); ` `    ``int` `rand = rnd.Next(0, 1); ` `    ``int` `pivot = (``int``)(rand * (n - 1)); ` `    ``swap(arr, l + pivot, r); ` `    ``return` `partition(arr, l, r); ` `} `   `// Driver Code ` `public` `static` `void` `Main() ` `{ ` `    ``GFG ob = ``new` `GFG(); ` `    ``int` `[]arr = {12, 3, 5, 7, 4, 19, 26}; ` `    ``int` `n = arr.Length,k = 3; ` `    ``Console.Write(``"K'th smallest element is "``+ ` `            ``ob.kthSmallest(arr, 0, n - 1, k)); ` `} ` `} `   `// This code is contributed by 29AjayKumar `

## PHP

 ` 0 && ``\$k` `<= ``\$r` `- ``\$l` `+ 1) ` `    ``{ ` `        ``// Partition the array around a random 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 the number of elements in the array ` `    ``return` `PHP_INT_MAX; ` `} `   `function` `swap(``\$a``, ``\$b``) ` `{ ` `    ``\$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. ` `// This function is used by randomPartition() ` `function` `partition(``\$arr``, ``\$l``, ``\$r``) ` `{ ` `    ``\$x` `= ``\$arr``[``\$r``]; ` `    ``\$i` `= ``\$l``; ` `    ``for` `(``\$j` `= ``\$l``; ``\$j` `<= ``\$r` `- 1; ``\$j``++) ` `    ``{ ` `        ``if` `(``\$arr``[``\$j``] <= ``\$x``) ` `        ``{ ` `            ``list(``\$arr``[``\$i``], ``\$arr``[``\$j``])=``array``(``\$arr``[``\$j``],``\$arr``[``\$i``]); ` `            ``//swap(&arr[i], &arr[j]); ` `            ``\$i``++; ` `        ``} ` `    ``} ` `    ``list(``\$arr``[``\$i``], ``\$arr``[``\$r``])=``array``(``\$arr``[``\$r``],``\$arr``[``\$i``]); ` `    ``//swap(&arr[i], &arr[r]); ` `    ``return` `\$i``; ` `} `   `// Picks a random pivot element between ` `// l and r and partitions arr[l..r] around ` `// the randomly picked element using partition() ` `function` `randomPartition(``\$arr``, ``\$l``, ``\$r``) ` `{ ` `    ``\$n` `= ``\$r``-``\$l``+1; ` `    ``\$pivot` `= rand() % ``\$n``; ` `    `  `    ``list(``\$arr``[``\$l` `+ ``\$pivot``], ``\$arr``[``\$r``]) = ` `            ``array``(``\$arr``[``\$r``],``\$arr``[``\$l` `+ ``\$pivot``] ); ` `    `  `    ``//swap(&arr[l + pivot], &arr[r]); ` `    ``return` `partition(``\$arr``, ``\$l``, ``\$r``); ` `} `   `// Driver program to test the above methods ` `    ``\$arr` `= ``array``(12, 3, 5, 7, 4, 19, 260); ` `    ``\$n` `= sizeof(``\$arr``)/sizeof(``\$arr``[0]); ` `    ``\$k` `= 3; ` `    ``echo` `"K'th smallest element is "` `, ` `            ``kthSmallest(``\$arr``, 0, ``\$n``-1, ``\$k``); ` `    `    `// This code is contributed by ajit. ` `?> `

## Javascript

 ``

Output

`K'th smallest element is 5`

Time Complexity: O(n^2)
The worst-case time complexity of the above solution is still O(n2). In the worst case, the randomized function may always pick a corner element. The expected time complexity of the above randomized QuickSelect is O(n), see CLRS book or MIT video lecture for proof. The assumption in the analysis is, random number generator is equally likely to generate any number in the input range.

Auxiliary Space: O(1) since using constant variables.

### Approach 2: Using Map

This approach is very much similar to the QuickSelect and counting sort algorithm but much easier to implement. Use a map and then map each element with its frequency. And as an ordered map would store the data in a sorted manner, so keep on adding the frequency of each element till it does not become greater than or equal to k so that the kth element from the start can be reached i.e. the kth smallest element.

Steps:

Follow the given steps to solve the problem:

1. Store the frequency of every element in a Map mp.
2. Now traverse over sorted elements in the Map mp and add their frequencies in a variable freq
3. If at any point the value of freq is greater than or equal to K, then return the value of the iterator of Map mp

Below is the Implementation of the above approach:

## C++

 `// C++ program to find K’th Smallest/Largest Element` `// in Unsorted Array`   `#include ` `using` `namespace` `std;`   `int` `Kth_smallest(map<``int``, ``int``> mp, ``int` `K)` `{` `    ``int` `freq = 0;` `    ``for` `(``auto` `it = mp.begin(); it != mp.end(); it++) {`   `        ``// adding the frequencies of` `        ``// each element` `        ``freq += (it->second);`   `        ``// if at any point frequency becomes` `        ``// greater than or equal to k then` `        ``// return that element` `        ``if` `(freq >= K) {` `            ``return` `it->first;` `        ``}` `    ``}`   `    ``// returning -1 if k>size of the array which` `    ``// is an impossible scenario` `    ``return` `-1;` `}`   `// Main driver method` `int` `main()` `{` `    ``int` `N = 5;` `    ``int` `K = 2;` `    ``vector<``int``> arr = { 12, 3, 5, 7, 19 };`   `    ``map<``int``, ``int``> mp;` `    ``for` `(``int` `i = 0; i < N; i++) {` `      `  `        ``// mapping every element with it's` `        ``// frequency` `        ``mp[arr[i]] += 1;` `    ``}`   `    ``// Function call` `    ``int` `ans = Kth_smallest(mp, K);` `    ``cout << ``"The "` `<< K << ``"th smallest element is "` `<< ans` `         ``<< endl;`   `    ``return` `0;` `}`   `// This code is contributed by Susobhan Akhuli`

Output

`The 2th smallest element is 5`

Time Complexity: O(N*log N), Where N is the size/length of the array.
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up