Quick Sort
Quick sort is the widely used sorting algorithm that makes n log n comparisons in average case for sorting of an array of n elements. This algorithm follows divide and conquer approach. The algorithm processes the array in the following way.
- Set the first index of the array to left and loc variable. Set the last index of the array to right variable. i.e. left = 0, loc = 0, en d = n - 1, where n is the length of the array.
- Start from the right of the array and scan the complete array from right to beginning comparing each element of the array with the element pointed by loc.
Ensure that, a[loc] is less than a[right].
- If this is the case, then continue with the comparison until right becomes equal to the loc.
- If a[loc] > a[right], then swap the two values. And go to step 3.
- Set, loc = right
- start from element pointed by left and compare each element in its way with the element pointed by the variable loc. Ensure that a[loc] > a[left]
- if this is the case, then continue with the comparison until loc becomes equal to left.
- [loc] < a[right], then swap the two values and go to step 2.
- Set, loc = left.
Complexity
Complexity |
Best Case |
Average Case |
Worst Case |
Time Complexity |
O(n) for 3 way partition or O(n log n) simple partition |
O(n log n) |
O(n2) |
Space Complexity |
|
|
O(log n) |
Algorithm
PARTITION (ARR, BEG, END, LOC)
- Step 1: [INITIALIZE] SET LEFT = BEG, RIGHT = END, LOC = BEG, FLAG =
- Step 2: Repeat Steps 3 to 6 while FLAG =
- Step 3: Repeat while ARR[LOC] <=ARR[RIGHT]
AND LOC != RIGHT
SET RIGHT = RIGHT - 1
[END OF LOOP]
- Step 4: IF LOC = RIGHT
SET FLAG = 1
ELSE IF ARR[LOC] > ARR[RIGHT]
SWAP ARR[LOC] with ARR[RIGHT]
SET LOC = RIGHT
[END OF IF]
- Step 5: IF FLAG = 0
Repeat while ARR[LOC] >= ARR[LEFT] AND LOC != LEFT
SET LEFT = LEFT + 1
[END OF LOOP]
- Step 6:IF LOC = LEFT
SET FLAG = 1
ELSE IF ARR[LOC] < ARR[LEFT]
SWAP ARR[LOC] with ARR[LEFT]
SET LOC = LEFT
[END OF IF]
[END OF IF]
- Step 7: [END OF LOOP]
- Step 8: END
QUICK_SORT (ARR, BEG, END)
- Step 1: IF (BEG < END)
CALL PARTITION (ARR, BEG, END, LOC)
CALL QUICKSORT(ARR, BEG, LOC - 1)
CALL QUICKSORT(ARR, LOC + 1, END)
[END OF IF]
- Step 2: END
C Program
Output:
The sorted array is:
23
23
23
34
45
65
67
89
90
101
Java Program
Output:
The sorted array is:
23
23
23
34
45
65
67
89
90
101
C# Program
Output:
The sorted array is:
23
23
23
34
45
65
67
89
90
101
|