Embed Size (px)
Citation preview
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)
