Implementing QuickSort Algorithm
1018Program:
// simple C program for Quick Sort # include <stdio.h> // to swap two numbers void swap(int* a, int* b) { int t = *a; *a = *b; *b = t; } /* a[] is the array, p is starting index, that is 0, and r is the last index of array. */ void quicksort(int a[], int p, int r) { if(p < r) { int q; q = partition(a, p, r); quicksort(a, p, q); quicksort(a, q+1, r); } } int partition (int a[], int low, int high) { int pivot = arr[high]; // selecting last element as pivot int i = (low - 1); // index of smaller element for (int j = low; j <= high- 1; j++) { // If current element is smaller than or equal to pivot if (arr[j] <= pivot) { i++; // increment index of smaller element swap(&arr[i], &arr[j]); } } swap(&arr[i + 1], &arr[high]); return (i + 1); } // function to print the array void printArray(int a[], int size) { int i; for (i=0; i < size; i++) { printf("%d ", a[i]); } printf("\n"); } int main() { int arr[] = {9, 7, 5, 11, 12, 2, 14, 3, 10, 6}; int n = sizeof(arr)/sizeof(arr[0]); // call quickSort function quickSort(arr, 0, n-1); printf("Sorted array: n"); printArray(arr, n); return 0; }
Output:
Sorted List of elements
Explanation:
How Quick Sorting Works?
Following are the steps involved in quick sort algorithm:
- After selecting an element as pivot, which is the last index of the array in our case, we divide the array for the first time.
- In quick sort, we call this partitioning. It is not simple breaking down of array into 2 subarrays, but in case of partitioning, the array elements are so positioned that all the elements smaller than the pivot will be on the left side of the pivot and all the elements greater than the pivot will be on the right side of it.
- And the pivot element will be at its final sorted position.
- The elements to the left and right, may not be sorted.
- Then we pick subarrays, elements on the left of pivot and elements on the right of pivot, and we perform partitioning on them by choosing a pivot in the subarrays.
Let's consider an array with values {9, 7, 5, 11, 12, 2, 14, 3, 10, 6}
Below, we have a pictorial representation of how quick sort will sort the given array.
In step 1, we select the last element as the pivot, which is 6 in this case, and call for partitioning, hence re-arranging the array in such a way that 6 will be placed in its final position and to its left will be all the elements less than it and to its right, we will have all the elements greater than it.
Then we pick the subarray on the left and the subarray on the right and select a pivot for them, in the above diagram, we chose 3 as pivot for the left subarray and 11 as pivot for the right subarray.
And we again call for partitioning.
This Particular section is dedicated to Programs only. If you want learn more about Data Structure. Then you can visit below links to get more depth on this subject.