Snel selecteren is een selectiealgoritme om het k-de kleinste element in een ongeordende lijst te vinden. Het houdt verband met de Snel sorteren sorteeralgoritme.
Voorbeelden:

Input: arr[] = {7, 10, 4, 3, 20, 15} k = 3 Output: 7 Input: arr[] = {7, 10, 4, 3, 20, 15} k = 4 Output: 10>

Het algoritme is vergelijkbaar met QuickSort. Het verschil is dat, in plaats van dat het voor beide zijden terugkeert (na het vinden van het draaipunt), het alleen terugkeert voor het deel dat het k-de kleinste element bevat. De logica is eenvoudig: als de index van het gepartitioneerde element groter is dan k, dan herhalen we het linkerdeel. Als de index hetzelfde is als k, hebben we het k-de kleinste element gevonden en keren we terug. Als de index kleiner is dan k, dan herhalen we het juiste deel. Dit reduceert de verwachte complexiteit van O(n log n) naar O(n), met in het slechtste geval 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  C++14       // CPP program for implementation of QuickSelect  #include  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 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;  }    // 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 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) retourneert kthSmallest(arr, l, index - 1, k);     // Anders herhalen voor rechter subarray return kthSmallest(arr, index + 1, r, k - index + l - 1);   } // Als k meer is dan het aantal // elementen in de array return INT_MAX;  } // Stuurprogramma om bovenstaande methoden te testen int main() { int arr[] = { 10, 4, 5, 8, 6, 11, 26 };   int n = groottevan(arr) / groottevan(arr[0]);   intk = 3;   uit<< 'K-th smallest element is '  << kthSmallest(arr, 0, n - 1, k);   return 0;  }   Java       // Java program of Quick Select  import 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]   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 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>lengte) { System.out.println('Index buiten bereik');   } else { // vind kth kleinste waarde System.out.println( 'K-th kleinste element in array: ' + kthSmallest(arraycopy, 0, lengte - 1, kPosition));   } } } // Deze code is bijgedragen door Saiteja Pamulapati Python3 # Python3-programma van Quick Select # Standaard partitieproces van QuickSort().  # Het beschouwt het laatste element als draaipunt # en verplaatst alle kleinere elementen naar links van # it en grotere elementen naar rechts def partitie(arr, l, r): x = arr[r] i = l voor j binnen bereik(l, r): als 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 distinct  def kthSmallest(arr, l, r, k):     # if k is smaller than number of   # elements in array   if (k>0 en 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) # Anders herhaal voor rechter subarray return kthSmallest(arr, index + 1, r, k - index + l - 1) print('Index uit bound') # Stuurprogrammacode arr = [ 10, 4, 5, 8, 6, 11, 26 ] n = len(arr) k = 3 print('K-de kleinste element is ', end = ' ') print(kthSmallest(arr, 0, n - 1, k)) # Deze code is bijgedragen door Muskan Kalra.   C# // C# programma van Quick Select met behulp van System;    class GFG {// partitiefunctie vergelijkbaar met snel sorteren // beschouwt het laatste element als draaipunt en voegt // elementen met minder waarde aan de linkerkant en // hoge waarde aan de rechterkant toe en verandert ook // de draaipositie naar de respectieve positie / / in de alleen-lezen array.   statische int partities(int []arr,int laag, int hoog) { int pivot = arr[hoog], pivotloc = laag, temp;   voor (int i = laag; i<= high; i++)   {   // inserting elements of less value   // to the left of the pivot location   if(arr[i]   {   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   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>lengte) { Console.WriteLine('Index buiten bereik');   } else { // vind kth kleinste waarde Console.WriteLine('K-ste kleinste element in array: ' + kthSmallest(arraycopy, 0, lengte - 1, kPosition - 1));   } } } // Deze code is bijgedragen door 29AjayKumar Javascript // Javascript-programma van Quick Select // partitiefunctie vergelijkbaar met snel sorteren // Beschouwt het laatste element als draaipunt en voegt // elementen met minder waarde aan de linkerkant toe en // hoge waarde naar rechts en verandert ook // de draaipositie naar de respectieve positie // in de uiteindelijke array.  functie _partition(arr, laag, hoog) {let pivot = arr[high], pivotloc = laag;   voor (laat i = laag; i<= high; i++)   {     // inserting elements of less value   // to the left of the pivot location   if (arr[i]   {   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 distinct  function 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   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  let 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>lengte) { document.write('Index buiten bereik ');  } else { // find kth kleinste waarde document.write( 'K-th kleinste element in array: ' + kthSmallest(arraycopy, 0, lengte - 1, kPosition)+' ');  } // Deze code is bijgedragen door rag2127 Uitvoer: K-de kleinste element is 6 Belangrijke punten: Net als quicksort is het in de praktijk snel, maar presteert het in het slechtste geval slecht. Het wordt gebruikt in Het partitieproces is hetzelfde als QuickSort, alleen de recursieve code verschilt. Er bestaat een algoritme dat in het slechtste geval het k-de kleinste element in O(n) vindt, maar QuickSelect presteert gemiddeld beter.    Gerelateerde C++-functie: std::nth_element in C++>