Counting Sort and Radix Sort Algorithms

Counting sort
 Counting sort assumes that each of the n input elements is an
integer in the range 0 to k. that is n is the number of elements and
k is the highest value element.
 Consider the input set : 4, 1, 3, 4, 3. Then n=5 and k=4
 Counting sort determines for each input element x, the number of
elements less than x. And it uses this information to place
element x directly into its position in the output array. For
example if there exits 17 elements less that x then x is placed into
the 18th
position into the output array.
 The algorithm uses three array:
Input Array: A[1..n] store input data where A[j] ∈ {1, 2, 3, …, k}
Output Array: B[1..n] finally store the sorted data
Temporary Array: C[1..k] store data temporarily

Counting Sort
1. Counting-Sort(A, B, k)
2. Let C[0…..k] be a new array
3. for i=0 to k
4. C[i]= 0;
5. for j=1 to A.length or n
6. C[ A[j] ] = C[ A[j] ] + 1;
7. for i=1 to k
8. C[i] = C[i] + C[i-1];
9. for j=n or A.length down to 1
10. B[ C[ A[j] ] ] = A[j];
11. C[ A[j] ] = C[ A[j] ] - 1;

Counting Sort
3. for i=0 to k [Loop 1]
4. C[i]= 0;
5. for j=1 to A.length( or n) [Loop 2]
6. C[ A[j] ] = C[ A[j] ] + 1;
8. C[i] = C[i] + C[i-1];
9. for j=n or A.length down to 1 [Loop 4]
10. B[ C[ A[j] ] ] = A[j];
11. C[ A[j] ] = C[ A[j] ] - 1;

Counting-sort example
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 33 00 22 33 00 33
0 5
1 2 3 4 5 6 7 8

Executing Loop 1
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 33 00 22 33 00 33
00 00 00 00 00
0
00
5
1 2 3 4 5 6 7 8

Executing Loop 2
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 33 00 22 33 00 33
00 00 1 00 00
0
00
5
1 2 3 4 5 6 7 8

Executing Loop 2
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
5 33 00 22 33 00 33
00 00 11 00 00
0
1
5
1 2 3 4 5 6 7 8

Executing Loop 2
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 3 00 22 33 00 33
00 00 11 1 00
0
11
5
1 2 3 4 5 6 7 8

Executing Loop 2
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 33 0 22 33 00 33
1 00 11 11 00
0
11
5
1 2 3 4 5 6 7 8

Executing Loop 2
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 33 00 2 33 00 33
11 00 2 11 00
0
11
5
1 2 3 4 5 6 7 8

Executing Loop 2
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 33 00 22 3 00 33
11 00 22 2 00
0
11
5
1 2 3 4 5 6 7 8

Executing Loop 2
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 33 00 22 33 0 33
2 00 22 22 00
0
11
5
1 2 3 4 5 6 7 8

Executing Loop 2
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 33 00 22 33 00 3
22 00 22 3 00
0
11
5
1 2 3 4 5 6 7 8

End of Loop 2
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 33 00 22 33 00
22 00 22 00
0
11
5
1 2 3 4 5 6 7 8
33
33

Executing Loop 3
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 33 00 22 33 00
2 0 22 00
0
11
5
1 2 3 4 5 6 7 8
33
33
C: 22 00 1133
1 2 3 40 5
222

Executing Loop 3
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 33 00 22 33 00
2222 00
0
11
5
1 2 3 4 5 6 7 8
33
33
C: 22 4 00 1133
1 2 3 40 5
22

Executing Loop 3
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 33 00 22 33 00
422 00
0
11
5
1 2 3 4 5 6 7 8
3
33
C: 22 44 00 117
1 2 3 40 5
22
22

Executing Loop 3
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 33 00 22 33 00
22 0
0
11
5
1 2 3 4 5 6 7 8
7
33
C: 22 44 7 11
1 2 3 40 5
22
22
44
77

Executing Loop 3
A:
B:
1 2 3 4 5
C:
1 2 3 4
6 7 8
55 33 00 22 33 00
22
0
1
5
1 2 3 4 5 6 7 8
33
C: 22 44 8
1 2 3 40 5
22
22
44
77
77 7
77

End of Loop 3
A:
B:
1 2 3 4 5 6 7 8
55 33 00 22 33 00
1 2 3 4 5 6 7 8
33
C: 22 44
1 2 3 40 5
22 77 77 88

Executing Loop 4
A:
B:
1 2 3 4 5 6 7 8
55 33 00 22 33 00
1 2 3 4 5 6 7 8
3
C: 22 44
1 2 3 40 5
22 7 77 88

Executing Loop 4
A:
B:
1 2 3 4 5 6 7 8
55 33 00 22 33 00
1 2 3 4 5 6 7 8
C: 22 44
1 2 3 40 5
22 7 77 88
3
J=8, then A[ j ]=A[8]=3
And B[ C[ A[j] ] ]
=B[ C[ 3 ] ]
=B[ 7]
So B[ C[ A[j] ] ] ←A[ j ]
=B[7]←3

A:
B:
1 2 3 4 5 6 7 8
55 33 00 22 33
1 2 3 4 5 6 7 8
C: 2 44
1 2 3 40 5
22 77 88
330
66
33
Executing Loop 4
J=8, then A[ j ]=A[8]=3
Then C[ A[j] ]
= C[ 3 ]
=7
So C[ A[j] ] = C[ A[j] ] -1
=7-1=6

Executing Loop 4
A:
B:
1 2 3 4 5 6 7 8
55 33 00 22
1 2 3 4 5 6 7 8
C: 44
1 2 3 40 5
22 77 88
33
6
33
00
11
00
3

Executing Loop 4
A:
B:
1 2 3 4 5 6 7 8
55 33 00
1 2 3 4 5 6 7 8
C: 4
1 2 3 40 5
22 77 88
33
55
33
00
00
2
11
33
33

Executing Loop 4
A:
B:
1 2 3 4 5 6 7 8
55 33
1 2 3 4 5 6 7 8
C: 33
1 2 3 40 5
22 77 88
33
33
00
00
0
1
33
33
55
22

Executing Loop 4
A:
B:
1 2 3 4 5 6 7 8
55
1 2 3 4 5 6 7 8
C:
1 2 3 40 5
22 77 88
33
33
00
00
0
00
33
33
533
00 22
3

Executing Loop 4
A:
B:
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8
C:
1 2 3 40 5
22 77 8
33
33
00
00
0 33
33
33
00 22
335
44
33
00

Executing Loop 4
A:
B:
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8
C:
1 2 3 40 5
22 77 77
33
33
00
00
0 33
33
3
00 22
332
33
00
55
44
55

End of Loop 4
A:
B:
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8
C:
1 2 3 40 5
22 77
33
33
00
00
0 33
3300 22
33
33
00
55
44
55
22 77
22
Sorted data in Array B

Time Complexity Analysis
4. C[i]= 0;
5. for j=1 to A.length or n [Loop 2]
6. C[ A[j] ] = C[ A[j] ] + 1;
8. C[i] = C[i] + C[i-1];
9. for j=n or A.length down to 1 [Loop 4]
10. B[ C[ A[j] ] ] = A[j];
11. C[ A[j] ] = C[ A[j] ] - 1;
Loop 2 and 4
takes O(n) time
Loop 1 and 3
takes O(k) time

• So the counting sort takes a total time of: O(n + k)
• Counting sort is called stable sort.
– A sorting algorithm is stable when numbers with
the same values appear in the output array in the
same order as they do in the input array.

Counting Sort Review
• Assumption: input taken from small set of numbers of size k
• Basic idea:
– Count number of elements less than you for each element.
– This gives the position of that number – similar to selection
sort.
• Pro’s:
– Fast
– Asymptotically fast - O(n+k)
– Simple to code
• Con’s:
– Doesn’t sort in place.
– Requires O(n+k) extra storage.

Radix Sort
• Radix sort is non comparative sorting
method
• Two classifications of radix sorts are least
significant digit (LSD) radix sorts and most
significant digit (MSD) radix sorts.
• LSD radix sorts process the integer
representations starting from the least digit
and move towards the most significant digit.
MSD radix sorts work the other way around.
35

Radix Sort
;digitonarraysortsort tostableause"do
to1for
),(Sort-Radix
digit.ofnumberaiselementeach,arrayinputIn
iA
di
dA
dA
←
355
720
436
839
657
457
329
839
329
657
457
436
355
720
657
457
355
839
436
329
720
839
720
657
457
436
355
329

The Algorithm
void radixsort(int a[1000],int n,int digits)
{
for(int i =1;i<=digits;i++)
countsort(a,n,i);
}

The Algorithm
void countsort(int a[1000],int n,int x)
{
int d[1000],t;
for(int s=1;s<=n;s++) // extracting the concerned digit from
{ t = a[s]; the number
t = t / (pow(10,x-1));
d[s] = t%10;
}
int c[10],b[1000],i,j;
for(i=0;i<=9;i++)
c[i] = 0;

The Algorithm
for(j = 1;j<=n;++j)
c[d[j]] = c[d[j]] + 1; //c[i] contains no of elements
for(i =0;i<9;i++) equal to i
c[i+1] = c[i+1] + c[i];
for(j=n;j>0;j--)
{ b[c[d[j]]] = a[j]; //shift the array’s numbers
c[d[j]] = c[d[j]] -1;
}
for(i=1;i<=n;i++)
a[i] = b[i];
}

Given n d-digit number in which each digit can
take up to k possible values, RADIX-SORT
correctly sorts these numbers in Ө(d(n+k))
time if the stable sort it uses takes Ө(n+k)
time.

Given n b-bit numbers and any positive integer
r<=b, RADIX-SORT correctly sorts theses
numbers in Ө((b/r)(n + 2r
)) time if the stable
sort it uses takes Ө(n+k) time for inputs in the
range 0 to k.
For example – A 32 bit word can be viewed as
four 8 bit digits, so b = 32, r = 8, k = 2r
– 1 =
255, d = 4. Each pass of counting sort takes
time Ө(n+k) = Ө(n+2r
) and there are d passes,
so total running time Ө(d(n+2r
)) = Ө(b/r(n+2r
))

Radix Sort Review
• Assumption: input taken from large set of numbers
• Basic idea:
– Sort the input on the basis of digits starting from unit’s
place.
– This gives the position of that number – similar to selection
sort.
• Pro’s:
– Fast
– Asymptotically fast - O(d(n+k))
– Simple to code
• Con’s:
– Doesn’t sort in place.

Counting Sort and Radix Sort Algorithms

Counting Sort and Radix Sort Algorithms

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Counting Sort and Radix Sort Algorithms (20)

Recently uploaded (20)

Counting Sort and Radix Sort Algorithms