Lecture 7

Sorting algorithms

1
Sorting – The Task
• Given an array
x[0], x[1], … , x[size-1]
reorder entries so that
x[0] <= x[1] <= . . . <= x[size-1]

Here, List is in non-decreasing order.

• We can also sort a list of elements in non-increasing order.

2
Sorting – Example
• Original list:
– 10, 30, 20, 80, 70, 10, 60, 40, 70

• Sorted in non-decreasing order:

– 10, 10, 20, 30, 40, 60, 70, 70, 80

• Sorted in non-increasing order:

– 80, 70, 70, 60, 40, 30, 20, 10, 10

3
Sorting Problem
• What do we want :
- Data to be sorted in order

0 size-1
x: Unsorted list

Sorted list

4
Issues in Sorting
Many issues are there in sorting techniques
• How to rearrange a given set of data?
• Which data structures are more suitable to store data prior
to their sorting?
• How fast the sorting can be achieved?
• How sorting can be done in a memory constraint situation?
• How to sort various types of data?

5
Sorting Algorithms

6
Sorting by Comparison
• Basic operation involved in this type of sorting
technique is comparison. A data item is compared
with other items in the list of items in order to find
its place in the sorted list.
• Insertion
• Selection
• Exchange
• Enumeration

7
Sorting by Comparison
Sorting by comparison – Insertion:
• From a given list of items, one item is considered at a time.
The item chosen is then inserted into an appropriate position
relative to the previously sorted items. The item can be
inserted into the same list or to a different list.
e.g.: Insertion sort
Sorting by comparison – Selection:

• First the smallest (or largest) item is located and it is separated

from the rest; then the next smallest (or next largest) is
selected and so on until all item are separated.
e.g.: Selection sort, Heap sort

8
Sorting by Comparison
Sorting by comparison – Exchange:

• If two items are found to be out of order, they are

interchanged. The process is repeated until no more exchange
is required.
e.g.: Bubble sort, Shell Sort, Quick Sort
Sorting by comparison – Enumeration:
• Two or more input lists are merged into an output list and
while merging the items, an input list is chosen following the
required sorting order.
e.g.: Merge sort

9
Sorting by Distribution
• No key comparison takes place
• All items under sorting are distributed over an auxiliary storage
space based on the constituent element in each and then grouped
them together to get the sorted list.
• Distributions of items based on the following choices
 Radix - An item is placed in a space decided by the
bases (or radix) of its components with which it is
composed of.
 Counting - Items are sorted based on their relative counts.
 Hashing - Items are hashed, that is, dispersed into a list
based on a hash function.
Note: This lecture concentrates only on sorting by comparison.

10
Insertion Sort

11
Insertion Sort

General
0
situation : i size-1
x: smallest elements, sorted remainder, unsorted

i Compare and
Shift till x[i] is
larger.
i

j
0 size-1

12
Insertion Sort
void insertionSort (int list[], int size)
{
int i,j,item;

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

{
item = list[i] ;
/* Move elements of list[0..i-1], that are greater than
item, to one position ahead of their current position */

for (j=i-1; (j>=0)&& (list[j] > item); j--)

list[j+1] = list[j];
list[j+1] = item ;
}
}

13
Insertion Sort
int main()
{
int x[ ]={-45,89,-65,87,0,3,-23,19,56,21,76,-50};

int i;
for(i=0;i<12;i++)
printf("%d ",x[i]);
OUTPUT
printf("\n");
-45 89 -65 87 0 3 -23 19 56 21 76 -50
insertionSort(x,12);
-65 -50 -45 -23 0 3 19 21 56 76 87 89
for(i=0;i<12;i++)
printf("%d ",x[i]);
printf("\n");
}

14
Insertion Sort - Example

15
Insertion Sort: Complexity Analysis
Case 1: If the input list is already in sorted order

Number of comparisons: Number of comparison in each

iteration is 1.

𝐶 𝑛 = 1 + 1 + 1 + ⋯ + 1 upto (n-1)th iteration.

Number of movement: No data movement takes place in any

iteration.
𝑀 𝑛 =0

16
Insertion Sort: Complexity analysis
Case 2: If the input list is sorted but in reverse order
Number of comparisons: Number of comparison in each
iteration is 1.
𝑛(𝑛 − 1)
𝐶 𝑛 = 1 + 2 +3 +⋯+ 𝑛 − 1 =
2
Number of movement: Number of movements takes place in
any ith iteration is i.
𝑛(𝑛 − 1)
𝑀 𝑛 = 1 + 2 + 3 + ⋯+ 𝑛 − 1 =
2

17
Insertion Sort: Complexity analysis
Case 3: If the input list is in random order
• Let 𝑝𝑗 be the probability that the key will go to the 𝑗𝑡𝑕 location
(1 ≤ 𝑗 ≤ 𝑖 + 1). Then the number of comparisons will be 𝑗 ∙ 𝑝𝑗 .

• The average number of comparisons in the (i + 1)𝑡𝑕 iteration is

𝑖+1

𝐴𝑖+1 = 𝑗 ∙ 𝑝𝑗
𝑗=1

• Assume that all keys are distinct and all permutations of keys are
equally likely.
1
𝑝1 = 𝑝2 = 𝑝3 = ⋯ = 𝑝𝑖+1 =
𝑖+1

18
Insertion Sort: Complexity analysis
Case 3: Number of comparisons
• Therefore, the average number of comparisons in the
(i + 1)𝑡𝑕 iteration
𝑖+1
1 1 𝑖+1 ∙ 𝑖+2 𝑖+2
𝐴𝑖+1 = 𝑗= ∙ =
𝑖+1 𝑖+1 2 2
𝑗=1

• Total number of comparisons for all (𝑛 − 1) iterations is

𝑛−1
1 𝑛 𝑛−1
𝐶 𝑛 = 𝐴𝑖+1 = ∙ + (𝑛 − 1)
2 2
𝑖=0

19
Insertion Sort: Complexity analysis
Case 3: Number of Movements
• On the average, number of movements in the 𝑖𝑡𝑕 iteration

𝑖 + 𝑖 − 1 + 𝑖 − 2 + ⋯+ 2 + 1 𝑖 + 1
𝑀𝑖 = =
𝑖 2

• Total number of movements

𝑛−1
1 𝑛 𝑛−1 𝑛−1
𝑀 𝑛 = 𝑀𝑖 = ∙ +
2 2 2
𝑖=1

20
Insertion Sort: Summary of Complexity Analysis
Case Comparisons Movement Memory Remarks
Case 1 C 𝑛 = (𝑛 − 1) 𝑀 𝑛 =0 𝑆 𝑛 =𝑛 Input list is in sorted
order
Case 2 𝑛(𝑛 − 1) 𝑛(𝑛 − 1) 𝑆 𝑛 =𝑛 Input list is sorted in
C 𝑛 = 𝑀 𝑛 =
2 2 reverse order

Case 3 (𝑛 − 1)(𝑛 + 4) (𝑛 − 1)(𝑛 + 2) 𝑆 𝑛 =𝑛 Input list is in random

C 𝑛 = 𝑀 𝑛 =
4 4 order

Case Run time, 𝑻(𝒏) Complexity Remarks

Case 1 𝑇 𝑛 = 𝑐 (𝑛 − 1) 𝑇 𝑛 = 𝑂(𝑛)
Best case

Case 2 𝑇 𝑛 = 𝑐 𝑛(𝑛 − 1) 𝑇 𝑛 = 𝑂(𝑛2 ) Worst case

Case 3 (𝑛 − 1)(𝑛 + 3) 𝑇 𝑛 = 𝑂(𝑛2 )

𝑇 𝑛 =𝑐 Average case
2

21
Selection Sort

22
Selection Sort
General situation :
0 k size-1
x: smallest elements, sorted remainder, unsorted

Steps :
• Find smallest element, mval, in x[k…size-1]
• Swap smallest element with x[k], then increase k.

0 k mval size-1
x:

swap

23
Selection Sort
/* Yield location of smallest element in
x[k .. size-1];*/

int findMinLloc (int x[ ], int k, int size)

{
int j, pos; /* x[pos] is the smallest
element found so far */
pos = k;
for (j=k+1; j<size; j++)
if (x[j] < x[pos])
pos = j;
return pos;
}

24
Selection Sort
/* The main sorting function */
/* Sort x[0..size-1] in non-decreasing order */

int selectionSort (int x[], int size)

{ int k, m;
for (k=0; k<size-1; k++)
{
m = findMinLoc(x, k, size);
temp = a[k];
a[k] = a[m];
a[m] = temp;
}
}

25
Selection Sort - Example
x: 3 12 -5 6 142 21 -17 45 x: -17 -5 3 6 12 21 142 45

x: -17 12 -5 6 142 21 3 45 x: -17 -5 3 6 12 21 45 142

x: -17 -5 12 6 142 21 3 45 x: -17 -5 3 6 12 21 45 142

x: -17 -5 3 6 142 21 12 45

x: -17 -5 3 6 142 21 12 45

x: -17 -5 3 6 12 21 142 45

26
Selection Sort: Complexity Analysis
Case 1: If the input list is already in sorted order
Number of comparisons:
𝑛−1
𝑛(𝑛 − 1)
𝐶 𝑛 = 𝑛−𝑖 =
2
𝑖=1

Number of movement: no data movement takes place in any

iteration.
𝑀 𝑛 =0

27
Selection Sort: Complexity Analysis
Case 2: If the input list is sorted but in reverse order
Number of comparisons:
𝑛−1
𝑛(𝑛 − 1)
𝑐 𝑛 = 𝑛−𝑖 =
2
𝑖=1

Number of movements:
3
𝑀 𝑛 = (𝑛 − 1)
2

28
Selection Sort: Complexity Analysis
Case 3: If the input list is in random order
Number of comparisons:
𝑛(𝑛 − 1)
𝐶 𝑛 =
2
• Let 𝑝𝑖 be the probability that the 𝑖𝑡𝑕 smallest element is in the 𝑖𝑡𝑕
position. Number of total swap operations = (1 − 𝑝𝑖 ) × (𝑛 − 1)
1
where 𝑝1 = 𝑝2 = 𝑝3 = ⋯ = 𝑝𝑛 =
𝑛

• Total number of movements

1 3(𝑛 − 1)(𝑛 − 1)
𝑀 𝑛 = 1− × 𝑛−1 ×3=
𝑛 𝑛

29
Selection Sort: Summary of Complexity analysis
Case Comparisons Movement Memory Remarks
Case 1 𝑛(𝑛 − 1) 𝑀 𝑛 =0 𝑆 𝑛 =0 Input list is in sorted
𝑐 𝑛 =
2 order
Case 2 𝑛(𝑛 − 1) 3(𝑛 − 1) 𝑆 𝑛 =0 Input list is sorted in
𝑐 𝑛 = 𝑀 𝑛 =
2 2 reverse order

𝑛(𝑛 − 1) 2 𝑆 𝑛 =0
Case 3 3 𝑛−1 Input list is in random
𝑐 𝑛 = 𝑀 𝑛 =
2 𝑛 order

Case Run time, 𝑻(𝒏) Complexity Remarks

Case 1 𝑛(𝑛 − 1) 𝑇 𝑛 = 𝑂(𝑛2 )
𝑇 𝑛 = Best case
2
Case 2 (𝑛 − 1)(𝑛 + 3) 𝑇 𝑛 = 𝑂(𝑛2 )
𝑇 𝑛 = Worst case
2
Case 3 (𝑛 − 1)(2𝑛 + 3) 𝑇 𝑛 = 𝑂(𝑛2 )
𝑇 𝑛 ≈ Average case
2
(Taking 𝑛 − 1 ≈ 𝑛)

30
Bubble Sort

31
Bubble Sort
In every iteration The sorting process proceeds in
heaviest element drops
several passes.
at the bottom.
• In every pass we go on
comparing neighbouring pairs,
and swap them if out of order.
• In every pass, the largest of the
elements under considering
will bubble to the top (i.e., the
The bottom
moves upward. right).

32
Bubble Sort
How the passes proceed?
• In pass 1, we consider index 0 to n-1.
• In pass 2, we consider index 0 to n-2.
• In pass 3, we consider index 0 to n-3.
• ……
• ……
• In pass n-1, we consider index 0 to 1.

33
Bubble Sort - Example
Pass: 1

x: 3 12 -5 6 72 21 -7 45 x: 3 -5 6 12 72 21 -7 45

x: 3 12 -5 6 72 21 -7 45 x: 3 -5 6 12 21 72 -7 45

x: 3 -5 12 6 72 21 -7 45 x: 3 -5 6 12 21 -7 72 45

x: 3 -5 6 12 72 21 -7 45 x: 3 -5 6 12 21 -7 45 72

34
Bubble Sort - Example
Pass: 2

x: 3 -5 6 12 21 -7 45 72 x: -5 3 6 12 21 -7 45 72

x: -5 3 6 12 21 -7 45 72 x: -5 3 6 12 -7 21 45 72

x: -5 3 6 12 21 -7 45 72 x: -5 3 6 12 -7 21 45 72

x: -5 3 6 12 21 -7 45 72

35
Bubble Sort
void swap(int *x, int *y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}

void bubble_sort(int x[], int n)

{
int i,j;
for (i=n-1; i>0; i--)
for (j=0; j<i; j++)
if (x[j] > x[j+1])
swap(&x[j],&x[j+1]);
}

36
Bubble Sort
int main()
{
int x[ ]={-45,89,-65,87,0,3,-23,19,56,21,76,-50};
int i;
for(i=0;i<12;i++)
printf("%d ",x[i]); OUTPUT
printf("\n");
-45 89 -65 87 0 3 -23 19 56 21 76 -50
bubble_sort(x,12);
for(i=0;i<12;i++) -65 -50 -45 -23 0 3 19 21 56 76 87 89
printf("%d ",x[i]);
printf("\n");
}

37
Bubble Sort: Complexity analysis
Case 1: If the input list is already in sorted order
Number of comparisons:
𝑛(𝑛 − 1)
𝐶 𝑛 =
2

Number of movements:
𝑀 𝑛 =0

38
Bubble Sort: Complexity analysis
Case 2: If the input list is sorted but in reverse order
Number of comparisons:
𝑛(𝑛 − 1)
𝑐 𝑛 =
2

Number of movements:
𝑛(𝑛 − 1)
𝑀 𝑛 =
2

39
Bubble Sort: Complexity analysis
Case 3: If the input list is in random order
Number of comparisons:
𝑛(𝑛 − 1)
𝐶 𝑛 =
2
Number of movements:
• Let 𝑝𝑗 be the probability that the largest element is in the unsorted
part is in 𝑗𝑡𝑕 (1 ≤ 𝑗 ≤ 𝑛 − 𝑖 + 1) location.
• The average number of swaps in the 𝑖𝑡𝑕 pass is
𝑛−𝑖+1

= 𝑛 − 𝑖 + 1 − 𝑗 ∙ 𝑝𝑗
𝑗=1

40
Bubble Sort: Complexity analysis
Case 3: If the input list is in random order
Number of movements:
1
• 𝑝1 = 𝑝2 = 𝑝𝑛−𝑖+1 =
𝑛−𝑖+1
• Therefore, the average number of swaps in the 𝑖𝑡𝑕 pass is
𝑛−𝑖+1
1 𝑛−𝑖
= ∙ 𝑛−𝑖+1−𝑗 =
𝑛−𝑖+1 2
𝑗=1
• The average number of movements
𝑛−1
𝑛 − 𝑖 𝑛(𝑛 − 1)
𝑀(𝑛) = =
2 4
𝑖=1

41
Bubble Sort: Summary of Complexity analysis
Case Comparisons Movement Memory Remarks
Case 1 𝑛(𝑛 − 1) 𝑀 𝑛 =0 𝑆 𝑛 =0 Input list is in sorted
𝑐 𝑛 =
2 order
Case 2 𝑛(𝑛 − 1) 𝑛(𝑛 − 1) 𝑆 𝑛 =0 Input list is sorted in
𝑐 𝑛 = 𝑀 𝑛 =
2 2 reverse order

Case 3 𝑛(𝑛 − 1) 𝑛(𝑛 − 1) 𝑆 𝑛 =0 Input list is in random

𝑐 𝑛 = 𝑀 𝑛 =
2 4 order

Case Run time, 𝑻(𝒏) Complexity Remarks

Case 1 𝑛(𝑛 − 1) 𝑇 𝑛 = 𝑂(𝑛2 )
𝑇 𝑛 =𝑐 Best case
2
Case 2 𝑇 𝑛 = 𝑐𝑛 𝑛 − 1 𝑇 𝑛 = 𝑂(𝑛2 ) Worst case

Case 3 3 𝑇 𝑛 = 𝑂(𝑛2 )
𝑇 𝑛 = 𝑛(𝑛 − 1) Average case
4

42
Bubble Sort
How do you make best case with (n-1)
comparisons only?

• By maintaining a variable flag, to check if

there has been any swaps in a given pass.
• If not, the array is already sorted.

43
Bubble Sort
void bubble_sort(int x[], int n)
{
int i,j;
int flag = 0;
for (i=n-1; i>0; i--)
{
for (j=0; j<i; j++)
if (x[j] > x[j+1])
{
swap(&x[j],&x[j+1]);
flag = 1;
}
if (flag == 0) return;
}
}

44
Efficient Sorting algorithms
Two of the most popular sorting algorithms are based on divide-
and-conquer approach.
• Quick sort
• Merge sort
Basic concept of divide-and-conquer method:
sort (list)
{
if the list has length greater than 1
{
Partition the list into lowlist and highlist;
sort (lowlist);
sort (highlist);
combine (lowlist, highlist);
}
}

45
Quick Sort

46
Quick Sort – How it Works?
At every step, we select a pivot element in the list
(usually the first element).
• We put the pivot element in the final position of the sorted
list.
• All the elements less than or equal to the pivot element are
to the left.
• All the elements greater than the pivot element are to the
right.

47
Quick Sort Partitioning
0 size-1
x:
pivot

Values smaller Values greater

Perform Perform
partitioning partitioning

48
Quick Sort
#include <stdio.h>
void quickSort( int[], int, int);
int partition( int[], int, int);
void main()
{
int i,a[] = { 7, 12, 1, -2, 0, 15, 4, 11, 9};
printf("\n\nUnsorted array is: ");
for(i = 0; i < 9; ++i)
printf(" %d ", a[i]);
quickSort( a, 0, 8);
printf("\n\nSorted array is: ");
for(i = 0; i < 9; ++i)
printf(" %d ", a[i]);
}
void quickSort( int a[], int l, int r)
{
int j;
if( l < r ) { // divide and conquer
j = partition( a, l, r);
quickSort( a, l, j-1);
quickSort( a, j+1, r);
}
}

49
Quick Sort
int partition( int a[], int l, int r)
{
int pivot, i, j, t;
pivot = a[l];
i = l;
j = r+1;
while( 1) {
do {
++i;
} while(a[i]<=pivot && i<=r);
do {
--j;
} while( a[j] > pivot );
if( i >= j ) break;
t = a[i];
a[i] = a[j];
a[j] = t;
}
t = a[l];
a[l] = a[j];
a[j] = t;
return j;
}

50
Quick Sort - Example
Input: 45 -56 78 90 -3 -6 123 0 -3 45 69 68

45 -56 78 90 -3 -6 123 0 -3 45 69 68

-6 -56 -3 0 -3 45 123 90 78 45 69 68

-56 -6 -3 0 -3 68 90 78 45 69 123
-3 0 -3 45 68 78 90 69
-3 0 69 78 90

Output: -56 -6 -3 -3 0 45 45 68 69 78 90 123

51
Quick Sort: Complexity analysis
Memory requirement:
Size of the stack is:
𝑆 𝑛 = 𝑙𝑜𝑔2 𝑛 + 1
Number of comparisons:
• Let, 𝑇(𝑛) represents total time to sort n elements and
𝑃(𝑛) represents the time for perform a partition of a list of
𝑛 elements.
𝑇 𝑛 = 𝑃 𝑛 + 𝑇 𝑛𝑙 + 𝑇 𝑛𝑟 , with 𝑇 1 = 𝑇 0 = 0
where, 𝑛𝑙 = number of elements in the left sub list
𝑛𝑟 = number of elements in the right sub list and 0 ≤ 𝑛𝑙 , 𝑛𝑟 < 𝑛

52
Quick Sort: Complexity analysis
Case 1: Elements in the list are in ascending order
Number of comparisons:
𝐶 𝑛 = 𝑛 − 1 + 𝐶 𝑛 − 1 , with 𝐶 1 = 𝐶 0 = 0
𝐶 𝑛 = 𝑛 − 1 + 𝑛 − 2 + 𝑛 − 3 + ⋯+ 2 + 1
𝑛(𝑛 − 1)
𝐶 𝑛 =
2
Number of movements:
𝑀 𝑛 =0

53
Quick Sort: Complexity analysis
Case 2: Elements in the list are in reverse order
Number of comparisons:
𝐶 𝑛 = 𝑛 − 1 + 𝐶 𝑛 − 1 , with 𝐶 1 = 𝐶 0 = 0
𝐶 𝑛 = 𝑛 − 1 + 𝑛 −2 + 𝑛 −3 +⋯+2 +1
𝑛(𝑛 − 1)
𝐶 𝑛 =
2
Number of movements:
𝑛−1
, 𝑖𝑓 𝑛 𝑖𝑠 𝑜𝑑𝑑
𝑀 𝑛 = 𝑛2
, 𝑖𝑓 𝑛 𝑖𝑠 𝑒𝑣𝑒𝑛
2

54
Quick Sort: Complexity analysis
Case 3: Elements in the list are in random order
𝒊𝒕𝒉 location
(i-1) (n-1)

Number of comparisons:
𝑛−1
1
𝐶 𝑛 = 𝑛−1 + 𝐶 𝑖 − 1 + 𝐶(𝑛 − 1) 𝑤𝑖𝑡𝑕 𝐶 1 = 𝐶 0 = 0
𝑛
𝑖=1
𝑛−1
2
𝐶 𝑛 = 𝑛−1 + 𝐶(𝑖)
𝑛
𝑖=1

𝐶 𝑛 = 2 𝑛 + 1 𝑙𝑜𝑔𝑒 𝑛 + 0.577 − 4𝑛

55
Quick Sort: Complexity analysis
Case 3: Elements in the list are in random order
Number of movements:
𝑛
1
𝑀 𝑛 = 𝑖 − 1 + 𝑀 𝑖 − 1 + 𝑀(𝑛 − 𝑖)
𝑛
𝑖=1
𝑛−1
𝑛−1 2
𝑀 𝑛 = + 𝑀(𝑖)
2 𝑛
𝑖=1

𝑀 𝑛 = 2 𝑛 + 1 𝑙𝑜𝑔𝑒 𝑛 + 0.577 − 4𝑛

56
Quick Sort: Summary of Complexity analysis
Case Comparisons Movement Memory Remarks
Case 1 𝑛(𝑛 − 1) 𝑀 𝑛 =0 𝑆 𝑛 =1 Input list is in sorted
𝑐 𝑛 =
2 order
Case 2 𝑛(𝑛 − 1) 𝑛 𝑆 𝑛 =1 Input list is sorted in
𝑐 𝑛 = 𝑀 𝑛 =
2 2 reverse order
Case 3 𝐶 𝑛 = 2 𝑛 + 1 (𝑙𝑜𝑔𝑒 𝑛 𝑀 𝑛 = 2 𝑛 + 1 (𝑙𝑜𝑔𝑒 𝑛 𝑆 𝑛 Input list is in
+ 0.577) − 4𝑛 + 0.577) − 4𝑛 = 𝑙𝑜𝑔2 𝑛 + 1 random order

Case Run time, 𝑻(𝒏) Complexity Remarks

Case 1 𝑛(𝑛 − 1) 𝑇 𝑛 = 𝑂(𝑛2 )
𝑇 𝑛 =𝑐 Worst case
2
Case 2 𝑛(𝑛 − 1) 𝑛 𝑇 𝑛 = 𝑂(𝑛2 )
𝑇 𝑛 =𝑐 + Worst case
2 2

Case 3 𝑇 𝑛 = 4𝑐 𝑛 + 1 𝑙𝑜𝑔𝑒 𝑛 + 0.577 − 8𝑐𝑛 𝑇 𝑛 = 𝑂(𝑛𝑙𝑜𝑔2 𝑛) Best / Average

𝑇 𝑛 = 2𝑐 𝑛𝑙𝑜𝑔2 𝑛 − 𝑛 + 1 case

57
Merge Sort

58
Merge Sort – How it Works?
Input Array

Part-I Part-II

Part-I Part-II Part-I Part-II

Split
Merge
Sorted arrays

59
Merging two Sorted arrays
𝑷𝒂 𝑷𝒃

a: Sorted Array b: Sorted Array

0 l 0 m

c: Merged sorted array

0 l+m-1

Move and copy elements pointed by 𝑃𝑎 if its value is smaller

than the element pointed by 𝑃𝑏 in (𝑙 + 𝑚 − 1) operations and otherwise.

60
Merge Sort – Example
x: 3 12 -5 6 72 21 -7 45

3 12 -5 6 Splitting arrays 72 21 -7 45

3 12 -5 6 72 21 -7 45

3 12 -5 6 72 21 -7 45

3 12 -5 6 21 72 -7 45
Merging two
-5 3 6 12 -7 21 45 72
sorted arrays

-7
-7 -5 3 6 12 21 45 72 61
Merge Sort Program
#include<stdio.h>
void mergesort(int a[],int i,int j);
void merge(int a[],int i1,int j1,int i2,int j2);
int main()
{
int a[30],n,i;
printf("Enter no of elements:");
scanf("%d",&n);
printf("Enter array elements:");
for(i=0;i<n;i++)
scanf("%d",&a[i]);
mergesort(a,0,n-1);
printf("\nSorted array is :");
for(i=0;i<n;i++)
printf("%d ",a[i]);
return 0;
}
62
Merge Sort Program

void mergesort(int a[],int i,int j)

{
int mid;

if(i<j) {
mid=(i+j)/2;
/* left recursion */
mergesort(a,i,mid);
/* right recursion */
mergesort(a,mid+1,j);
/* merging of two sorted sub-arrays */
merge(a,i,mid,mid+1,j);
}
}

63
Merge Sort Program
void merge(int a[],int i1,int i2,int j1,int j2)
{
int temp[50]; //array used for merging
int i=i1,j=j1,k=0;
while(i<=i2 && j<=j2) //while elements in both lists
{
if(a[i]<a[j])
temp[k++]=a[i++];
else
temp[k++]=a[j++];
}
while(i<=i2) //copy remaining elements of the first list
temp[k++]=a[i++];
while(j<=j2) //copy remaining elements of the second list
temp[k++]=a[j++];
for(i=i1,j=0;i<=j2;i++,j++)
a[i]=temp[j]; //Transfer elements from temp[] back to a[]
}

64
Merge Sort – Splitting Trace
-56 23 43 -5 -3 0 123 -35 87 56 75 80

-56 23 43 -5 -3 0 123 -35 87 56 75 80

-56 23 43 -5 -3 0 123 -35 87 56 75 80

-56 23 43 -5 -3 0 123 -35 87 56 75 80

23 43 -3 0 -35 87 75 80

Output: -56 -35 -5 -3 0 23 43 56 75 80 87 123

Space Complexity?? Worst Case: O(n.log(n))

65
Merge Sort: Complexity analysis
Time Complexity:
𝑛 𝑛
𝑇 𝑛 =𝐷 𝑛 +𝑇 +𝑇 +𝐶 𝑛 𝑖𝑓 𝑛 > 1
2 2
𝑇 𝑛 = 𝑐1 𝑖𝑓 𝑛 = 1
• For simplicity of calculation
𝑛 𝑛 𝑛
𝑇 =𝑇 =𝑇
2 2 2
𝑇 𝑛 = 𝑐1 𝑖𝑓 𝑛 = 1
𝑛
𝑇 𝑛 = 𝑐2 + 2𝑇 + 𝑛−1 𝑖𝑓 𝑛 > 1
2
𝑇 𝑛 = 𝑛 ∙ 𝑐1 + 𝑛𝑙𝑜𝑔2 𝑛 + 𝑐2 − 1 𝑛 − 1 𝐴𝑠𝑠𝑢𝑚𝑖𝑛𝑔 𝑛 = 2𝑘

66
Quick Sort vs. Merge Sort
• Quick sort
• hard division, easy combination
• partition in the divide step of the divide-and-conquer
framework
• hence combine step does nothing

• Merge sort
• easy division, hard combination
• merge in the combine step
• the divide step in this framework does one simple
calculation only

67
Quick Sort vs. Merge Sort
Both the algorithms divide the problem into two sub
problems.
• Merge sort:
– two sub problems are of almost equal size always.

• Quick sort:
– an equal sub division is not guaranteed.

• This difference between the two sorting methods appears as

the deciding factor of their run time performances.

68