Quick Sort

Quick Sort is an efficient, in-place sorting algorithm that in practice is faster than Merge Sort and Heap Sort. It is based on the divide-and-conquer approach. The key process in quicksort is partitioning, which arranges the elements of the array so that all elements less than the pivot precede the pivot, and all elements greater than the pivot follow it.


Algorithm:

Bubble Sort Visualization
Complexity
Best Time Complexity O(n log n)
Average Time Complexity O(n log n)
Worst Time Complexity O(n2)
Space Complexity O(log n)

Quick Sort Visualizer

Quick Sort Code

public void quickSort(int[] arr, int low, int high) {
                        if (low < high) {
                            int pi = partition(arr, low, high);
                            quickSort(arr, low, pi-1);
                            quickSort(arr, pi+1, high);
                        }
                    }
                    
                    int partition(int[] arr, int low, int high) {
                        int pivot = arr[high];
                        int i = (low-1);
                        for (int j = low; j < high; j++) {
                            if (arr[j] < pivot) {
                                i++;
                                int temp = arr[i];
                                arr[i] = arr[j];
                                arr[j] = temp;
                            }
                        }
                        int temp = arr[i+1];
                        arr[i+1] = arr[high];
                        arr[high] = temp;
                        return i+1;
                    }
void quickSort(int arr[], int low, int high) {
                        if (low < high) {
                            int pi = partition(arr, low, high);
                            quickSort(arr, low, pi - 1);
                            quickSort(arr, pi + 1, high);
                        }
                    }
                    
                    int partition (int arr[], int low, int high) {
                        int pivot = arr[high];
                        int i = (low - 1);
                        for (int j = low; j <= high - 1; j++) {
                            if (arr[j] < pivot) {
                                i++;
                                swap(&arr[i], &arr[j]);
                            }
                        }
                        swap(&arr[i + 1], &arr[high]);
                        return (i + 1);
                    }
                    
                    void swap(int* a, int* b) {
                        int t = *a;
                        *a = *b;
                        *b = t;
                    }
void quickSort(int arr[], int low, int high) {
                        if (low < high) {
                            int pi = partition(arr, low, high);
                            quickSort(arr, low, pi - 1);
                            quickSort(arr, pi + 1, high);
                        }
                    }
                    
                    int partition (int arr[], int low, int high) {
                        int pivot = arr[high];
                        int i = (low - 1);
                        for (int j = low; j <= high - 1; j++) {
                            if (arr[j] < pivot) {
                                i++;
                                swap(&arr[i], &arr[j]);
                            }
                        }
                        swap(&arr[i + 1], &arr[high]);
                        return (i + 1);
                    }
                    
                    void swap(int* a, int* b) {
                        int t = *a;
                        *a = *b;
                        *b = t;
                    }
def quickSort(arr, low, high):
                        if low < high:
                            pi = partition(arr, low, high)
                            quickSort(arr, low, pi-1)
                            quickSort(arr, pi+1, high)
                    
                    def partition(arr, low, high):
                        pivot = arr[high]
                        i = low - 1
                        for j in range(low, high):
                            if arr[j] < pivot:
                                i += 1
                                arr[i], arr[j] = arr[j], arr[i]
                        arr[i+1], arr[high] = arr[high], arr[i+1]
                        return i + 1

Practice Questions

Question Number Question Title Level Link
1 Sort an Array Easy Link
2 Kth Largest Element in an Array Medium Link
3 Top K Frequent Elements Hard Link