Quick Sort

Quicksort is a sorting algorithm based on the divide and conquer approach where
1. An array is divided into subarrays by selecting a pivot element (element selected
from the array).

While dividing the array, the pivot element should be positioned in such a way that
elements less than pivot are kept on the left side and elements greater than pivot
are on the right side of the pivot.
2. The left and right subarrays are also divided using the same approach. This
process continues until each subarray contains a single element.

3. At this point, elements are already sorted. Finally, elements are combined to form
a sorted array.

Working of Quicksort Algorithm

1. Select the Pivot Element
There are different variations of quicksort where the pivot element is selected from
different positions. Here, we will be selecting the rightmost element of the array as the
pivot element.

Select a pivot element

2. Rearrange the Array
Now the elements of the array are rearranged so that elements that are smaller than the
pivot are put on the left and the elements greater than the pivot are put on the right.
 Put all the smaller elements on the left
and greater on the right of pivot element
Here's how we rearrange the array:

1. A pointer is fixed at the pivot element. The pivot element is compared with the
elements beginning from the first index.

Comparison of pivot
element with element beginning from the first index

2. If the element is greater than the pivot element, a second pointer is set for that

element. If the element is

greater than the pivot element, a second pointer is set for that element.

3. Now, pivot is compared with other elements. If an element smaller than the pivot
element is reached, the smaller element is swapped with the greater element
 found earlier. Pivot is
compared with other elements.

4. Again, the process is repeated to set the next greater element as the second
pointer. And, swap it with another smaller element.

The process is repeated

to set the next greater element as the second pointer.

5. The process goes on until the second last element is reached.

The process goes on until

the second last element is reached.
 6. Finally, the pivot element is swapped with the second pointer.

Finally, the pivot element

is swapped with the second pointer.

3. Divide Subarrays
Pivot elements are again chosen for the left and the right sub-parts separately. And, step
2 is repeated.

Select pivot element of in each half and

put at correct place using recursion

Experiment No:3

Write a program to sort given set of numbers in ascending/descending order using Quick sort and any
other sorting algorithm. Also record the time taken by these two programs and compare them.
To study and Implement Sort Algorithm
Knowledge of
• Array Data Structure
• Divide and Conquer Technique
Quick Sort Algorithm:

Input to the function is array A: The array to be sorted

The following procedure implements quick sort.
QUICKSORT(A, p, r)
1 if p < r
2 then q ← PARTITION(A, p, r)
3 QUICKSORT(A, p, q − 1)
4 QUICKSORT(A, q + 1, r)

To sort an entire array A, the initial call is QUICKSORT (A, 1, length[A]).

Partitioning the array
The key to the algorithm is the PARTITION procedure, which rearranges the subarray
A [p . . . r] in place.
PARTITION(A, p, r)
1 x ← A[r]
2i←p−1
3 for j ← p to r − 1
4 do if A[ j ] ≤ x
5 then i ←i + 1
6 exchange A[i ] ↔ A[ j ]
7 exchange A[i + 1] ↔ A[r]
8 return i + 1

/* Simple Quick Sort Program Using Functions and Array in C*/

/* Data Structure Programs,C Functions and Array Examples */

#include<stdio.h>

/* Declaring an array, first element as low, and last element as high */

void quicksort(int array[25],int low,int high){

int x, y, p, temp;

if(low<high){

p=low;

x=low;
y=high;

while(x<y){

while(array[x]<=array[p]&&x<high)

x++;

while(array[y]>array[p])

y--;

if(x<y){

temp=array[x];

array[x]=array[y];

array[y]=temp;

temp=array[p];

array[p]=array[y];

array[y]=temp;

quicksort(array,low,y-1);

quicksort(array,y+1,high);
 }

int main(){

int x, count, array[25];

printf("How many elements should the array have? (Max. - 25): ");

scanf("%d",&count);

printf("Enter %d elements for the array: ", count);

for(x=0;x<count;x++)

scanf("%d",&array[x]);

quicksort(array,0,count-1);

printf("After implementing quicksort the sorted order is: ");

for(x=0;x<count;x++)

printf(" %d",array[x]);

return 0;

}
 Merge Sort

Divide and Conquer

If we can break a single big problem into smaller sub-problems, solve the
smaller sub-problems and combine their solutions to find the solution for the
original big problem, it becomes easier to solve the whole problem.

Let's take an example, Divide and Rule.

When Britishers came to India, they saw a country with different religions living
in harmony, hard working but naive citizens, unity in diversity, and found it
difficult to establish their empire. So, they adopted the policy of Divide and
Rule. Where the population of India was collectively a one big problem for
them, they divided the problem into smaller problems, by instigating rivalries
between local kings, making them stand against each other, and this worked
very well for them.

Well that was history, and a socio-political policy (Divide and Rule), but the
idea here is, if we can somehow divide a problem into smaller sub-problems, it
becomes easier to eventually solve the whole problem.

In Merge Sort, the given unsorted array with n elements, is divided

into n subarrays, each having one element, because a single element is always
sorted in itself. Then, it repeatedly merges these subarrays, to produce new
sorted subarrays, and in the end, one complete sorted array is produced.

The concept of Divide and Conquer involves three steps:

1. Divide the problem into multiple small problems.

2. Conquer the subproblems by solving them. The idea is to break down the
problem into atomic subproblems, where they are actually solved.

3. Combine the solutions of the subproblems to find the solution of the

actual problem.
How Merge Sort Works?

As we have already discussed that merge sort utilizes divide-and-conquer rule

to break the problem into sub-problems, the problem in this case
being, sorting a given array.

In merge sort, we break the given array midway, for example if the original array
had 6 elements, then merge sort will break it down into two subarrays
with 3 elements each.

But breaking the orignal array into 2 smaller subarrays is not helping us in
sorting the array.

So we will break these subarrays into even smaller subarrays, until we have
multiple subarrays with single element in them. Now, the idea here is that an
array with a single element is already sorted, so once we break the original array
into subarrays which has only a single element, we have successfully broken
down our problem into base problems.
And then we have to merge all these sorted subarrays, step by step to form one
single sorted array.

Let's consider an array with values {14, 7, 3, 12, 9, 11, 6, 12}

Below, we have a pictorial representation of how merge sort will sort the given
array.
In merge sort we follow the following steps:
 1. We take a variable p and store the starting index of our array in this. And
we take another variable r and store the last index of array in it.

2. Then we find the middle of the array using the formula (p + r)/2 and mark
the middle index as q, and break the array into two subarrays,
from p to q and from q + 1 to r index.

3. Then we divide these 2 subarrays again, just like we divided our main array
and this continues.

4. Once we have divided the main array into subarrays with single elements,
then we start merging the subarrays.

Merge sort Algorithm

MergeSort(arr, left, right):

if left < right

mid = (left+right)/2

mergeSort(arr, left, mid)

mergeSort(arr, mid+1, right)

merge(arr, left, mid, right)

end
#include <stdio.h>
// lets take a[5] = {32, 45, 67, 2, 7} as the array to be
sorted.

// merge sort function

void mergeSort(int a[], int p, int r)

int q;

if(p < r)

q = (p + r) / 2;

mergeSort(a, p, q);

mergeSort(a, q+1, r);

merge(a, p, q, r);

// function to merge the subarrays

void merge(int a[], int p, int q, int r)

int b[5]; //same size of a[]

int i, j, k;

k = 0;

i = p;
 j = q + 1;

while(i <= q && j <= r)

if(a[i] < a[j])

b[k++] = a[i++]; // same as b[k]=a[i]; k++;

i++;

else

b[k++] = a[j++];

while(i <= q)

b[k++] = a[i++];

while(j <= r)

b[k++] = a[j++];

}
 for(i=r; i >= p; i--)

a[i] = b[--k]; // copying back the sorted list to

a[]

// function to print the array

void printArray(int a[], int size)

int i;

for (i=0; i < size; i++)

printf("%d ", a[i]);

printf("\n");

int main()

int arr[] = {32, 45, 67, 2, 7};

int len = sizeof(arr)/sizeof(arr[0]);

 printf("Given array: \n");

printArray(arr, len);

// calling merge sort

mergeSort(arr, 0, len - 1);

printf("\nSorted array: \n");

printArray(arr, len);

return 0;