Semblable à la Tri par fusion , l'algorithme Quick Sort est un algorithme Divide and Conquer. Il sélectionne initialement un élément comme élément pivot et partitionne le tableau donné autour du pivot choisi. Il existe de nombreuses versions différentes de quickSort qui sélectionnent le pivot de différentes manières.
- Choisissez toujours le premier élément comme pivot (implémenté ci-dessous).
- Choisissez toujours le dernier élément comme pivot.
- Choisissez un élément aléatoire comme pivot.
- Choisissez la médiane comme pivot.
Le processus clé de quickSort est le processus partition(). Le but de la fonction partition() est de recevoir un tableau et un élément x du tableau comme pivot, de mettre x à sa bonne position dans un tableau trié puis de mettre tous les éléments plus petits (plus petits que x) avant x, et de mettre tous les éléments plus grands (supérieurs à x) après x. Tout cela doit être fait en temps linéaire, c'est-à-dire Big O(n) .
Pseudo Code pour la fonction récursive QuickSort :
/* low -->Index de début, high --> Index de fin */ quickSort(arr[], low, high) { if (low Method-1 : CPP // Implémentation C++ de l'algorithme de tri rapide. #include using namespace std; int partition(int arr[], int start, int end) { int pivot = arr[start]; int count = 0; for (int i = start + 1; i<= end; i++) { if (arr[i] <= pivot) count++; } // Giving pivot element its correct position int pivotIndex = start + count; swap(arr[pivotIndex], arr[start]); // Sorting left and right parts of the pivot element int i = start, j = end; while (i pivotIndex) { while (arr[i] <= pivot) { i++; } while (arr[j]>pivot) {j--; } if (i pivotIndex) { swap(arr[i++], arr[j--]); } } return pivotIndex; } void quickSort(int arr[], int start, int end) { // cas de base if (start>= end) return; // partitionnement du tableau int p = partition(arr, start, end); // Tri de la partie gauche quickSort(arr, start, p - 1); // Tri de la partie droite quickSort(arr, p + 1, end); } int main() { int arr[] = { 9, 3, 4, 2, 1, 8 }; entier n = 6 ; tri rapide (arr, 0, n - 1); pour (int i = 0; je cout<< arr[i] << ' '; } return 0; } Output 1 2 3 4 8 9 Method-2 : This method’s space complexity is O(n). As we will take an extra array in partition function like in merge function of merge sort . Algorithm explanation and steps of partition function: Make a new array of size equal to given array. push all the smaller elements than pivotElement to the new array. Push pivotElement to new array now. finally, push all the greater elements than pivotElement to the new array. Now, copy the new array to the original array. Store the index of the pivotElement from the original array. Return this index. After this, all the elements in the original array are in the order : smaller than pivotElement ->pivotElement -> supérieur à pivotElement . Complexité temporelle : θ(nlogn). Complexité spatiale : O(n). C++ // ajouté par Manish Sharma #include en utilisant l'espace de noms std ; int partition(int* arr, int start, int end) { // en supposant que le dernier élément est pivotElement int index = 0, pivotElement = arr[end], pivotIndex; int* temp = new int[fin - début + 1]; // création d'un tableau dont la taille est égale à la plage de partition actuelle... for (int i = start; i<= end; i++) // pushing all the elements in temp which are smaller than pivotElement { if(arr[i] { temp[index] = arr[i]; index++; } } temp[index] = pivotElement; // pushing pivotElement in temp index++; for (int i = start; i // pushing all the elements in temp which are greater than pivotElement { if(arr[i]>pivotElement) { temp[index] = arr[i]; indice++; } } // tous les éléments maintenant dans le tableau temporaire sont dans l'ordre : // les éléments les plus à gauche sont inférieurs à pivotElement et les éléments les plus à droite sont supérieurs à pivotElement index = 0; pour (int je = début; je<= end; i++) // copying all the elements to original array i.e arr { if(arr[i] == pivotElement) { // for getting pivot index in the original array. // we need the pivotIndex value in the original and not in the temp array pivotIndex = i; } arr[i] = temp[index]; index++; } return pivotIndex; // returning pivotIndex } void quickSort(int* arr, int start, int end) { if(start { int partitionIndex = partition(arr, start, end); // for getting partition quickSort(arr, start, partitionIndex - 1); // sorting left side array quickSort(arr, partitionIndex + 1, end); // sorting right side array } return; } int main() { int size = 9; int arr[size] = {5, 12, 7, 1, 13, 2 ,23, 11, 18}; cout << 'Unsorted array : '; for (int i = 0; i { cout << arr[i] << ' '; } printf('
'); quickSort(arr, 0, size - 1); cout << 'Sorted array : '; for (int i = 0; i { cout << arr[i] << ' '; } return 0; } Output Unsorted array : 5 12 7 1 13 2 23 11 18 Sorted array : 1 2 5 7 11 12 13 18 23 Please refer complete article on QuickSort for more details!>