Scribd
Upload
57 views26 pages

CS301 Lec44

The document discusses various sorting algorithms including selection sort, insertion sort, bubble sort, and divide and conquer sorting algorithms like merge sort and quick sort. It provides examples and analyses the time complexity of each algorithm. Selection sort, insertion sort and bubble sort have a worst-case time complexity of O(n2) because they compare all adjacent elements in the list. Divide and conquer algorithms like merge sort and quick sort have better time complexities of O(n log n) by splitting the list into halves and merging the sorted parts.

Uploaded by

M NOOR MALIK
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
57 views26 pages

CS301 Lec44

The document discusses various sorting algorithms including selection sort, insertion sort, bubble sort, and divide and conquer sorting algorithms like merge sort and quick sort. It provides examples and analyses the time complexity of each algorithm. Selection sort, insertion sort and bubble sort have a worst-case time complexity of O(n2) because they compare all adjacent elements in the list. Divide and conquer algorithms like merge sort and quick sort have better time complexities of O(n log n) by splitting the list into halves and merging the sorted parts.

Uploaded by

M NOOR MALIK
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 26

Sorting

Lecture No.44
Data Structure

Dr. Sohail Aslam


Sorting Integers

How to sort the integers in this array?

20 8 5 10 7

5 7 8 10 20
Elementary Sorting Algorithms

 Selection Sort
 Insertion Sort
 Bubble 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
Selection Sort -- Example

a: 19 5 7 12
00 11 22 33
a: 5 19 7 12
0 1 2 3
a: 5 7 19 12
0 1 2 3
a: 5 7 12 19
0 1 2 3
a: 5 7 12 19
0 1 2 3
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)

20 8 5 10 7

5 8 20 10 7

5 7 20 10 8

5 7 8 10 20

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

 Basic idea (sorting cards):


• Starts 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

a: 19 12 5 7
0 1 2 3

a: 12 19 5 7
0 1 2 3

a: 5 12 19 7
0 1 2 3

a: 5 7 12 19
0 1 2 3
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 -- animation

count val pos


a: 19 12 5 7 1 12 0
0 1 2 3
a: 19 12
19 5 7 1 12 -1
0 1 2 3

a: 19
12 19 5 7
0 1 2 3

a: 12 19 5 7
0 1 2 3
Insertion Sort -- animation (cont)

count val pos


a: 12 19 5 7 2 5 1
0 1 2 3
a: 12 19 19
5 7 2 5 0
0 1 2 3
a: 12 19
12 19 7 2 5 -1
0 1 2 3
a: 12
5 12 19 7
0 1 2 3
a: 5 12 19 7
0 1 2 3
Insertion Sort -- animation (cont)

count val pos


a: 5 12 19 7 3 7 2
0 1 2 3
a: 5 12 19 19
7 3 7 1
0 1 2 3
a: 5 12 12
19 19 3 7 0
0 1 2 3
a: 5 12
7 12 19
0 1 2 3
a: 5 7 12 19
0 1 2 3
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

 Basic idea (lighter bubbles rise to the top):


• Exchange neighbouring items until the largest
item reaches the end of the array
• Repeat for the rest of the array
Bubble Sort -- Example

a: 19 5 12 7 a: 5 12 7 19
0 1 2 3 0 1 2 3
a: 5 19 12 7 a: 5 7 12 19
0 1 2 3 0 1 2 3

a: 5 12 19 7 a: 5 7 12 19
0 1 2 3 0 1 2 3

a: 5 12 7 19 a: 5 7 12 19
0 1 2 3 0 1 2 3

a: 5 12 7 19 a: 5 7 12 19
0 1 2 3
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 < bound; i++)
if ( arr[i] > arr[i+1] ) {
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
swapped = i;
}
bound = swapped;
}
}
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)


NLogN Algorithms

 Divide and Conquer


 Merge Sort
 Quick Sort
 Heap Sort
Divide and Conquer

What if we split the list into two parts?

10 12 8 4 2 11 7 5
Divide and Conquer

Sort the two parts:

10
4 12
8 10
8 12
4 2 11
5 7 11
5
Divide and Conquer

Then merge the two parts together:

4
2 8
4 10
5 12
7 2
8 10
5 11
7 11
12

You might also like