Sorting Procedures

Bubble Sort
Selection Sort
Insertion Sort
Merge Sort
Shell Sort
Quick Sort
Bubble Sort
Original List
void Sort()
0 1 2 3 4 5 6
{
5 4 2 6 7 1 3
for (i=0; i<(n-1); i++)
Pass - 1 {
1 5 4 2 6 7 1 3 for (j=0; j<(n-i-1); j++)
{
2 4 5 2 6 7 1 3 if ( a[j] > a[j+1] )

3 4 2 5 6 7 1 3 {
t = a[j];
4 4 2 5 6 7 1 3 a[j] = a[j+1];
a[j+1] = t;
5 4 2 5 6 7 1 3
}

6 4 2 5 6 1 7 3 }
}
4 2 5 6 1 3 7 }
Original List
void Sort()
0 1 2 3 4 5 6
{
4 2 5 6 1 3 7
for (i=0; i<(n-1); i++)
Pass - 2 {
1 4 2 5 6 1 3 7 for (j=0; j<(n-i-1); j++)
{
2 2 4 5 6 1 3 7 if ( a[j] > a[j+1] )

3 2 4 5 6 1 3 7 {
t = a[j];
4 2 4 5 6 1 3 7 a[j] = a[j+1];
a[j+1] = t;
5 2 4 5 1 6 3 7
}

2 4 5 1 3 6 7 }
}
}
Original List
void Sort()
0 1 2 3 4 5 6
{
2 4 5 1 3 6 7
for (i=0; i<(n-1); i++)
Pass - 3 {
1 2 4 5 1 3 6 7 for (j=0; j<(n-i-1); j++)
{
2 2 4 5 1 3 6 7 if ( a[j] > a[j+1] )

3 2 4 5 1 3 6 7 {
t = a[j];
4 2 4 1 5 3 6 7 a[j] = a[j+1];
a[j+1] = t;
2 4 1 3 5 6 7
}
}
}
}
Original List
void Sort()
0 1 2 3 4 5 6
{
2 4 1 3 5 6 7
for (i=0; i<(n-1); i++)
Pass - 4 {
1 2 4 1 3 5 6 7 for (j=0; j<(n-i-1); j++)
{
2 2 4 1 3 5 6 7 if ( a[j] > a[j+1] )

3 2 1 4 3 5 6 7 {
t = a[j];
2 1 3 4 5 6 7 a[j] = a[j+1];
a[j+1] = t;
}
}
}
}
Original List
void Sort()
0 1 2 3 4 5 6
{
2 1 3 4 5 6 7
for (i=0; i<(n-1); i++)
Pass - 5 {
1 2 1 3 4 5 6 7 for (j=0; j<(n-i-1); j++)
{
2 1 2 3 4 5 6 7 if ( a[j] > a[j+1] )

1 2 3 4 5 6 7 {
t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}
}
}
Original List
void Sort()
0 1 2 3 4 5 6
{
1 2 3 4 5 6 7
for (i=0; i<(n-1); i++)
Pass - 6 {
1 1 2 3 4 5 6 7 for (j=0; j<(n-i-1); j++)
{
1 2 3 4 5 6 7 if ( a[j] > a[j+1] )
{
t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}
}
}
Selection Sort
Original List
0 1 2 3 4 5 6 void Sort()
5 4 2 6 7 1 3 {

Pass - 1 int m;
for (i=0; i<(n-1); i++)
1 5 4 2 6 7 1 3 {
m = i;
2 5 4 2 6 7 1 3
for (j=i+1; j<n; j++)
3 5 4 2 6 7 1 3 {
if ( a[m] > a[j] )
4 5 4 2 6 7 1 3
m = j;
5 5 4 2 6 7 1 3 }

6 5 4 2 6 7 1 3 t = a[m];
a[m] = a[i];
5 4 2 6 7 1 3 a[i] = t;
1 4 2 6 7 5 3 }
}
Original List
0 1 2 3 4 5 6 void Sort()
1 4 2 6 7 5 3 {

Pass - 2 int m;
for (i=0; i<(n-1); i++)
1 1 4 2 6 7 5 3 {
m = i;
2 1 4 2 6 7 5 3 for (j=i+1; j<n; j++)

3 1 4 2 6 7 5 3 {
if ( a[m] > a[j] )
4 1 4 2 6 7 5 3 m = j;
}
5 1 4 2 6 7 5 3
t = a[m];

1 4 2 6 7 5 3 a[m] = a[i];
a[i] = t;
1 2 4 6 7 5 3 }
}
Original List
0 1 2 3 4 5 6 void Sort()
1 2 4 6 7 5 3 {

Pass - 3 int m;
for (i=0; i<(n-1); i++)
1 1 2 4 6 7 5 3 {
m = i;
2 1 2 4 6 7 5 3 for (j=i+1; j<n; j++)

3 1 2 4 6 7 5 3 {
if ( a[m] > a[j] )
4 1 2 4 6 7 5 3 m = j;
}
1 2 4 6 7 5 3
t = a[m];

1 2 3 6 7 5 4 a[m] = a[i];
a[i] = t;
}
}
Original List
0 1 2 3 4 5 6 void Sort()
1 2 3 6 7 5 4 {

Pass - 4 int m;
for (i=0; i<(n-1); i++)
1 1 2 3 6 7 5 4 {
m = i;
2 1 2 3 6 7 5 4 for (j=i+1; j<n; j++)

3 1 2 3 6 7 5 4 {
if ( a[m] > a[j] )
1 2 3 6 7 5 4 m = j;
}
1 2 3 4 7 5 6
t = a[m];
a[m] = a[i];
a[i] = t;
}
}
Original List
0 1 2 3 4 5 6 void Sort()
1 2 3 4 7 5 6 {

Pass - 5 int m;
for (i=0; i<(n-1); i++)
1 1 2 3 4 7 5 6 {
m = i;
2 1 2 3 4 7 5 6 for (j=i+1; j<n; j++)

1 2 3 4 7 5 6 {
if ( a[m] > a[j] )
1 2 3 4 5 7 6 m = j;
}
t = a[m];
a[m] = a[i];
a[i] = t;
}
}
Original List
0 1 2 3 4 5 6 void Sort()
1 2 3 4 5 7 6 {

Pass - 6 int m;
for (i=0; i<(n-1); i++)
1 1 2 3 4 5 7 6 {
m = i;
1 2 3 4 5 7 6 for (j=i+1; j<n; j++)

1 2 3 4 5 6 7 {
if ( a[m] > a[j] )
m = j;
}
t = a[m];
a[m] = a[i];
a[i] = t;
}
}
Insertion Sort
Original List
0 1 2 3 4 5 6
5 4 2 6 7 1 3 Temp
Pass - 1 4

1 5 4 2 6 7 1 3 void Sort()
{
5 5 2 6 7 1 3 for (i=1; i<n; i++)
{
4 5 2 6 7 1 3 t = a[i] ;
j = i - 1;
while( j >= 0 && a[j] > t )
{
a[j+1] = a[j];
j--;
}
a[j+1] = t;
}
}
Original List
0 1 2 3 4 5 6
4 5 2 6 7 1 3 Temp
Pass - 2 2

1 4 5 2 6 7 1 3 void Sort()
{
2 4 5 5 6 7 1 3 for (i=1; i<n; i++)
{
4 4 5 6 7 1 3 t = a[i] ;
j = i - 1;
2 4 5 6 7 1 3 while( j >= 0 && a[j] > t )
{
a[j+1] = a[j];
j--;
}
a[j+1] = t;
}
}
Original List
0 1 2 3 4 5 6
2 4 5 6 7 1 3 Temp
Pass - 3 6

1 2 4 5 6 7 1 3 void Sort()
{
2 4 5 6 7 1 3 for (i=1; i<n; i++)
{
2 4 5 6 7 1 3 t = a[i] ;
j = i - 1;
while( j >= 0 && a[j] > t )
{
a[j+1] = a[j];
j--;
}
a[j+1] = t;
}
}
Original List
0 1 2 3 4 5 6
2 4 5 6 7 1 3 Temp
Pass - 4 7

1 2 4 5 6 7 1 3 void Sort()
{
2 4 5 6 7 1 3 for (i=1; i<n; i++)
{
2 4 5 6 7 1 3 t = a[i] ;
j = i - 1;
while( j >= 0 && a[j] > t )
{
a[j+1] = a[j];
j--;
}
a[j+1] = t;
}
}
Original List
0 1 2 3 4 5 6
2 4 5 6 7 1 3 Temp
Pass - 5 1

1 2 4 5 6 7 1 3 void Sort()
{
2 2 4 5 6 7 7 3 for (i=1; i<n; i++)
{
3 2 4 5 6 6 7 3 t = a[i] ;
j = i - 1;
4 2 4 5 5 6 7 3 while( j >= 0 && a[j] > t )
{
5 2 4 4 5 6 7 3 a[j+1] = a[j];
j--;
2 2 4 5 6 7 3 }
a[j+1] = t;
1 2 4 5 6 7 3 }
}
Original List
0 1 2 3 4 5 6
1 2 4 5 6 7 3 Temp
Pass - 6 3

1 1 2 4 5 6 7 3 void Sort()
{
2 1 2 4 5 6 7 7 for (i=1; i<n; i++)
{
3 1 2 4 5 6 6 7 t = a[i] ;
j = i - 1;
4 1 2 4 5 5 6 7 while( j >= 0 && a[j] > t )
{
5 1 2 4 4 5 6 7 a[j+1] = a[j];
j--;
1 2 4 4 5 6 7 }
a[j+1] = t;
1 2 3 4 5 6 7 }
}
Merge Sort
• Divide and Conquer

• Merge Sort
 Divide and Conquer
1. Base Case, solve the problem directly
if it is small enough

2. Divide the problem into two or more

similar and smaller subproblems

3. Recursively solve the subproblems

4. Combine solutions to the subproblems

 Divide and Conquer - Sort
Problem:
• Input: A[left..right] – unsorted array of integers

• Output: A[left..right] – sorted in non-decreasing order

 Divide and Conquer - Sort
1. Base case
at most one element (left ≥ right), return
2. Divide A into two subarrays: FirstPart, SecondPart
Two Subproblems:
sort the FirstPart
sort the SecondPart

3. Recursively
sort FirstPart
sort SecondPart

4. Combine sorted FirstPart and sorted SecondPart

 Overview
• Divide and Conquer

• Merge Sort
 Merge Sort: Idea

Divide into
A FirstPart SecondPart
two halves
Recursively
sort
FirstPart SecondPart

Merge

A is sorted!
 Merge Sort: Algorithm
Merge-Sort (A, left, right)
if left ≥ right return
else
middle ← b(left+right)/2
Recursive Call
Merge-Sort(A, left, middle)
Merge-Sort(A, middle+1, right)
Merge(A, left, middle, right)
Merge-Sort: Merge
Sorted

A:

merge
Sorted Sorted
FirstPart SecondPart

A:

A[left] A[middle] A[right]

 Merge-Sort: Merge Example

A: 2
5 3
5 7 28
15 8 30
1 4
6 5 14
10 6

L: R:
3 5 15 28 6 10 14 22

Temporary Arrays
 Merge-Sort: Merge Example

A:
3
1 5 15 28 30 6 10 14

k=0

L: R:
3
2 15
3 28
7 30
8 6
1 10
4 14
5 22
6

i=0 j=0
 Merge-Sort: Merge Example

A:
1 2
5 15 28 30 6 10 14

k=1

L: R:
3
2 5
3 15
7 28
8 6
1 10
4 14
5 22
6

i=0 j=1
 Merge-Sort: Merge Example

A:
1 2 3 28 30
15 6 10 14

k=2

L: R:
2 3 7 8 6
1 10
4 14
5 22
6

i=1 j=1
 Merge-Sort: Merge Example

A:
1 2 3 4 6 10 14

k=3

L: R:
2 3 7 8 6
1 10
4 14
5 22
6

i=2 j=1
 Merge-Sort: Merge Example

A:
1 2 3 4 5 6 10 14

k=4

L: R:
2 3 7 8 6
1 10
4 14
5 22
6

i=2 j=2
 Merge-Sort: Merge Example

A:
1 2 3 4 5 6 10 14

k=5

L: R:
2 3 7 8 6
1 10
4 14
5 22
6

i=2 j=3
 Merge-Sort: Merge Example

A:
1 2 3 4 5 6 7 14

k=6

L: R:
2 3 7 8 6
1 10
4 14
5 22
6

i=2 j=4
 Merge-Sort: Merge Example

A:
1 2 3 4 5 6 7 8
14

k=7

L: R:
3
2 5
3 15
7 28
8 6
1 10
4 14
5 22
6

i=3 j=4
 Merge-Sort: Merge Example

A:
1 2 3 4 5 6 7 8

k=8

L: R:
3
2 5
3 15
7 28
8 6
1 10
4 14
5 22
6

i=4 j=4
Merge(A, left, middle, right)
1. n1 ← middle – left + 1
2. n2 ← right – middle
3. create array L[n1], R[n2]
4. for i ← 0 to n1-1 do L[i] ← A[left +i]
5. for j ← 0 to n2-1 do R[j] ← A[middle+j]
6. k ← i ← j ← 0
7. while i < n1 & j < n2
8. if L[i] < R[j]
9. A[k++] ← L[i++]
10. else
11. A[k++] ← R[j++]
12. while i < n1
13. A[k++] ← L[i++]
14. while j < n2
15. A[k++] ← R[j++] n = n1+n2
Space: n
Time : cn for some constant c
 Merge-Sort(A, 0, 7)
Divide
A: 6 2 8 4 3 3 7 7 5 5 11
Merge-Sort(A, 0, 7)
Merge-Sort(A, 0, 3) , divide
A: 3 7 5 1

6 2 88 44
Merge-Sort(A, 0, 7)
Merge-Sort(A, 0, 1) , divide
A: 3 7 5 1

8 4

6 2
2
Merge-Sort(A, 0, 7)
Merge-Sort(A, 0, 0) , base case
A: 3 7 5 1

8 4

6
Merge-Sort(A, 0, 7)
Merge-Sort(A, 0, 0), return
A: 3 7 5 1

8 4

6 2
Merge-Sort(A, 0, 7)
Merge-Sort(A, 1, 1) , base case
A: 3 7 5 1

8 4

2
Merge-Sort(A, 0, 7)
Merge-Sort(A, 1, 1), return
A: 3 7 5 1

8 4

6 2
Merge-Sort(A, 0, 7)
Merge(A, 0, 0, 1)
A: 3 7 5 1

8 4

2 6
Merge-Sort(A, 0, 7)
Merge-Sort(A, 0, 1), return
A: 3 7 5 1

2 6 8 4
Merge-Sort(A, 0, 7)
Merge-Sort(A, 2, 3) , divide
A: 3 7 5 1

2 6

8 4
Merge-Sort(A, 0, 7)
Merge-Sort(A, 2, 2), base case
A: 3 7 5 1

2 6

8
Merge-Sort(A, 0, 7)
Merge-Sort(A, 2, 2), return
A: 3 7 5 1

2 6

8 4
Merge-Sort(A, 0, 7)
Merge-Sort(A, 3, 3), base case
A:

2 6

4
Merge-Sort(A, 0, 7)
Merge-Sort(A, 3, 3), return
A: 3 7 5 1

2 6

8 4
Merge-Sort(A, 0, 7)
Merge(A, 2, 2, 3)
A: 3 7 5 1

2 6

4 8
Merge-Sort(A, 0, 7)
Merge-Sort(A, 2, 3), return
A: 3 7 5 1

2 6 4 8
Merge-Sort(A, 0, 7)
Merge(A, 0, 1, 3)
A: 3 7 5 1

2 4 6 8
Merge-Sort(A, 0, 7)
Merge-Sort(A, 0, 3), return
A: 2 4 6 8 3 7 5 1
Merge-Sort(A, 0, 7)
Merge-Sort(A, 4, 7)
A: 2 4 6 8

3 7 5 1
Merge-Sort(A, 0, 7)
Merge (A, 4, 5, 7)
A: 2 4 6 8

1 3 5 7
Merge-Sort(A, 0, 7)
Merge-Sort(A, 4, 7), return
A: 2 4 6 8 1 3 5 7
Merge-Sort(A, 0, 7)
Merge-Sort(A,
Merge(A, 0, 3, 0,
7)7), done!
A: 1 2 3 4 5 6 7 8
Original List
1 2 3 4 5 6 7
5 4 6 2 7 1 3
List Size - 1
5 4

4 5 6 2

4 5 2 6 7 1

4 5 2 6 1 7

4 5 2 6 1 7 3
Original List
1 2 3 4 5 6 7
4 5 2 6 1 7 3
List Size - 2

4 5 2 6

2 4 5 6 1 7 3

2 4 5 6 1 3 7
Original List
1 2 3 4 5 6 7
2 4 5 6 1 3 7
List Size - 4

2 4 5 6 1 3 7

1 2 3 4 5 6 7
Shell Sort
Original List
1 2 3 4 5 6 7 void Sort()
{
5 4 2 6 7 1 3 int gap, flag;
gap = n / 2;
while( gap > 0 )
List Gap - 3 {
do
1 5 4 2 6 7 1 3 {
flag = 0;
2 5 4 2 6 7 1 3 for(i=1; i<=(n-gap); i++)
if( a[i] > a[i+gap] )
3 5 4 2 6 7 1 3 {
t = a[i];
a[i] = a[i+gap];
4 5 4 1 6 7 2 3 a[i+gap] = t;
flag = 1;
5 4 1 3 7 2 6 }
}
while(flag);
gap = gap / 2;
}
}
Original List
1 2 3 4 5 6 7 void Sort()
{
5 4 1 3 7 2 6 int gap, flag;
gap = n / 2;
while( gap > 0 )
List Gap - 3 {
do {
1 5 4 2 6 7 1 3 flag = 0;
for(i=1; i<=(n-gap); i++)
2 5 4 2 6 7 1 3 if( a[i] > a[i+gap] )
{
3 5 4 2 6 7 1 3 t = a[i];
a[i] = a[i+gap];
a[i+gap] = t;
4 5 4 1 6 7 2 3 flag = 1;
}
5 4 1 3 7 2 6 } while(flag);
gap = gap / 2;
}
}
Original List
1 2 3 4 5 6 7 void Sort()
{
5 4 1 3 7 2 6 int gap, flag;
gap = n / 2;
while( gap > 0 )
List Gap - 1 {
do {
1 5 4 1 3 7 2 6 flag = 0;
for(i=1; i<=(n-gap); i++)
2 4 5 1 3 7 2 6 if( a[i] > a[i+gap] )
{
3 4 1 5 3 7 2 6 t = a[i];
a[i] = a[i+gap];
a[i+gap] = t;
4 4 1 3 5 7 2 6 flag = 1;
}
5 4 1 3 5 7 2 3 } while(flag);
gap = gap / 2;
6 4 1 3 5 2 7 6 }
}
4 1 3 5 2 6 7 …contd.
Original List …contd. from previous
1 2 3 4 5 6 7 void Sort()
{
4 1 3 5 2 6 7 int gap, flag;
gap = n / 2;
while( gap > 0 )
List Gap - 1 {
do {
1 4 1 3 5 2 6 7 flag = 0;
for(i=1; i<=(n-gap); i++)
2 1 4 3 5 2 6 7 if( a[i] > a[i+gap] )
{
3 1 3 4 5 2 6 7 t = a[i];
a[i] = a[i+gap];
a[i+gap] = t;
4 1 3 4 5 2 6 7 flag = 1;
}
5 1 3 4 2 5 6 7 } while(flag);
gap = gap / 2;
6 1 3 4 2 5 6 7 }
}
1 3 4 2 5 6 7 …contd.
Original List …contd. from previous
1 2 3 4 5 6 7 void Sort()
{
1 3 4 2 5 6 7 int gap, flag;
gap = n / 2;
while( gap > 0 )
List Gap - 1 {
do {
1 1 3 4 2 5 6 7 flag = 0;
for(i=1; i<=(n-gap); i++)
2 1 3 4 2 5 6 7 if( a[i] > a[i+gap] )
{
3 1 3 4 2 5 6 7 t = a[i];
a[i] = a[i+gap];
a[i+gap] = t;
4 1 3 2 4 5 6 7 flag = 1;
}
5 1 3 2 4 5 6 7 } while(flag);
gap = gap / 2;
6 1 3 2 4 5 6 7 }
}
1 3 2 4 5 6 7 …contd.
Original List …contd. from previous
1 2 3 4 5 6 7 void Sort()
{
1 3 2 4 5 6 7 int gap, flag;
gap = n / 2;
while( gap > 0 )
List Gap - 1 {
do {
1 1 3 2 4 5 6 7 flag = 0;
for(i=1; i<=(n-gap); i++)
2 1 3 2 4 5 6 7 if( a[i] > a[i+gap] )
{
3 1 2 3 4 5 6 7 t = a[i];
a[i] = a[i+gap];
a[i+gap] = t;
4 1 2 3 4 5 6 7 flag = 1;
}
5 1 2 3 4 5 6 7 } while(flag);
gap = gap / 2;
6 1 2 3 4 5 6 7 }
}
1 2 3 4 5 6 7 …contd.
Original List …contd. from previous
1 2 3 4 5 6 7 void Sort()
{
1 2 3 4 5 6 7 int gap, flag;
gap = n / 2;
while( gap > 0 )
List Gap - 1 {
do {
1 1 2 3 4 5 6 7 flag = 0;
for(i=1; i<=(n-gap); i++)
2 1 2 3 4 5 6 7 if( a[i] > a[i+gap] )
{
3 1 2 3 4 5 6 7 t = a[i];
a[i] = a[i+gap];
a[i+gap] = t;
4 1 2 3 4 5 6 7 flag = 1;
}
5 1 2 3 4 5 6 7 } while(flag);
gap = gap / 2;
6 1 2 3 4 5 6 7 }
}
1 2 3 4 5 6 7 …contd.
Quick Sort
Original List
5 4 2 6 7 1 3

No. of Lists - 1
5 4 2 6 7 1 3

3 4 2 6 7 1 5

3 4 2 5 7 1 6

3 4 2 1 7 5 6

3 4 2 1 5 7 6

3 4 2 1 5 7 6
Original List
3 4 2 1 5 7 6

No. of Lists - 2
3 4 2 1 5 7 6

1 4 2 3

1 3 2 4

1 2 3 4

1 2 3 4

1 2 3 4
Original List
1 2 3 4 5 7 6

No. of Lists - 3
1 2 3 4 5 7 6

1 2
Original List
1 2 3 4 5 7 6

No. of Lists - 2
1 2 3 4 5 7 6

6 7

6 7

1 2 3 4 5 7 6
The End