Svarende til Flet sortering algoritmen, er Quick Sort-algoritmen en Divide and Conquer-algoritme. Den vælger til at begynde med et element som et pivotelement og opdeler det givne array omkring det valgte pivot. Der er mange forskellige versioner af quickSort, der vælger pivot på forskellige måder.
- Vælg altid det første element som en pivot (implementeret nedenfor).
- Vælg altid det sidste element som pivot.
- Vælg et tilfældigt element som pivot.
- Vælg median som omdrejningspunkt.
Nøgleprocessen i quickSort er partition() processen. Formålet med funktionen partition() er at modtage et array og et element x i arrayet som en pivot, sætte x i dens korrekte position i et sorteret array og derefter sætte alle mindre elementer (mindre end x) før x, og sætte alle større elementer (større end x) efter x. Alt dette skal gøres i lineær tid, dvs. Big O(n) .
Pseudokode til rekursiv QuickSort-funktion:
/* low -->Startindeks, høj --> Slutindeks */ quickSort(arr[], lav, høj) { if (lav Metode-1 : CPP // C++ Implementering af Quick Sort Algorithm. #include ved hjælp af navneområde 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; // partitionering af arrayet int p = partition(arr, start, end); // Sortering af venstre del quickSort(arr, start, p - 1); // Sortering af højre 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 end pivotElement . Tidskompleksitet: θ(nlogn). Rumkompleksitet : O(n). C++ // tilføjet af Manish Sharma #include ved hjælp af navneområde std; int partition(int* arr, int start, int end) { // antager sidste element som pivotElement int index = 0, pivotElement = arr[end], pivotIndex; int* temp = ny int[end - start + 1]; // laver et array, hvis størrelse er lig med det aktuelle partitionsområ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 elementerne nu i temp array er orden : // elementerne længst til venstre er mindre end pivotElement og elementerne længst til højre er større end 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!>