Quick sort algorithm is a popular sorting algorithm that uses the divide and conquer strategy to sort an array of elements. It works by selecting a pivot element and partitioning the array around the pivot such that all elements on the left of the pivot are smaller than the pivot, and all elements on the right are larger. The partitioning is done recursively until the entire array is sorted. In this article, we will explain in detail what quick sort algorithm is, how it works, and provide examples of implementing the algorithm using Python code.

**How Quick Sort Algorithm Works**

Quick sort algorithm follows the divide and conquer strategy, which involves the following steps:

- Select a pivot element from the array.
- Partition the array around the pivot such that all elements on the left of the pivot are smaller than the pivot, and all elements on the right are larger.
- Recursively apply the above two steps to the sub-arrays until the entire array is sorted.

The pivot element can be selected using different techniques, such as selecting the first or last element, selecting a random element, or selecting the median element. The partitioning is done by comparing each element to the pivot and placing it on the left or right of the pivot accordingly.

**Python Code Implementation**

Here is an example of implementing quick sort algorithm in Python:

```
def quick_sort(arr):
if len(arr) <= 1:
return arr
else:
pivot = arr[0]
left_half = [x for x in arr[1:] if x < pivot]
right_half = [x for x in arr[1:] if x >= pivot]
return quick_sort(left_half) + [pivot] + quick_sort(right_half)
```

The above code implements quick sort algorithm using the `quick_sort`

function, which takes an array `arr`

as input and sorts it in ascending order. The function first checks if the length of the array is less than or equal to one. If it is, the function returns the array as it is already sorted. Otherwise, the function selects the first element as the pivot and partitions the array around the pivot. Then, the function recursively calls itself on the left and right sub-arrays and combines the sorted sub-arrays with the pivot element to produce the final sorted array.

**Advantages and Disadvantages of Quick Sort Algorithm**

Quick sort algorithm has the following advantages:

- Efficient for large data sets due to its time complexity of O(n log n)
- In-place sorting algorithm, meaning that it does not require additional memory to sort the array
- Faster in practice than other sorting algorithms for small data sets

However, quick sort algorithm has the following disadvantages:

- Not stable, meaning that it does not preserve the order of equal elements in the array
- Worst-case time complexity of O(n^2) when the pivot is chosen poorly

**Conclusion**

Quick sort algorithm is a popular sorting algorithm that uses the divide and conquer strategy to sort an array of elements. It is efficient for sorting large data sets and is an in-place sorting algorithm. In this article, we have explained in detail what quick sort algorithm is, how it works, and provided examples of implementing the algorithm using Python code.

For complete list of topic on DATA STRUCTURE AND ALGORITHM click hear

**FAQs**

- What is the time complexity of quick sort algorithm?

- The time complexity of quick sort algorithm is O(n log n) on average and O(n^2) in the worst case.

- Is quick sort a stable sorting algorithm?

- No, quick sort is not a stable sorting algorithm as it does not preserve the order of equal elements in the array.