Vergelijkbaar met de Sortering samenvoegen algoritme, het Quick Sort-algoritme is een verdeel en heers-algoritme. Het selecteert in eerste instantie een element als een spilelement en verdeelt de gegeven array rond het gekozen spilelement. Er zijn veel verschillende versies van quickSort die op verschillende manieren een draaipunt kiezen.
- Kies altijd het eerste element als draaipunt (hieronder geïmplementeerd).
- Kies altijd het laatste element als spil.
- Kies een willekeurig element als draaipunt.
- Kies de mediaan als draaipunt.
Het belangrijkste proces in quickSort is het partitie() proces. Het doel van de functie partitie() is om een array en een element x van de array als draaipunt te ontvangen, x op de juiste positie in een gesorteerde array te plaatsen en vervolgens alle kleinere elementen (kleiner dan x) voor x te plaatsen, en alle grotere elementen (groter dan x) na x. Dit alles moet in lineaire tijd worden gedaan, dat wil zeggen Big O(n).
Pseudocode voor recursieve QuickSort-functie:
/* low -->Startindex, hoog --> Eindindex */ quickSort(arr[], low, high) { if (low Methode-1: CPP // C++ Implementatie van het Quick Sort-algoritme. #include met behulp van naamruimte std; int partitie(int arr[], int start, int end) { int pivot = arr[start]; int count = 0;<= 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]>draaipunt) { j--; } if (i pivotIndex) { swap(arr[i++], arr[j--]); } } return pivotIndex; } void quickSort(int arr[], int start, int end) {// basisscenario if (start>= end) return; // de array int p = partitie(arr, start, end); // Sorteren van het linkerdeel quickSort(arr, start, p - 1); // Het juiste deel sorteren quickSort(arr, p + 1, end); } int main() { int arr[] = { 9, 3, 4, 2, 1, 8 }; intn = 6; quickSort(arr, 0, n - 1); voor (int i = 0; ik 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 -> groter dan pivotElement . Tijdcomplexiteit: θ(nlogn). Ruimtecomplexiteit: O(n). C++ // toegevoegd door Manish Sharma #include met behulp van naamruimte std; int partitie(int* arr, int start, int end) {// uitgaande van het laatste element als pivotElement int index = 0, pivotElement = arr[end], pivotIndex; int* temp = nieuwe int[eind - begin + 1]; // een array maken waarvan de grootte gelijk is aan het huidige partitiebereik... 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]; index++; } } // alle elementen die nu in de tijdelijke array staan, zijn in de juiste volgorde: // meest linkse elementen zijn kleiner dan pivotElement en meest rechtse elementen zijn groter dan pivotElement index = 0; voor (int i = begin; i<= 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!>