# What Is Quick Sort in Data Structure in C?

//

Larry Thompson

Quick Sort is a popular sorting algorithm in computer science and is widely used in various applications. It is based on the divide-and-conquer strategy and has an average time complexity of O(n log n). In this article, we will explore what Quick Sort is and how it works in the context of data structures using the C programming language.

What is Quick Sort?
Quick Sort, as the name suggests, is a fast sorting algorithm that efficiently sorts an array or list of elements. It was developed by British computer scientist Tony Hoare in 1959 and has since become one of the most commonly used sorting algorithms.

The Working Principle
The Quick Sort algorithm follows a simple principle: divide and conquer. It works by selecting a pivot element from the array and partitioning the 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.

## Algorithm Steps

1. Choose a pivot element from the array. 2. Partition: Rearrange elements such that all elements smaller than the pivot come before it, and all elements greater than the pivot come after it.

3. Recursively apply steps 1 and 2 to the sub-arrays formed by dividing the original array into two parts. 4. Combine: Join all sub-arrays to obtain a sorted array.

Choosing a Pivot Element
The efficiency of Quick Sort greatly depends on choosing an appropriate pivot element. There are different strategies for selecting a pivot, such as choosing the first element, last element, or a random element from the array.

### Partitioning

Partitioning is a crucial step in Quick Sort where we rearrange the elements around the chosen pivot element. The goal is to place all smaller elements before the pivot and all larger elements after it.

• Select the pivot element.
• Initialize two pointers, i and j, pointing to the first and last elements of the array respectively.
• Increment i until an element greater than the pivot is found.
• Decrement j until an element smaller than the pivot is found.
• If i is less than or equal to j, swap the elements at positions i and j.
• Repeat steps 3-5 until i is greater than j.

### Recursive Sorting

After partitioning, we will have two sub-arrays. We recursively apply the same steps to these sub-arrays until we reach a base case where there are no more elements to divide.

Pseudo code for Quick Sort:

```function quickSort(arr[], low, high)
if low < high
pivotIndex = partition(arr, low, high)
quickSort(arr, low, pivotIndex - 1)
quickSort(arr, pivotIndex + 1, high)

function partition(arr[], low, high)
pivot = arr[high]
i = low - 1
for j = low to high - 1
if arr[j] <= pivot
swap arr[i+1] and arr[j]
i++
swap arr[i+1] and arr[high]
return i+1
```

## Complexity Analysis

The average time complexity of Quick Sort is O(n log n), making it one of the fastest sorting algorithms. However, in the worst-case scenario (when the array is already sorted or reverse sorted), its time complexity can be O(n^2). The space complexity of Quick Sort is O(log n) due to recursive function calls.

Conclusion
Quick Sort is a powerful and efficient sorting algorithm widely used in various applications. It follows the divide-and-conquer strategy and has a good average-case time complexity. By properly choosing the pivot element and efficiently partitioning the array, Quick Sort provides a fast way to sort large sets of data.

In this article, we have explored what Quick Sort is, its working principle, and the steps involved in implementing it. We have also discussed the important concepts of choosing a pivot element, partitioning, and recursive sorting. Understanding Quick Sort will not only enhance your knowledge of sorting algorithms but also equip you with an efficient tool for handling data effectively in your programming projects.

Happy coding!