Data Structures and Algorithms

Lecture __ : Sorting Algorithms

Original Author of the lecture slides: Dr. Sohail Aslam

Sorting Integers

20 8 5 10 7

5 7 8 10 20

How to sort the integers in this array?

Elementary Sorting Algorithms

Selection Sort

Insertion Sort

Bubble Sort

Selection Sort

Selection Sort

Main idea:

find the smallest element

put it in the first position

find the next smallest element

put it in the second position

…

And so on, until you get to the end of the list

1 2 30

7 12 195a: 19

1 2 30

7 19 125a: 12

1 2 30

19 7 125a: 7

Selection Sort -- Example

1 2 30

7 12 195a:

1 2 30

5 7 1219a:a:

1 2 30

5

Selection Sort: Code

void selectionSort(int *arr, int N)

{

int posmin, count, tmp;

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

{

posmin = findIndexMin(arr,count,N);

tmp=arr[posmin];

arr[posmin]=arr[count];

arr[count]=tmp;

}

}

Selection Sort: Code

int findIndexMin(int *arr, int start,

int N)

{

int posmin=start;

int index;

for(index=start; index < N; index++)

if (arr[index]<arr[posmin])

posmin=index;

return posmin;

}

Swap Action (SelectionSorting)

5 8 20 10 7

5 7 20 10 8

5 7 8 10 20

20 8 5 10 7

5 7 8 10 20

Selection Sort Analysis

What is the time complexity of this algorithm?

Worst case == Best case == Average case

Each iteration performs a linear search on the rest of the

array

first element N +

second element N-1 +

…

penultimate element 2 +

last element 1

Total N(N+1)/2

= (N2+N)/2

Insertion Sort

Commonly used by card players

As each card is picked up, it is placed into the proper

sequence in their hand

Divide the list into a sorted sublist and an unsorted sublist

In each pass, one or more pieces of data are removed

from the unsorted sublist and inserted into their correct

position in a sorted sublist

Insertion Sort

Basic idea

Start by considering the first two elements of the array

data, if out of order, swap them

Consider the third element, insert it into the proper

position among the first three elements.

Consider the forth element, insert it into the proper

position among the first four elements.

… …

Insertion Sort -- Example

1 2 30

12 5 719a:

1 2 30

19 5 712a:

1 2 30

12 19 75a:

1 2 30

7 12 195a:

Insertion Sort: Code

void insertionSort(int *arr, int N)

{

int pos, count, val;for(count=1; count < N; count++){ val = arr[count];

for(pos=count-1; pos >= 0; pos--) if (arr[pos] > val)

arr[pos+1]=arr[pos];else break;

arr[pos+1] = val;}}

Insertion Sort – iteration 1

1 2 30

12 5 719a:

1 2 30

19 5 719a:

count val pos

1 12 0

1 12 -1

1 2 30

5 719a: 1219

1 2 30

19 5 712a:

12

Insertion Sort -- iteration 2

1 2 30

12 19 75a:

count val pos

2 5 1

2 5 -1

1 2 30

19 5 712a:

1 2 30

5 712a: 19 19

1 2 30

19 712a: 1912

2 5 0

1 2 30

12 19 712a: 5

Insertion Sort – iteration 3

1 2 30

12 19 75a:

count val pos

3 7 2

3 7 0

3 7 1

1 2 30

12 19 75a: 19

1 2 30

12 19 195a: 12

1 2 30

12 12 195a: 7

1 2 30

7 12 195a:

Insertion Sort Analysis

What is the time complexity of this algorithm?

Worst case > Average case > Best case

Each iteration inserts an element at the start of the array,

shifting all sorted elements along

second element 2 +

…

penultimate element N-1 +

last element N

Total (2+N)(N-1)/2 = O(N2)

Bubble Sort

Bubble Sort

Lighter bubbles rise to the top:

Repeat until done:

Compare adjacent pairs of items

If the pair of items are out of order, exchange them, and

continue with the next pair

If the pair is in order, ignore them and continue with the

next pair

1 2 30

12 7 195a:

Bubble Sort -- Example

1 2 30

12 7 195a:

19 12 75

1 2 30

a:

12 19 75a:

1 2 30

5 12 719

1 2 30

a: a:

1 2 30

12 7 195a:

1 2 30

7 12 195a:

1 2 30

7 12 195a:

1 2 30

7 12 195a:

1 2 30

7 12 195a:

Bubble Sort: Code

void bubbleSort(int *arr, int N){

int i, temp, bound = N-1;

int swapped = 1;

while (swapped > 0 ) {

swapped = 0;

for(i=0; i < N-1; i++)

if ( arr[i] > arr[i+1] ) {

temp = arr[i];

arr[i] = arr[i+1];

arr[i+1] = temp;

swapped = i;

}

}

}

}

Bubble Sort Analysis

What is the time complexity of this algorithm?

Worst case > Average case > Best case

Each iteration compares all the adjacent elements,

swapping them if necessary

• first iteration N +

• second iteration N-1 +

• …

• last iteration 1

• Total N(1+N)/2 = O(N2)

Summary

Insertion, Selection and Bubble sort:

Worst case time complexity is proportional to N2.

Best sorting routines are N log(N)