Algorithms

710 CHAPTER 5 ■ Strings
J
6
A
A
K
J
Q
6
J
A
9
9
8
9
K
4
5
Q
3
2
10
9
7
4
4
10
A
5
3
8
2
K
4
7
Q
J
6
3
7
8
10
3
10
7
Q
2
2
5
K
5
6
8
K
J
9
5
2
A
3
4
6
7
8
10
Q
6
A
J
9
3
7
4
8
Q
10
2
K
5
A
Q
9
8
4
10
5
K
J
3
7
2
6
J
6
A
K
Q
10
9
4
2
7
3
5
8
A
2
3
4
5
6
7
8
9
10
J
Q
K
A
2
3
4
5
6
7
8
9
10
J
Q
K
A
2
3
4
5
6
7
8
9
10
J
Q
K
A
2
3
4
5
6
7
8
9
10
J
Q
K
Sorting a card deck with
MSD string sort
MSD st r ing sor t To implement a general-purpose string sort, where
strings are not necessarily all the same length, we consider the characters
in left-to-right order. We know that strings that start with a should appear
before strings that start with b, and so forth. The natural way to implement
this idea is a recursive method known as most-significant-digit-first (MSD)
string sort. We use key-indexed counting to sort the strings according to
their first character, then (recursively) sort the subarrays corresponding to
each character (excluding the first character, which we know to be the same
for each string in each subarray). Like quicksort, MSD string sort partitions
the array into subarrays that can be sorted independently to complete
the job, but it partitions the array into one subarray for each possible value
of the first character, instead of the two or three partitions in quicksort.
End-of-string convention. We need to pay particular attention to reaching
the ends of strings in MSD string sort. For a proper sort, we need the subarray
for strings whose characters
have all been examined to
appear as the first subarray, and
we do not want to recursively
sort this subarray. To facilitate
these two parts of the computation
we use a private twoargument
toChar() method to
convert from an indexed string
character to an array index
that returns -1 if the specified
character position is past the
end of the string. Then, we just
add 1 to each returned value, to
get a nonnegative int that we
can use to index count[]. This
convention means that we have
R+1 different possible character
values at each string position:
0 to signify end of string,
1 for the first alphabet character,
2 for the second alphabet
character, and so forth. Since
sort on first character value
to partition into subarrays
0
0
0
.
.
.
0
0
1
1
1
.
.
.
1
1
2
2
2
.
.
.
2
2
r
r
r
.
.
.
r
r
.
.
.
.
.
.
Overview of MSD string sort
recursively sort subarrays
(excluding first character)
0
0
0
.
.
.
0
0
1
1
1
.
.
.
1
1
2
2
2
.
.
.
2
2
r
r
r
.
.
.
r
r
.
.
.
.
.
.