# Kth smallest element in the array using constant space when array can’t be modified

Given an array arr[] of size N and an integer K, the task is to find the Kth smallest element from the array in constant extra space and the array can’t be modified.

Examples:

Input: arr[] = {7, 10, 4, 3, 20, 15}, K = 3
Output: 7
Given array in sorted is {3, 4, 7, 10, 15, 20}
where 7 is the third smallest element.

Input: arr[] = {12, 3, 5, 7, 19}, K = 2
Output: 5

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: First we find the min and max element from the array. Then we set low = min, high = max and mid = (low + high) / 2.
Now, perform a modified binary search, and for each mid we count the number of elements less than mid and equal to mid. If countLess < k and countLess + countEqual ≥ k then mid is our answer, else we have to modify our low and high.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the kth smallest ` `// element from the array ` `int` `kthSmallest(``int``* arr, ``int` `k, ``int` `n) ` `{ ` ` `  `    ``// Minimum and maximum element from the array ` `    ``int` `low = *min_element(arr, arr + n); ` `    ``int` `high = *max_element(arr, arr + n); ` ` `  `    ``// Modified binary search ` `    ``while` `(low <= high) { ` ` `  `        ``int` `mid = low + (high - low) / 2; ` ` `  `        ``// To store the count of elements from the array ` `        ``// which are less than mid and ` `        ``// the elements which are equal to mid ` `        ``int` `countless = 0, countequal = 0; ` `        ``for` `(``int` `i = 0; i < n; ++i) { ` `            ``if` `(arr[i] < mid) ` `                ``++countless; ` `            ``else` `if` `(arr[i] == mid) ` `                ``++countequal; ` `        ``} ` ` `  `        ``// If mid is the kth smallest ` `        ``if` `(countless < k ` `            ``&& (countless + countequal) >= k) { ` `            ``return` `mid; ` `        ``} ` ` `  `        ``// If the required element is less than mid ` `        ``else` `if` `(countless >= k) { ` `            ``high = mid - 1; ` `        ``} ` ` `  `        ``// If the required element is greater than mid ` `        ``else` `if` `(countless < k ` `                 ``&& countless + countequal < k) { ` `            ``low = mid + 1; ` `        ``} ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 7, 10, 4, 3, 20, 15 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``); ` `    ``int` `k = 3; ` ` `  `    ``cout << kthSmallest(arr, k, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `// Function to return the kth smallest ` `// element from the array ` `static` `int` `kthSmallest(``int``[] arr, ``int` `k, ``int` `n) ` `{ ` ` `  `    ``// Minimum and maximum element from the array ` `    ``int` `low = Arrays.stream(arr).min().getAsInt(); ` `    ``int` `high = Arrays.stream(arr).max().getAsInt(); ` ` `  `    ``// Modified binary search ` `    ``while` `(low <= high) ` `    ``{ ` ` `  `        ``int` `mid = low + (high - low) / ``2``; ` ` `  `        ``// To store the count of elements from the array ` `        ``// which are less than mid and ` `        ``// the elements which are equal to mid ` `        ``int` `countless = ``0``, countequal = ``0``; ` `        ``for` `(``int` `i = ``0``; i < n; ++i)  ` `        ``{ ` `            ``if` `(arr[i] < mid) ` `                ``++countless; ` `            ``else` `if` `(arr[i] == mid) ` `                ``++countequal; ` `        ``} ` ` `  `        ``// If mid is the kth smallest ` `        ``if` `(countless < k ` `            ``&& (countless + countequal) >= k)  ` `        ``{ ` `            ``return` `mid; ` `        ``} ` ` `  `        ``// If the required element is less than mid ` `        ``else` `if` `(countless >= k)  ` `        ``{ ` `            ``high = mid - ``1``; ` `        ``} ` ` `  `        ``// If the required element is greater than mid ` `        ``else` `if` `(countless < k ` `                ``&& countless + countequal < k) ` `        ``{ ` `            ``low = mid + ``1``; ` `        ``} ` `    ``} ` `    ``return` `Integer.MIN_VALUE; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `arr[] = { ``7``, ``10``, ``4``, ``3``, ``20``, ``15` `}; ` `    ``int` `n = arr.length; ` `    ``int` `k = ``3``; ` ` `  `    ``System.out.println(kthSmallest(arr, k, n)); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## Python3

 `# Python3 implementation of the approach  ` ` `  `# Function to return the kth smallest  ` `# element from the array  ` `def` `kthSmallest(arr, k, n) :  ` ` `  `    ``# Minimum and maximum element from the array  ` `    ``low ``=` `min``(arr);  ` `    ``high ``=` `max``(arr);  ` ` `  `    ``# Modified binary search  ` `    ``while` `(low <``=` `high) : ` ` `  `        ``mid ``=` `low ``+` `(high ``-` `low) ``/``/` `2``;  ` ` `  `        ``# To store the count of elements from the array  ` `        ``# which are less than mid and  ` `        ``# the elements which are equal to mid  ` `        ``countless ``=` `0``; countequal ``=` `0``;  ` `         `  `        ``for` `i ``in` `range``(n) : ` `             `  `            ``if` `(arr[i] < mid) : ` `                ``countless ``+``=` `1``;  ` `                 `  `            ``elif` `(arr[i] ``=``=` `mid) : ` `                ``countequal ``+``=` `1``;  ` ` `  ` `  `        ``# If mid is the kth smallest  ` `        ``if` `(countless < k ``and` `(countless ``+` `countequal) >``=` `k) : ` `            ``return` `mid;  ` `         `  ` `  `        ``# If the required element is less than mid  ` `        ``elif` `(countless >``=` `k) : ` `            ``high ``=` `mid ``-` `1``;  ` ` `  `        ``# If the required element is greater than mid  ` `        ``elif` `(countless < k ``and` `countless ``+` `countequal < k) : ` `            ``low ``=` `mid ``+` `1``;  ` `     `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` `     `  `    ``arr ``=` `[ ``7``, ``10``, ``4``, ``3``, ``20``, ``15` `];  ` `    ``n ``=` `len``(arr);  ` `    ``k ``=` `3``;  ` ` `  `    ``print``(kthSmallest(arr, k, n));  ` ` `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# implementation of the approach ` `using` `System; ` `using` `System.Linq;  ` ` `  `class` `GFG  ` `{ ` ` `  `// Function to return the kth smallest ` `// element from the array ` `static` `int` `kthSmallest(``int``[] arr, ``int` `k, ``int` `n) ` `{ ` ` `  `    ``// Minimum and maximum element from the array ` `    ``int` `low = arr.Min(); ` `    ``int` `high = arr.Max(); ` ` `  `    ``// Modified binary search ` `    ``while` `(low <= high) ` `    ``{ ` ` `  `        ``int` `mid = low + (high - low) / 2; ` ` `  `        ``// To store the count of elements from the array ` `        ``// which are less than mid and ` `        ``// the elements which are equal to mid ` `        ``int` `countless = 0, countequal = 0; ` `        ``for` `(``int` `i = 0; i < n; ++i)  ` `        ``{ ` `            ``if` `(arr[i] < mid) ` `                ``++countless; ` `            ``else` `if` `(arr[i] == mid) ` `                ``++countequal; ` `        ``} ` ` `  `        ``// If mid is the kth smallest ` `        ``if` `(countless < k ` `            ``&& (countless + countequal) >= k)  ` `        ``{ ` `            ``return` `mid; ` `        ``} ` ` `  `        ``// If the required element is less than mid ` `        ``else` `if` `(countless >= k)  ` `        ``{ ` `            ``high = mid - 1; ` `        ``} ` ` `  `        ``// If the required element is greater than mid ` `        ``else` `if` `(countless < k ` `                ``&& countless + countequal < k) ` `        ``{ ` `            ``low = mid + 1; ` `        ``} ` `    ``} ` `    ``return` `int``.MinValue; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args)  ` `{ ` `    ``int` `[]arr = { 7, 10, 4, 3, 20, 15 }; ` `    ``int` `n = arr.Length; ` `    ``int` `k = 3; ` ` `  `    ``Console.WriteLine(kthSmallest(arr, k, n)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```7
```

Time Complexity: O(N log(Max – Min)) where Max and Min are the maximum and minimum elements from the array respectively and N is the size of the array.

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.