Quickselect Algorithm - GeeksforGeeks

10 Aug, 2021
Quickselect is a selection algorithm to find the k-th smallest element in an unordered list. It is related to the quick sort sorting algorithm.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
The algorithm is similar to QuickSort. The difference is, instead of recurring for both sides (after finding pivot), it recurs only for the part that contains the k-th smallest element. The logic is simple, if index of partitioned element is more than k, then we recur for left part. If index is same as k, we have found the k-th smallest element and we return. If index is less than k, then we recur for right part. This reduces the expected complexity from O(n log n) to O(n), with a worst case of O(n^2).
function quickSelect(list, left, right, k)

   if left = right
      return list[left]

   Select a pivotIndex between left and right

   pivotIndex := partition(list, left, right, 
                                  pivotIndex)
   if k = pivotIndex
      return list[k]
   else if k < pivotIndex
      right := pivotIndex - 1
   else
      left := pivotIndex + 1 
C++14
Java
Python3
C#
Javascript
// CPP program for implementation of QuickSelect#include <bits/stdc++.h>using namespace std; // 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;} // 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 index = partition(arr, l, r);         // If position is same as k        if (index - l == k - 1)            return arr[index];         // If position is more, recur        // for left subarray        if (index - l > k - 1)            return kthSmallest(arr, l, index - 1, k);         // Else recur for right subarray        return kthSmallest(arr, index + 1, r,                            k - index + l - 1);    }     // If k is more than number of    // elements in array    return INT_MAX;} // Driver program to test above methodsint main(){    int arr[] = { 10, 4, 5, 8, 6, 11, 26 };    int n = sizeof(arr) / sizeof(arr[0]);    int k = 3;    cout << "K-th smallest element is "        << kthSmallest(arr, 0, n - 1, k);    return 0;}
// Java program of Quick Selectimport java.util.Arrays; class GFG {     // partition function similar to quick sort    // Considers last element as pivot and adds    // elements with less value to the left and    // high value to the right and also changes    // the pivot position to its respective position    // in the final array.    public static int partition(int[] arr, int low,                                int high)    {        int pivot = arr[high], pivotloc = low;        for (int i = low; i <= high; i++) {            // inserting elements of less value            // to the left of the pivot location            if (arr[i] < pivot) {                int temp = arr[i];                arr[i] = arr[pivotloc];                arr[pivotloc] = temp;                pivotloc++;            }        }         // swapping pivot to the final pivot location        int temp = arr[high];        arr[high] = arr[pivotloc];        arr[pivotloc] = temp;         return pivotloc;    }     // finds the kth position (of the sorted array)    // in a given unsorted array i.e this function    // can be used to find both kth largest and    // kth smallest element in the array.    // ASSUMPTION: all elements in arr[] are distinct    public static int kthSmallest(int[] arr, int low,                                  int high, int k)    {        // find the partition        int partition = partition(arr, low, high);         // if partition value is equal to the kth position,        // return value at k.        if (partition == k - 1)            return arr[partition];         // if partition value is less than kth position,        // search right side of the array.        else if (partition < k - 1)            return kthSmallest(arr, partition + 1, high, k);         // if partition value is more than kth position,        // search left side of the array.        else            return kthSmallest(arr, low, partition - 1, k);    }     // Driver Code    public static void main(String[] args)    {        int[] array = new int[] { 10, 4, 5, 8, 6, 11, 26 };        int[] arraycopy            = new int[] { 10, 4, 5, 8, 6, 11, 26 };         int kPosition = 3;        int length = array.length;         if (kPosition > length) {            System.out.println("Index out of bound");        }        else {            // find kth smallest value            System.out.println(                "K-th smallest element in array : "                + kthSmallest(arraycopy, 0, length - 1,                              kPosition));        }    }} // This code is contributed by Saiteja Pamulapati
# Python3 program of Quick Select # 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 # finds the kth position (of the sorted array)# in a given unsorted array i.e this function# can be used to find both kth largest and# kth smallest element in the array.# ASSUMPTION: all elements in arr[] are distinctdef 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        index = partition(arr, l, r)         # if position is same as k        if (index - l == k - 1):            return arr[index]         # If position is more, recur        # for left subarray        if (index - l > k - 1):            return kthSmallest(arr, l, index - 1, k)         # Else recur for right subarray        return kthSmallest(arr, index + 1, r,                            k - index + l - 1)    print("Index out of bound") # Driver Codearr = [ 10, 4, 5, 8, 6, 11, 26 ]n = len(arr)k = 3print("K-th smallest element is ", end = "")print(kthSmallest(arr, 0, n - 1, k)) # This code is contributed by Muskan Kalra.
// C# program of Quick Selectusing System; class GFG{         // partition function similar to quick sort    // Considers last element as pivot and adds    // elements with less value to the left and    // high value to the right and also changes    // the pivot position to its respective position    // in the readonly array.    static int partitions(int []arr,int low, int high)    {        int pivot = arr[high], pivotloc = low, temp;        for (int i = low; i <= high; i++)        {            // inserting elements of less value            // to the left of the pivot location            if(arr[i] < pivot)            {                        temp = arr[i];                arr[i] = arr[pivotloc];                arr[pivotloc] = temp;                pivotloc++;            }        }                 // swapping pivot to the readonly pivot location        temp = arr[high];        arr[high] = arr[pivotloc];        arr[pivotloc] = temp;                 return pivotloc;    }         // finds the kth position (of the sorted array)    // in a given unsorted array i.e this function    // can be used to find both kth largest and    // kth smallest element in the array.    // ASSUMPTION: all elements in []arr are distinct    static int kthSmallest(int[] arr, int low,                                int high, int k)    {        // find the partition        int partition = partitions(arr,low,high);         // if partition value is equal to the kth position,        // return value at k.        if(partition == k)            return arr[partition];                     // if partition value is less than kth position,        // search right side of the array.        else if(partition < k )            return kthSmallest(arr, partition + 1, high, k );                     // if partition value is more than kth position,        // search left side of the array.        else            return kthSmallest(arr, low, partition - 1, k );            }         // Driver Code    public static void Main(String[] args)    {        int[] array = {10, 4, 5, 8, 6, 11, 26};        int[] arraycopy = {10, 4, 5, 8, 6, 11, 26};                         int kPosition = 3;        int length = array.Length;                 if(kPosition > length)        {            Console.WriteLine("Index out of bound");        }        else        {            // find kth smallest value            Console.WriteLine("K-th smallest element in array : " +                                kthSmallest(arraycopy, 0, length - 1,                                                        kPosition - 1));        }    }} // This code is contributed by 29AjayKumar
<script>// Javascript program of Quick Select // partition function similar to quick sort    // Considers last element as pivot and adds    // elements with less value to the left and    // high value to the right and also changes    // the pivot position to its respective position    // in the final array.function _partition(arr, low, high){    let pivot = arr[high], pivotloc = low;        for (let i = low; i <= high; i++)        {                     // inserting elements of less value            // to the left of the pivot location            if (arr[i] < pivot)            {                let temp = arr[i];                arr[i] = arr[pivotloc];                arr[pivotloc] = temp;                pivotloc++;            }        }          // swapping pivot to the final pivot location        let temp = arr[high];        arr[high] = arr[pivotloc];        arr[pivotloc] = temp;          return pivotloc;} // finds the kth position (of the sorted array)    // in a given unsorted array i.e this function    // can be used to find both kth largest and    // kth smallest element in the array.    // ASSUMPTION: all elements in arr[] are distinctfunction kthSmallest(arr, low, high, k){     // find the partition        let partition = _partition(arr, low, high);          // if partition value is equal to the kth position,        // return value at k.        if (partition == k - 1)            return arr[partition];          // if partition value is less than kth position,        // search right side of the array.        else if (partition < k - 1)            return kthSmallest(arr, partition + 1, high, k);          // if partition value is more than kth position,        // search left side of the array.        else            return kthSmallest(arr, low, partition - 1, k);} // Driver Codelet array = [ 10, 4, 5, 8, 6, 11, 26];let arraycopy = [10, 4, 5, 8, 6, 11, 26 ];let kPosition = 3;let length = array.length; if (kPosition > length) {    document.write("Index out of bound<br>");}else{ // find kth smallest valuedocument.write("K-th smallest element in array : "+ kthSmallest(arraycopy, 0, length - 1,              kPosition)+"<br>");} // This code is contributed by rag2127</script>
Output: 
K-th smallest element is 6
Important Points:  
Like quicksort, it is fast in practice, but has poor worst-case performance. It is used inThe partition process is same as QuickSort, only recursive code differs.There exists an algorithm that finds k-th smallest element in O(n) in worst case, but QuickSelect performs better on average.  
Like quicksort, it is fast in practice, but has poor worst-case performance. It is used in
The partition process is same as QuickSort, only recursive code differs.
There exists an algorithm that finds k-th smallest element in O(n) in worst case, but QuickSelect performs better on average.  
Related C++ function : std::nth_element in C++This article is contributed by Sahil Chhabra . If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
ChandanKumar44
Saiteja Pamulapati
MuskanKalra1
29AjayKumar
code_ayush
Hasanul Islam
kziomek
rag2127
Order-Statistics
Quick Sort
Searching
Sorting
Searching
Sorting
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Search an element in a sorted and rotated array
Program to find largest element in an array
k largest(or smallest) elements in an array
Given an array of size n and a number k, find all elements that appear more than n/k times
Median of two sorted arrays of different sizes
Bubble Sort
Insertion Sort
Selection Sort
std::sort() in C++ STL
Time Complexities of all Sorting Algorithms