Quicksort Example
Hello! In this guide, I will tell you about the algorithm called Quicksort and show how to implement it using the C programming language.
So, Quicksort is an efficient sorting algorithm. On average, it performs O(n log n) comparisons to sort the array with n elements. In the worst case, it will perform O(n2) comparisons.
The essence of the algorithm is pretty simple: we choose the bearing element and then divide the array into three parts: less then the bearing element, equal to the bearing element, and bigger than the bearing element. Then, the algorithm is recursively applied to subarrays.
Program algorithm:
- Choose the bearing element.
- Divide the array into three parts:
- Create l and r variables which are assigned to the indexes of the beginning and the end of the considered subarray.
- Increase l while the element number l is less than the bearing element.
- Decrease r while the element number r is bigger than the bearing element.
- If l is still less then the r, swap the element number l and element number r, increment l and decrement r.
- If l is bigger than r, break the cycle.
- Repeat first two steps recursively until we reach the array consisting of 1 element.
So, let’s take a look at the implementation of the algorithm in the C programming language:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
void Quicksort(int a, int b){ int l = a, r = b; int bear = array[(l + r) / 2]; // choose the middle element as the bearing one while (l <= r) { while (array[l] < bear) l++; while (array[r] > bear) r--; if (l <= r) swap(array[l++], array[r--]); } if (a < r) qsort(a, r); if (b > l) qsort(l, b);} |
This realization has a lot of disadvantages, such as a possibility of the stack overflow because of a large number of nested recursions and the fact that the bearing element is always the middle one. Usually, it works normally, but in solving, for example, Olympiad problems, a tricky jury can specifically choose such tests so this solution will work too long and won’t pass the limit.
The dependence of the performance of the bearing element is one of the main disadvantages of the algorithm, and nothing can be done about it. If you need the sorting algorithm that will work with a guaranteed O(n log n) speed, you should prefer the Pyramid Sort. But usually, Quicksort is more productive than the others. It doesn’t require too much memory and it’s simple in the implementation, therefore its popularity is deserved.
Here is a screenshot of the working program:
Thanks for your attention!
