In this instructional exercise, you will find out about algorithm and program for snappy sort in C.

The speedy sort is the quickest interior sorting algorithm with the time multifaceted nature O (n log n).

The essential algorithm to sort an exhibit a[ ] of n components can be portrayed recursively as pursues:

**Quick Sort Algorithm**

On the off chance that n < = 1, at that point return.

Pick any component V in a[]. This is known as the pivot.

Revise components of the cluster by moving all components xi > V right of V and all components xi < = V left of V.

In the event that the spot of the V after the pre-game plan is j, all components with esteem not as much as V,

show up in a[0], a[1] . . . . a[j – 1] and each one of those with esteem more prominent than V show up in a[j + 1] . . . . a[n – 1].

Apply fast sort recursively to a[0] . . . . a[j – 1] and to a[j + 1] . . . . a[n – 1].

## Quick Sort Animation

Visualization of the quicksort algorithm. The horizontal lines are pivot values.

**Program**

```
#include <stdio.h>
void quick_sort(int[],int,int);
int partition(int[],int,int);
int main()
{
int a[50],n,i;
printf("How many elements?");
scanf("%d",&n);
printf("\nEnter array elements:");
for(i=0;i<n;i++)
scanf("%d",&a[i]);
quick_sort(a,0,n-1);
printf("\nArray after sorting:");
for(i=0;i<n;i++)
printf("%d ",a[i]);
return 0;
}
void quick_sort(int a[],int l,int u)
{
int j;
if(l<u)
{
j=partition(a,l,u);
quick_sort(a,l,j-1);
quick_sort(a,j+1,u);
}
}
int partition(int a[],int l,int u)
{
int v,i,j,temp;
v=a[l];
i=l;
j=u+1;
do
{
do
i++;
while(a[i]<v&&i<=u);
do
j--;
while(v<a[j]);
if(i<j)
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}while(i<j);
a[l]=a[j];
a[j]=v;
return(j);
}
```

In the event that you discovered anything mistaken or have any questions with respect to above quick sort in C instructional exercise at that point remark beneath.