Sorting Algorithms and their implementations

• Arranging the data in a logical order
•
• Ascending order is a method of arranging numbers from smallest
value to largest value.
• OR
• Descending order is a method of arranging numbers from largest
value to smallest value.

Different sorting techniques
• Insertion sort
• Selection sort
• Bubble sort
• Merge sort
• Quick sort

Algorithm
• Step 1 − If the element is the first one, it is already sorted.
• Step 2 – Move to next element
• Step 3 − Compare the current element with all elements in
the sorted array
• Step 4 – If the element in the sorted array is smaller than the
current element, iterate to the next element. Otherwise, shift
all the greater element in the array by one position towards
the right
• Step 5 − Insert the value at the correct position
• Step 6 − Repeat until the complete list is sorted

Code
void insertionSort(int array[], int n)
{
int i, key, j;
for (i = 1; i < n; i++)
{
key = array[i];
j = i - 1;
while (j >= 0 && array[j] > key)
{
array[j + 1] = array[j];
j = j - 1;
}
array[j + 1] = key;
}
}

Algorithm
• Step 1 − Set MIN to location 0
• Step 2 − Search the minimum element in the list
• Step 3 − Swap with value at location MIN
• Step 4 − Increment MIN to point to next element
• Step 5 − Repeat until list is sorted

#include <stdio.h>
int main()
{
int arr[10]={6,12,0,18,11,99,55,45,34,2};
int n=10;
int i, j, min, swap;
for (i = 0; i < (n - 1); i++)
{
min = i;
for (j = i + 1; j < n; j++)
{
if (arr[min] > arr[j])
min = j;
}

if (min != i)
{
swap = arr[i];
arr[i] = arr[min];
arr[min] = swap;
}
}
for (i = 0; i < n; i++)
printf("%dt", arr[i]);
return 0;
}

Divide and Conquer
• Merge Sort is one of the most popular sorting algorithms that is
based on the principle of Divide and Conquer Algorithm.
• Here, a problem is divided into multiple sub-problems. Each sub-
problem is solved individually. Finally, sub-problems are combined to
form the final solution.
• Strategy
• Using the Divide and Conquer technique, we divide a problem into
subproblems. When the solution to each subproblem is ready, we 'combine'
the results from the subproblems to solve the main problem.

Step 1: Create duplicate copies of sub-arrays to be sorted
// Create L ← A[l..m] and R ← A[m+1..r]
int n1 = m - l + 1 = 3 - 0 + 1 = 4;
int n2 = r - m = 5 - 3 = 2;
int L[4], R[2];
for (int i = 0; i < 4; i++)
L[i] = arr[l + i];
// L[0,1,2,3] = A[0,1,2,3] = [1,5,10,12]
for (int j = 0; j < 2; j++)
R[j] = arr[m + 1 + j];
// R[0,1] = A[4,5] = [6,9]
A
L
R

Step 2: Maintain current index of sub-arrays and main array
int i, j, k;
i = 0;
j = 0;
k = l;

Step 3: Until we reach the end of either L or R, pick smaller
among elements L and R and place them in the correct
position at A[l..m]
while (i < n1 && j < n2)
{
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}

Step 4: When we run out of elements in either L or R, pick up
the remaining elements and put in A[l..m]
// We exited the earlier loop because j < n2 doesn't hold
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}

Cont..
// We exited the earlier loop because i < n1 doesn't hold
while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}

// C program for Merge Sort
#include <stdio.h>
#include <stdlib.h>
// Merges two subarrays of arr[].
// First subarray is arr[l..m]
// Second subarray is arr[m+1..r]
void merge(int arr[], int l,int m, int r)
{
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
// Create temp arrays
int L[n1], R[n2];
// Copy data to temp arrays
// L[] and R[]
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1 + j];
// Merge the temp arrays back
// into arr[l..r]
// Initial index of first subarray
i = 0;
// Initial index of second subarray
j = 0;
// Initial index of merged subarray
k = l;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
// Copy the remaining elements
// of L[], if there are any
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
// Copy the remaining elements of
// R[], if there are any
while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}
// l is for left index and r is
// right index of the sub-array
// of arr to be sorted

• void mergeSort(int arr[],int l, int r)
• {
• if (l < r)
• {
• // Same as (l+r)/2, but avoids
• // overflow for large l and h
• int m = l + (r - l) / 2;
•
• // Sort first and second halves
• mergeSort(arr, l, m);
• mergeSort(arr, m + 1, r);
•
• merge(arr, l, m, r);
• }
• }

• Quicksort is a sorting algorithm based on the divide and conquer
approach where
• 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.
• The left and right subarrays are also divided using the same
approach. This process continues until each subarray contains a
single element.
• At this point, elements are already sorted. Finally, elements are
combined to form a sorted array.

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

// Quick sort in C
#include <stdio.h>
// function to swap elements
void swap(int *a, int *b) {
int t = *a;
*a = *b;
*b = t;
}

// function to find the partition position
int partition(int array[], int low, int high) {
// select the rightmost element as pivot
int pivot = array[high];
// pointer for greater element
int i = (low - 1);
// traverse each element of the array
// compare them with the pivot
for (int j = low; j < high; j++) {
if (array[j] <= pivot) {
// if element smaller than pivot is found
// swap it with the greater element pointed by i
i++;
// swap element at i with element at j
swap(&array[i], &array[j]);
}
}
// swap the pivot element with the greater
element at i
swap(&array[i + 1], &array[high]);
// return the partition point
return (i + 1);
}

void quickSort(int array[], int low, int high) {
if (low < high) {
// find the pivot element such that
// elements smaller than pivot are on left of pivot
// elements greater than pivot are on right of pivot
int pi = partition(array, low, high);
// recursive call on the left of pivot
quickSort(array, low, pi - 1);
// recursive call on the right of pivot
quickSort(array, pi + 1, high);
}
}

// function to print array elements
void printArray(int array[], int size) {
for (int i = 0; i < size; ++i) {
printf("%d ", array[i]);
}
printf("n");
}
// main function
int main() {
int data[] = {8, 7, 2, 1, 0, 9, 6};
int n = sizeof(data) / sizeof(data[0]);
printf("Unsorted Arrayn");
printArray(data, n);
// perform quicksort on data
quickSort(data, 0, n - 1);
printf("Sorted array in ascending order: n");
printArray(data, n);
}

Sorting Algorithms and their implementations

More Related Content

Similar to Sorting Algorithms and their implementations (20)

Recently uploaded (20)

Sorting Algorithms and their implementations