Lesson 4

Hello, learner! Today, we're diving into Quick Sort, a speedy sorting algorithm akin to sorting toys by size. We'll explore how it works and implement it in JavaScript, so hang tight!

Quick Sort, devised by Tony Hoare in 1959, leverages the divide-and-conquer strategy. It selects a pivot element and then arranges all smaller elements to one side and larger ones to the other.

Quick Sort operates in three steps:

- Selecting a pivot.
- Shifting elements smaller than the pivot to one side, and moving elements larger than the pivot to the other side.
- Repeating these steps for both sides separately.

Consider, for instance, sorting `[3, 9, 4, 7, 5, 1, 6, 2, 8]`

with `7`

as the pivot. After one round, it becomes `[3, 4, 5, 1, 6, 2, 7, 9, 8]`

. The pivot `7`

is correctly placed, and we can then divide the array into two parts: `[3, 4, 5, 1, 6]`

and `[9, 8]`

, which can be sorted separately.

Let's implement Quick Sort in JavaScript. First, we partition the array around the pivot in our `partition`

function:

JavaScript`1function partition(arr, low, high) { 2 let pivot = arr[high]; // The pivot is the last element 3 let i = low - 1; 4 for (let j = low; j < high; j++) { 5 if (arr[j] <= pivot) { // If the current element is smaller than the pivot 6 i++; 7 [arr[i], arr[j]] = [arr[j], arr[i]]; // Swap the current element with the element at index i 8 } 9 } 10 [arr[i + 1], arr[high]] = [arr[high], arr[i + 1]]; // Position the pivot in the correct position in the array 11 return i + 1; 12}`

In this portion of the code, we selected the last element as the pivot and placed smaller elements on the left.

The function starts by initializing `i`

to one index before the `start`

. This `i`

basically keeps track of the latest position where an element has been swapped because it was less than or equal to the pivot. If `arr[j]`

is less than or equal to the pivot, `i`

is incremented and then `arr[j]`

is swapped with `arr[i]`

. Essentially, smaller elements get pushed towards the front of the array (or the given part of the array).

The `start`

and `end`

parameters control which part of the given array is under the partition operation. Using these parameters, we can apply partition to some part of the array, which will be helpful later.

Then, we apply Quick Sort with a function that invokes `partition`

and recursively sorts the two halves:

JavaScript`1function quickSort(arr, low, high) { 2 if (low < high) { 3 let pi = partition(arr, low, high); 4 quickSort(arr, low, pi - 1); // Recursively sort the left half 5 quickSort(arr, pi + 1, high); // Recursively sort the right half 6 } 7}`

Spot on! We've just created a fully functioning Quick Sort algorithm in JavaScript.

The time complexity of Quick Sort can vary. Generally speaking, the more unique items there are, the quicker Quick Sort works. In the best and average cases, it shines with a time complexity of $O(n * log(n))$. However, the time complexity can degrade to $O(n^2)$ in the worst case.

Kudos! You've mastered the basics of Quick Sort and its implementation in JavaScript and have analyzed its time complexity. Up next, we have engaging practice exercises lined up. Are you ready to flex your newly acquired skills?