# K’th Smallest/Largest Element in Unsorted Array | Set 2 (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 largest element in the given array. It is given that all array elements are distinct.

We recommend reading the following post as a prerequisite to this post. Kâ€™th Smallest/Largest Element in Unsorted Array | Set 1

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, it is discussed which is mainly an extension of method 3 (QuickSelect) discussed in the previous post.

The flowchart is as follows:

Flowchart

flowchart- kth smallest

## 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[0]), k = 3;` `    ``cout << ``"K'th smallest element is "` `         ``<< kthSmallest(arr, 0, n - 1, k);` `}`

## 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(n);` `        ``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)); ` `} ` `} `   `// this code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`K'th smallest element is 5`

Time Complexity : O(N * log N).
Auxiliary Space: O(1).

Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next
Similar Reads
Complete Tutorials