Ligner på Slå sammen sortering algoritmen, er Quick Sort-algoritmen en Divide and Conquer-algoritme. Den velger først et element som et pivotelement og deler den gitte matrisen rundt den valgte pivoten. Det er mange forskjellige versjoner av quickSort som velger pivot på forskjellige måter.
- Velg alltid det første elementet som en pivot (implementert nedenfor).
- Velg alltid det siste elementet som pivot.
- Velg et tilfeldig element som pivot.
- Velg median som en pivot.
Nøkkelprosessen i quickSort er partisjon()-prosessen. Målet med partisjon()-funksjonen er å motta en matrise og et element x i matrisen som en pivot, sette x i riktig posisjon i en sortert matrise og deretter sette alle mindre elementer (mindre enn x) før x, og sette alle større elementer (større enn x) etter x. Alt dette bør gjøres i lineær tid, dvs. Big O(n) .
Pseudokode for rekursiv QuickSort-funksjon:
/* low -->Startindeks, høy --> Sluttindeks */ quickSort(arr[], lav, høy) { if (lav Metode-1 : CPP // C++ Implementering av Quick Sort Algorithm. #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--]); } } returner pivotIndex; } void quickSort(int arr[], int start, int end) { // base case if (start>= end) return; // partisjonering av matrisen int p = partisjon(arr, start, slutt); // Sortering av venstre del quickSort(arr, start, p - 1); // Sortering av høyre del quickSort(arr, p + 1, end); } int main() { int arr[] = { 9, 3, 4, 2, 1, 8 }; int n = 6; quickSort(arr, 0, n - 1); for (int i = 0; i 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 -> større enn pivotElement . Tidskompleksitet : θ(nlogn). Romkompleksitet : O(n). C++ // lagt til av Manish Sharma #include ved å bruke navneområde std; int partisjon(int* arr, int start, int end) { // antar siste element som pivotElement int index = 0, pivotElement = arr[end], pivotIndex; int* temp = ny int[end - start + 1]; // lage en matrise hvis størrelse er lik gjeldende partisjonsområde... 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[indeks] = arr[i]; indeks++; } } // alle elementene nå i temp array er rekkefølge: // elementene lengst til venstre er mindre enn pivotElement og elementene lengst til høyre er større enn pivotElement index = 0; for (int i = start; 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!>