# What Is Quick Sort Algorithm in Data Structure?

//

Heather Bennett

The Quick Sort algorithm is one of the most efficient sorting algorithms in data structure. It is a comparison-based algorithm that works by dividing the unsorted list into two smaller sub-arrays, and then recursively sorting those sub-arrays. The key idea behind Quick Sort is to choose a pivot element from the array and partition the other elements into two sub-arrays, according to whether they are less than or greater than the pivot.

## How does Quick Sort work?

The steps involved in Quick Sort are:

• Step 1: Choose an element from the array to be the pivot. This element can be chosen in different ways, such as picking the first element, last element, or a random element.
• Step 2: Partitioning: Reorder the array so that all elements with values less than the pivot come before it, while all elements with values greater than the pivot come after it (equal values can go either way). After this partitioning, the pivot is in its final sorted position.
• Step 3: Recursively apply Quick Sort on the sub-array before and after the pivot.

This process continues until each sub-array has only one element left. At this point, all elements are sorted, and when we combine these sub-arrays together, we get a completely sorted array.

## An Example

To better understand how Quick Sort works, let’s consider an example:

```[5, 9, 3, 1, 8]

The pivot is chosen as 5.

After partitioning:
[3, 1] 5 [9, 8]

The sub-arrays [3, 1] and [9, 8] are recursively sorted using Quick Sort.

After sorting:
[1, 3] 5 [8, 9]

Finally, we combine the sub-arrays to get the sorted array: [1, 3, 5, 8, 9].
```

## Analysis of Quick Sort

Quick Sort has an average case time complexity of O(n log n), which makes it highly efficient for large data sets. However, in the worst case scenario where the pivot is chosen poorly (e.g., the smallest or largest element), Quick Sort can have a time complexity of O(n^2).

Despite this worst-case scenario, Quick Sort is widely used due to its efficiency and simplicity. It is often faster in practice than other sorting algorithms like Bubble Sort or Insertion Sort.

## Conclusion

In conclusion, Quick Sort is a powerful sorting algorithm that efficiently sorts large data sets. By dividing the array into smaller sub-arrays and recursively sorting them, Quick Sort achieves an average case time complexity of O(n log n). Although it can have a worst-case time complexity of O(n^2), it remains a popular choice for sorting due to its overall efficiency.