Implement divide & conquer logic in JavaScript to implement QuickSort

We are required to write a JavaScript function that takes in an array of numbers and uses the quick sort algorithm to sort it.

QuickSort Algorithm

QuickSort is a divide and conquer algorithm that works by selecting a 'pivot' element from the array and partitioning other elements into two sub-arrays according to whether they are less than or greater than the pivot. The sub-arrays are then sorted recursively.

How It Works

The algorithm follows these steps:

• Choose a pivot element (typically the middle element)
• Partition the array so elements smaller than pivot go to the left, larger ones to the right
• Recursively apply QuickSort to the left and right sub-arrays
• Combine the results to get the final sorted array

Implementation

const arr = [43, 3, 34, 34, 23, 232, 3434, 4, 23, 2, 54, 6, 54];

// Find a "pivot" element in the array to compare all other
// elements against and then shift elements before or after
// pivot depending on their values
const quickSort = (arr, left = 0, right = arr.length - 1) => {
    let len = arr.length, index;
    if(len > 1) {
        index = partition(arr, left, right)
        if(left < index - 1) {
            quickSort(arr, left, index - 1)
        }
        if(index < right) {
            quickSort(arr, index, right)
        }
    }
    return arr
}

const partition = (arr, left, right) => {
    let middle = Math.floor((right + left) / 2),
    pivot = arr[middle],
    i = left, // Start pointer at the first item in the array
    j = right // Start pointer at the last item in the array
    
    while(i <= j) {
        // Move left pointer to the right until the value at the
        // left is greater than the pivot value
        while(arr[i] < pivot) {
            i++
        }
        // Move right pointer to the left until the value at the
        // right is less than the pivot value
        while(arr[j] > pivot) {
            j--
        }
        // If the left pointer is less than or equal to the
        // right pointer, then swap values
        if(i <= j) {
            [arr[i], arr[j]] = [arr[j], arr[i]] // ES6 destructuring swap
            i++
            j--
        }
    }
    return i
}

console.log("Original array:", arr);
console.log("Sorted array:", quickSort([...arr])); // Use spread to avoid modifying original

Original array: [43, 3, 34, 34, 23, 232, 3434, 4, 23, 2, 54, 6, 54]
Sorted array: [2, 3, 4, 6, 23, 23, 34, 34, 43, 54, 54, 232, 3434]

Time Complexity

Conclusion

QuickSort is an efficient divide and conquer sorting algorithm with O(n log n) average time complexity. Its in-place partitioning makes it memory efficient, though worst-case performance can degrade to O(n²).