SORTINGS

• Sorting is a process of arranging a list of elements in a particular order.

Types

Bubble sort Selection sort Insertion Sort Quick Sort Merge Sort
 BUBBLE SORT
• Simplest sorting algorithm.
• It works by repeatedly swapping the adjacent elements if they are in wrong order.

• Complexities

Average case : Worst case :

Best case : O(n)
O(n^2) O(n^2)
 BUBBLE SORT

i
n for i in range(n-1):
0 1 2 3 4
5 8 6 3 1
 BUBBLE SORT

i
n-1 for i in range(n-1):
0 1 2 3 4 for j in range(0, n-i-1):
5 8 6 3 1

j
 BUBBLE SORT

i
n-1 for i in range(n-1):
0 1 2 3 4 for j in range(0, n-i-1):
5 8 6 3 1 if arr[j] > arr[j+1] :
                 arr[j], arr[j+1] = arr[j+1], arr[j]
5>8 false

j
 BUBBLE SORT

i
n-1 for i in range(n-1):
0 1 2 3 4 for j in range(0, n-i-1):
5 8 6 3 1 if arr[j] > arr[j+1] :
                 arr[j], arr[j+1] = arr[j+1], arr[j]
8>6 true
j swap
 BUBBLE SORT

i
n-1 for i in range(n-1):
0 1 2 3 4 for j in range(0, n-i-1):
5 6 8 3 1 if arr[j] > arr[j+1] :
                 arr[j], arr[j+1] = arr[j+1], arr[j]

j
8>3 true
swap
 BUBBLE SORT

i
n-1 for i in range(n-1):
0 1 2 3 4 for j in range(0, n-i-1):
5 6 3 8 1 if arr[j] > arr[j+1] :
                 arr[j], arr[j+1] = arr[j+1], arr[j]
8>1 true
j swap
 BUBBLE SORT

i n-1 for i in range(n-1):

0 1 2 3 4 for j in range(0, n-i-1):
5 6 3 1 8 if arr[j] > arr[j+1] :
                 arr[j], arr[j+1] = arr[j+1], arr[j]

j 5>6 false
 BUBBLE SORT

i n-1 for i in range(n-1):

0 1 2 3 4 for j in range(0, n-i-1):
5 6 3 1 8 if arr[j] > arr[j+1] :
                 arr[j], arr[j+1] = arr[j+1], arr[j]

j 6>3 true
swap
 BUBBLE SORT

i n-1 for i in range(n-1):

0 1 2 3 4 for j in range(0, n-i-1):
5 3 6 1 8 if arr[j] > arr[j+1] :
                 arr[j], arr[j+1] = arr[j+1], arr[j]

j
6>1 true
swap
 BUBBLE SORT

i n-1 for i in range(n-1):

0 1 2 3 4 for j in range(0, n-i-1):
5 3 1 6 8 if arr[j] > arr[j+1] :
                 arr[j], arr[j+1] = arr[j+1], arr[j]
5>3 true
j swap
 BUBBLE SORT

i n-1 for i in range(n-1):

0 1 2 3 4 for j in range(0, n-i-1):
3 5 1 6 8 if arr[j] > arr[j+1] :
                 arr[j], arr[j+1] = arr[j+1], arr[j]

5>1 true
j
swap
 BUBBLE SORT

n-1 for i in range(n-1):

i
0 1 2 3 4 for j in range(0, n-i-1):
3 1 5 6 8 if arr[j] > arr[j+1] :
                 arr[j], arr[j+1] = arr[j+1], arr[j]
3>1 true
j swap
 BUBBLE SORT

i n-1 for i in range(n-1):

0 1 2 3 4 for j in range(0, n-i-1):
1 3 5 6 8 if arr[j] > arr[j+1] :
                 arr[j], arr[j+1] = arr[j+1], arr[j]

j Sorted
 SELECTION SORT

• Its generally used for sorting files with very large records and small keys.
• It proceeds by finding the smallest element in unsorted list and swapping with
leftmost unsorted list.

• Complexities

Best case : Average case : Worst case :

O(n^2) O(n^2) O(n^2)
 SELECTION SORT

for i in range(len(A)):
i m=i
m n
0 1 2 3 4
5 8 6 3 1
 SELECTION SORT

for i in range(len(A)):
i m=i
m n-1
for j in range(i+1, len(A)):
0 1 2 3 4
5 8 6 3 1

j
 SELECTION SORT

for i in range(len(A)):
i m=i
m n
for j in range(i+1, len(A)):
0 1 2 3 4
if A[m] > A[j]:
5 8 6 3 1              m=j
A[i], A[m] = A[m], A[i]
j

5>8 false
 SELECTION SORT

for i in range(len(A)):
i m=i
m n
for j in range(i+1, len(A)):
0 1 2 3 4
if A[m] > A[j]:
5 8 6 3 1              m=j
A[i], A[m] = A[m], A[i]
j

5>6 false
 SELECTION SORT

for i in range(len(A)):
i m=i
n
for j in range(i+1, len(A)):
0 1 2 3 4
if A[m] > A[j]:
5 8 6 3 1              m=j
m=j=3
A[i], A[m] = A[m], A[i]
m
j

5>3 true
 SELECTION SORT

for i in range(len(A)):
i m=i
n
for j in range(i+1, len(A)):
0 1 2 3 4
if A[m] > A[j]:
5 8 6 3 1              m=j
m=j=4
A[i], A[m] = A[m], A[i]
Swap
m A[0],A[4]
j

3>1 true
 SELECTION SORT

for i in range(len(A)):
i m=i
n
for j in range(i+1, len(A)):
0 1 2 3 4
if A[m] > A[j]:
1 8 6 3 5              m=j
m=j=2
A[i], A[m] = A[m], A[i]
m

8>6 true
 SELECTION SORT

for i in range(len(A)):
i m=i
n
for j in range(i+1, len(A)):
0 1 2 3 4
if A[m] > A[j]:
1 8 6 3 5              m=j
m=j=3
A[i], A[m] = A[m], A[i]
m
j

6>3 true
 SELECTION SORT

for i in range(len(A)):
i m=i
n
for j in range(i+1, len(A)):
0 1 2 3 4
if A[m] > A[j]:
1 8 6 3 5              m=j
Swap
A[i], A[m] = A[m], A[i]
A[1],A[3]
j
m

3>5 false
 SELECTION SORT

for i in range(len(A)):
m m=i
i n
for j in range(i+1, len(A)):
0 1 2 3 4
if A[m] > A[j]:
1 3 6 8 5              m=j
A[i], A[m] = A[m], A[i]

6>8 false
 SELECTION SORT

for i in range(len(A)):
m=i
i n
for j in range(i+1, len(A)):
0 1 2 3 4
if A[m] > A[j]:
1 3 6 8 5              m=j
m=j=4
A[i], A[m] = A[m], A[i]
Swap
j m
A[2],A[4]

6>5 true
 SELECTION SORT

for i in range(len(A)):
m m=i
i n
for j in range(i+1, len(A)):
0 1 2 3 4
if A[m] > A[j]:
1 3 5 8 6              m=j
m=j=4
A[i], A[m] = A[m], A[i]
Swap
j
A[3],A[4]

8>6 true
 SELECTION SORT

for i in range(len(A)):
m
m=i
i n
for j in range(i+1, len(A)):
0 1 2 3 4
if A[m] > A[j]:
1 3 5 6 8              m=j
Sorted
A[i], A[m] = A[m], A[i]

j
 QUICK SORT

• We have three ways to choose pivot element.

• Pivot as first element
• Pivot as last element
• Pivot as median.

• Complexities

Best case : Average case : Worst case :

O(n log(n)) O(n log(n)) O(n^2)
 Quick Sort
A[p…r] pivot x=5

5 3 2 6 4 1 3 7 5 3 2 6 4 1 3 7

i j i j

3 3 2 6 4 1 5 7 3 3 2 6 4 1 5 7

i A[i] < pivot j A[i] < pivot i j

A[p…q] A[q+1…r]

3 3 2 1 4 6 5 7 3 3 2 1 4 6 5 7

i j j i
A[i] < pivot A[i] < pivot
 Quick Sort
5 3 2 6 4 1 3 7
Pivot

3 3 2 1 4 5 6 5 7

Pivot Pivot

1 2 3 3 3 4 5 6 6 7

Pivot Pivot Pivot

1 1 2 3 3 3 4 6 6 7

Pivot

3 3 4

1 2 3 3 4 5 6 7
 MERGE SORT
• It is a divide-and-conquer algorithm, which works by repeatedly dividing the array in
small parts and merging them again in the sorted order.

• Complexities

Best case : Average case : Worst case :

O(n log(n)) O(n log(n)) O(n log(n))