Algorithms and Data Structures: Counting Sort and Radix Sort

Algorithms and Data Structures:
Counting sort and Radix sort

15th October, 2013
ADS: lect 8 slide 1 15th October, 2013
Special Cases of the Sorting Problem
In this lecture we assume that the sort keys are sequences of bits.
Quite a natural special case. Doesnt cover everything:
eg, exact real number arithmetic doesnt take this form.
In certain applications, eg Biology, pairwise experiments may only

return > or < (non-numeric).
Sometimes the bits are naturally grouped, eq, as characters in a

string or hexadecimal digits in a number (4 bits), or in general bytes
(8 bits).
Todays sorting algorithms are allowed access these bits or groups of

bits, instead of just letting them compare keys . . .
This was NOT possible in comparison-based setting.
Easy results . . . Surprising results
Simplest Case:
Keys are integers in the range 1, . . . , m, where m = O(n) (n is (as usual)
the number of elements to be sorted). We can sort in (n) time
(big deal . . . but will help later).
Surprising case: (I think)
For any constant k, the problem of sorting n integers in the range {1, . . . , n
k
}
can be done in (n) time.
Simplest Case:
(big deal
. . . but will help later).
k
}
Simplest Case:
k
}
Simplest Case:
k
}
Counting Sort
Assumption: Keys (attached to items) are Ints in range 1, . . . , m.
Idea
1. Count for every key j , 1 j m how often it occurs in the input
array. Store results in an array C.
2. The counting information stored in C can be used to determine the
position of each element in the sorted array. Suppose we modify the
values of the C[j ] so that now
C[j ] = the number of keys less than or equal to j .
Then we know that the elements with key j must be stored at the
indices C[j 1] + 1, . . . , C[j ] of the nal sorted array.
3. We use a trick to move the elements to the right position of an
auxiliary array. Then we copy the sorted auxiliary array back to the
original one.
Counting Sort
Idea
original one.
Counting Sort
Idea
original one.
Counting Sort
Idea
original one.
Implementation of Counting Sort
Algorithm Counting Sort(A, m)
1. n A.length
2. Initialise array C[1 . . . m]
3. for i 1 to n do
4. j A[i ].key
5. C[j ] C[j ] + 1
6. for j 2 to m do
7. C[j ] C[j ] + C[j 1] C[j ] stores of keys j
8. Initialise array B[1 . . . n]
9. for i n downto 1 do
10. j A[i ].key A[i ] highest w. key j
11. B[C[j ]] A[i ] Insert A[i ] into highest free index for j
12. C[j ] C[j ] 1
13. for i 1 to n do
14. A[i ] B[i ]
Analysis of Counting Sort
The loops in lines 35, 912, and 1314 all require time (n).
The loop in lines 67 requires time (m).
Thus the overall running time is

O(n + m).
This is linear in the number of elements if m = O(n).

Note: This does not contradict Theorem 3 from Lecture 7 - thats a result
about the general case, where keys have an arbitary size (and need not
even be numeric).
Note: Counting-Sort is STABLE.
(After sorting, 2 items with the same key have their initial relative
order).

O(n + m).

even be numeric).
order).

O(n + m).

even be numeric).
order).
Radix Sort
Basic Assumption
Keys are sequences of digits in a xed range 0, . . . , R 1,
all of equal length d.
Examples of such keys
4 digit hexadecimal numbers (corresponding to 16 bit integers)

R = 16, d = 4
5 digit decimal numbers (for example, US post codes)

R = 10, d = 5
Fixed length ASCII character sequences

R = 128
Fixed length byte sequences

R = 256
Stable Sorting Algorithms
Denition 1
A sorting algorithm is stable if it always leaves elements with equal keys
in their original order.
Examples
Counting-Sort, Merge-Sort, and Insertion Sort are all

stable.
Quicksort is not stable.
If keys and elements are exactly the same thing (in our setting, an
element is a structure containing the key as a sub-element) then we
have a much easier (non-stable) version of Counting-Sort.
(How? ... CLASS?).
Stable Sorting Algorithms
Denition 1
A sorting algorithm is stable if it always leaves elements with equal keys
in their original order.
Examples
Counting-Sort, Merge-Sort, and Insertion Sort are all

stable.
Quicksort is not stable.
If keys and elements are exactly the same thing (in our setting, an
element is a structure containing the key as a sub-element) then we
have a much easier (non-stable) version of Counting-Sort.
(How? ... CLASS?).
Radix Sort (contd)
Idea
Sort the keys digit by digit, starting with the least
signicant digit.
Example
now
for
tip
ilk
dim
tag
jot
sob
nob
sky
hut
ace
bet
sob
for
nob
ace
ilk
tag
dim
tip
jot
hut
bet
now
sky
tag
ace
bet
hut
dim
ilk
sky
tip
now
jot
for
sob
nob
ace
bet
dim
for
tip
tag
sob
sky
now
nob
jot
ilk
hut
Each of the three sorts is carried out with respect to the digits in that
column. Stability (and having previously sorted digits/suxes to the
right), means this achieves a sorting of the suxes starting at the current
column.
Radix Sort (contd)
Algorithm Radix-Sort(A, d)
1. for i 0 to d do
2. use stable sort to sort array A using digit i as key
Most commonly, Counting Sort is used in line 2 - this means that once
a set of digits is already in sorted order, then (by stability) performing
Counting Sort on the next-most signicant digits preserves that order,
within the blocks constructed by the new iteration.
Then each execution of line 2 requires time (n + R).
Thus the overall time required by Radix-Sort is
(d(n + R))
Sorting Integers with Radix-Sort
Theorem 2
An array of length n whose keys are b-bit numbers can be sorted in time
(nb/ lg n)
using a suitable version of Radix-Sort.
Proof: Let the digits be blocks of lg n bits. Then R = 2
lg n
= (n)
and d = b/lg n. Using the implementation of Radix-Sort based on
Counting Sort the integers can be sorted in time
(d(n + R)) = (nb/ lg n).
Note: If all numbers are at most n
k
, then b = k lg n . . . Radix Sort
is (n) (assuming k is some constant, eg 3, 10).
Reading Assignment
[CLRS] Sections 8.2, 8.3
Problems
1. Think about the qn. on slide 7 - how do we get a very easy
(non-stable) version of Counting-Sort if there are no items
attached to the keys?
2. Can you come up with another way of achieving counting sorts
O(m + n)-time bound and stability (you will need a dierent data
structure from an array).
3. Exercise 8.3-4 of [CLRS].

Algorithms and Data Structures: Counting Sort and Radix Sort

Uploaded by

Copyright:

Available Formats

Algorithms and Data Structures: Counting Sort and Radix Sort

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Algorithms and Data Structures: Counting Sort and Radix Sort

Uploaded by

Copyright:

Available Formats

Algorithms and Data Structures:

Counting sort and Radix sort

Quite a natural special case. Doesnt cover everything:

eg, exact real number arithmetic doesnt take this form.

In certain applications, eg Biology, pairwise experiments may only

Sometimes the bits are naturally grouped, eq, as characters in a

Todays sorting algorithms are allowed access these bits or groups of

The loop in lines 67 requires time (m).

Thus the overall running time is

This is linear in the number of elements if m = O(n).

The loop in lines 67 requires time (m).

Thus the overall running time is

This is linear in the number of elements if m = O(n).

The loop in lines 67 requires time (m).

Thus the overall running time is

This is linear in the number of elements if m = O(n).

4 digit hexadecimal numbers (corresponding to 16 bit integers)

5 digit decimal numbers (for example, US post codes)

Fixed length ASCII character sequences

Fixed length byte sequences

Counting-Sort, Merge-Sort, and Insertion Sort are all

Quicksort is not stable.

Counting-Sort, Merge-Sort, and Insertion Sort are all

Quicksort is not stable.

You might also like