Boost.Sort

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

string_sort.hpp
Go to the documentation of this file.
1 //Templated hybrid string_sort
2
3 // Copyright Steven J. Ross 2001 - 2009.
4 // Distributed under the Boost Software License, Version 1.0.
5 // (See accompanying file LICENSE_1_0.txt or copy at
6 // http://www.boost.org/LICENSE_1_0.txt)
7
8 // See http://www.boost.org/libs/sort/ for library home page.
9
10 /*
11 Some improvements suggested by:
12 Phil Endecott and Frank Gennari
13 */
14
15 #ifndef BOOST_STRING_SORT_HPP
16 #define BOOST_STRING_SORT_HPP
17 #include <algorithm>
18 #include <vector>
19 #include <cstring>
20 #include <limits>
21 #include <boost/static_assert.hpp>
22 #include <boost/sort/spreadsort/detail/constants.hpp>
23 #include <boost/sort/spreadsort/detail/string_sort.hpp>
24
25 namespace boost {
26 namespace sort {
27
28 /*! \brief String sort algorithm using random access iterators, allowing character-type overloads.\n
29 (All variants fall back to @c std::sort if the data size is too small, < @c detail::min_sort_size).
30
31 \details @c string_sort is a fast templated in-place hybrid radix/comparison algorithm,
32 which in testing tends to be roughly 50% to 2X faster than @c std::sort for large tests (>=100kB).\n
33 \par
34 Worst-case performance is <em> O(N * (lg(range)/s + s)) </em>,
35 so @c integer_sort is asymptotically faster
36 than pure comparison-based algorithms. @c s is @c max_splits, which defaults to 11,
37 so its worst-case with default settings for 32-bit integers is
38 <em> O(N * ((32/11) </em> slow radix-based iterations fast comparison-based iterations).\n\n
39 Some performance plots of runtime vs. n and log(range) are provided:\n
40 <a href="../../doc/graph/windows_string_sort.htm"> windows_string_sort</a>\n
41 <a href="../../doc/graph/osx_string_sort.htm"> osx_string_sort</a>
42
43 \tparam RandomAccessIter <a href="http://www.cplusplus.com/reference/iterator/RandomAccessIterator/">Random access iterator</a>
44 \tparam Unsigned_char_type Unsigned character type used for string.
45 \param[in] first Iterator pointer to first element.
46 \param[in] last Iterator pointing to one beyond the end of data.
47 \param[in] unused Unused ???
48
49 \pre [@c first, @c last) is a valid range.
50 \pre @c RandomAccessIter @c value_type is mutable.
51 \pre @c RandomAccessIter @c value_type is <a href="http://en.cppreference.com/w/cpp/concept/LessThanComparable">LessThanComparable</a>
52 \pre @c RandomAccessIter @c value_type supports the @c operator>>,
53 which returns an integer-type right-shifted a specified number of bits.
54 \post The elements in the range [@c first, @c last) are sorted in ascending order.
55
56 \throws std::exception Propagates exceptions if any of the element comparisons, the element swaps (or moves),
57 the right shift, subtraction of right-shifted elements, functors,
58 or any operations on iterators throw.
59
60 \warning Throwing an exception may cause data loss. This will also throw if a small vector resize throws, in which case there will be no data loss.
61 \warning Invalid arguments cause undefined behaviour.
62 \note @c spreadsort function provides a wrapper that calls the fastest sorting algorithm available for a data type,
63 enabling faster generic-programming.
64
65 \remark The lesser of <em> O(N*log(N)) </em> comparisons and <em> O(N*log(K/S + S)) </em>operations worst-case, where:
66 \remark * N is @c last - @c first,
67 \remark * K is the log of the range in bits (32 for 32-bit integers using their full range),
68 \remark * S is a constant called max_splits, defaulting to 11 (except for strings where it is the log of the character size).
69
70 */
71
72 template <class RandomAccessIter, class Unsigned_char_type>
73 inline void string_sort(RandomAccessIter first, RandomAccessIter last,
74 Unsigned_char_type unused)
75 {
76 //Don't sort if it's too small to optimize
77 if (last - first < detail::min_sort_size)
78 std::sort(first, last);
79 else
80 detail::string_sort(first, last, unused);
81 }
82
83
84 /*! \brief String sort algorithm using random access iterators, wraps using default of unsigned char.
85 (All variants fall back to @c std::sort if the data size is too small, < @c detail::min_sort_size).
86
87 \details @c string_sort is a fast templated in-place hybrid radix/comparison algorithm,
88 which in testing tends to be roughly 50% to 2X faster than @c std::sort for large tests (>=100kB).\n
89 Worst-case performance is <em> O(N * (lg(range)/s + s)) </em>,
90 so @c integer_sort is asymptotically faster
91 than pure comparison-based algorithms. @c s is @c max_splits, which defaults to 11,
92 so its worst-case with default settings for 32-bit integers is
93 <em> O(N * ((32/11) </em> slow radix-based iterations fast comparison-based iterations).\n\n
94 Some performance plots of runtime vs. n and log(range) are provided:\n
95 <a href="../../doc/graph/windows_string_sort.htm"> windows_string_sort</a>
96 \n
97 <a href="../../doc/graph/osx_string_sort.htm"> osx_string_sort</a>
98
99 \tparam RandomAccessIter <a href="http://www.cplusplus.com/reference/iterator/RandomAccessIterator/">Random access iterator</a>
100 \param[in] first Iterator pointer to first element.
101 \param[in] last Iterator pointing to one beyond the end of data.
102
103 \pre [@c first, @c last) is a valid range.
104 \pre @c RandomAccessIter @c value_type is mutable.
105 \pre @c RandomAccessIter @c value_type is <a href="http://en.cppreference.com/w/cpp/concept/LessThanComparable">LessThanComparable</a>
106 \pre @c RandomAccessIter @c value_type supports the @c operator>>,
107 which returns an integer-type right-shifted a specified number of bits.
108 \post The elements in the range [@c first, @c last) are sorted in ascending order.
109
110 \throws std::exception Propagates exceptions if any of the element comparisons, the element swaps (or moves),
111 the right shift, subtraction of right-shifted elements, functors,
112 or any operations on iterators throw.
113
114 \warning Throwing an exception may cause data loss. This will also throw if a small vector resize throws, in which case there will be no data loss.
115 \warning Invalid arguments cause undefined behaviour.
116 \note @c spreadsort function provides a wrapper that calls the fastest sorting algorithm available for a data type,
117 enabling faster generic-programming.
118
119 \remark The lesser of <em> O(N*log(N)) </em> comparisons and <em> O(N*log(K/S + S)) </em>operations worst-case, where:
120 \remark * N is @c last - @c first,
121 \remark * K is the log of the range in bits (32 for 32-bit integers using their full range),
122 \remark * S is a constant called max_splits, defaulting to 11 (except for strings where it is the log of the character size).
123
124 */
125 template <class RandomAccessIter>
126 inline void string_sort(RandomAccessIter first, RandomAccessIter last)
127 {
128 unsigned char unused = '\0';
129 string_sort(first, last, unused);
130 }
131
132
133 /*! \brief String sort algorithm using random access iterators, allowing character-type overloads.
134
135 (All variants fall back to @c std::sort if the data size is too small, < detail::min_sort_size).
136
137 \details @c integer_sort is a fast templated in-place hybrid radix/comparison algorithm,
138 which in testing tends to be roughly 50% to 2X faster than @c std::sort for large tests (>=100kB).\n
139 Worst-case performance is <em> O(N * (lg(range)/s + s)) </em>,
140 so @c integer_sort is asymptotically faster
141 than pure comparison-based algorithms. @c s is @c max_splits, which defaults to 11,
142 so its worst-case with default settings for 32-bit integers is
143 <em> O(N * ((32/11) </em> slow radix-based iterations fast comparison-based iterations).\n\n
144 Some performance plots of runtime vs. n and log(range) are provided:\n
145 <a href="../../doc/graph/windows_integer_sort.htm"> windows_integer_sort</a>
146 \n
147 <a href="../../doc/graph/osx_integer_sort.htm"> osx_integer_sort</a>
148
149
150 \tparam RandomAccessIter <a href="http://www.cplusplus.com/reference/iterator/RandomAccessIterator/">Random access iterator</a>
151 \tparam Comp To provide @c operator< for user-defined comparison.
152 \tparam Unsigned_char_type Unsigned character type used for string.
153
154 \param[in] first Iterator pointer to first element.
155 \param[in] last Iterator pointing to one beyond the end of data.
156 \param[in] comp comparison functor.
157 \param[in] unused Unused ???
158
159 \pre [@c first, @c last) is a valid range.
160 \pre @c RandomAccessIter @c value_type is mutable.
161 \pre @c RandomAccessIter @c value_type is <a href="http://en.cppreference.com/w/cpp/concept/LessThanComparable">LessThanComparable</a>
162 \pre @c RandomAccessIter @c value_type supports the @c operator>>,
163 which returns an integer-type right-shifted a specified number of bits.
164 \post The elements in the range [@c first, @c last) are sorted in ascending order.
165
166 \return @c void.
167
168 \throws std::exception Propagates exceptions if any of the element comparisons, the element swaps (or moves),
169 the right shift, subtraction of right-shifted elements, functors,
170 or any operations on iterators throw.
171
172 \warning Throwing an exception may cause data loss. This will also throw if a small vector resize throws, in which case there will be no data loss.
173 \warning Invalid arguments cause undefined behaviour.
174 \note @c spreadsort function provides a wrapper that calls the fastest sorting algorithm available for a data type,
175 enabling faster generic-programming.
176
177 \remark The lesser of <em> O(N*log(N)) </em> comparisons and <em> O(N*log(K/S + S)) </em>operations worst-case, where:
178 \remark * N is @c last - @c first,
179 \remark * K is the log of the range in bits (32 for 32-bit integers using their full range),
180 \remark * S is a constant called max_splits, defaulting to 11 (except for strings where it is the log of the character size).
181 */
182 template <class RandomAccessIter, class Compare, class Unsigned_char_type>
183 inline void reverse_string_sort(RandomAccessIter first,
184 RandomAccessIter last, Compare comp, Unsigned_char_type unused)
185 {
186 //Don't sort if it's too small to optimize.
187 if (last - first < detail::min_sort_size)
188 std::sort(first, last, comp);
189 else
190 detail::reverse_string_sort(first, last, unused);
191 }
192
193
194 /*! \brief String sort algorithm using random access iterators, wraps using default of @c unsigned char.
195
196 (All variants fall back to @c std::sort if the data size is too small, < @c detail::min_sort_size).
197
198 \details @c integer_sort is a fast templated in-place hybrid radix/comparison algorithm,
199 which in testing tends to be roughly 50% to 2X faster than @c std::sort for large tests (>=100kB).\n
200 Worst-case performance is <em> O(N * (lg(range)/s + s)) </em>,
201 so @c integer_sort is asymptotically faster
202 than pure comparison-based algorithms. @c s is @c max_splits, which defaults to 11,
203 so its worst-case with default settings for 32-bit integers is
204 <em> O(N * ((32/11) </em> slow radix-based iterations fast comparison-based iterations).\n\n
205 Some performance plots of runtime vs. n and log(range) are provided:\n
206 <a href="../../doc/graph/windows_integer_sort.htm"> windows_integer_sort</a>
207 \n
208 <a href="../../doc/graph/osx_integer_sort.htm"> osx_integer_sort</a>
209
210
211 \tparam RandomAccessIter <a href="http://www.cplusplus.com/reference/iterator/RandomAccessIterator/">Random access iterator</a>
212 \tparam Comp To provide @c operator< for user-defined comparison.
213
214 \param[in] first Iterator pointer to first element.
215 \param[in] last Iterator pointing to one beyond the end of data.
216 \param[in] comp Comparison functor.
217
218 \pre [@c first, @c last) is a valid range.
219 \pre @c RandomAccessIter @c value_type is mutable.
220 \pre @c RandomAccessIter @c value_type is <a href="http://en.cppreference.com/w/cpp/concept/LessThanComparable">LessThanComparable</a>
221 \pre @c RandomAccessIter @c value_type supports the @c operator>>,
222 which returns an integer-type right-shifted a specified number of bits.
223 \post The elements in the range [@c first, @c last) are sorted in ascending order.
224
225 \return @c void.
226
227 \throws std::exception Propagates exceptions if any of the element comparisons, the element swaps (or moves),
228 the right shift, subtraction of right-shifted elements, functors,
229 or any operations on iterators throw.
230
231 \warning Throwing an exception may cause data loss. This will also throw if a small vector resize throws, in which case there will be no data loss.
232 \warning Invalid arguments cause undefined behaviour.
233 \note @c spreadsort function provides a wrapper that calls the fastest sorting algorithm available for a data type,
234 enabling faster generic-programming.
235
236 \remark The lesser of <em> O(N*log(N)) </em> comparisons and <em> O(N*log(K/S + S)) </em>operations worst-case, where:
237 \remark * N is @c last - @c first,
238 \remark * K is the log of the range in bits (32 for 32-bit integers using their full range),
239 \remark * S is a constant called max_splits, defaulting to 11 (except for strings where it is the log of the character size).
240 */
241 template <class RandomAccessIter, class Compare>
242 inline void reverse_string_sort(RandomAccessIter first,
243 RandomAccessIter last, Compare comp)
244 {
245 unsigned char unused = '\0';
246 reverse_string_sort(first, last, comp, unused);
247 }
248
249
250 /*! \brief String sort algorithm using random access iterators, wraps using default of @c unsigned char.
251
252 (All variants fall back to @c std::sort if the data size is too small, < @c detail::min_sort_size).
253
254 \details @c integer_sort is a fast templated in-place hybrid radix/comparison algorithm,
255 which in testing tends to be roughly 50% to 2X faster than @c std::sort for large tests (>=100kB).\n
256 Worst-case performance is <em> O(N * (lg(range)/s + s)) </em>,
257 so @c integer_sort is asymptotically faster
258 than pure comparison-based algorithms. @c s is @c max_splits, which defaults to 11,
259 so its worst-case with default settings for 32-bit integers is
260 <em> O(N * ((32/11) </em> slow radix-based iterations fast comparison-based iterations).\n\n
261 Some performance plots of runtime vs. n and log(range) are provided:\n
262 <a href="../../doc/graph/windows_integer_sort.htm"> windows_integer_sort</a>
263 \n
264 <a href="../../doc/graph/osx_integer_sort.htm"> osx_integer_sort</a>
265
266
267 \tparam RandomAccessIter <a href="http://www.cplusplus.com/reference/iterator/RandomAccessIterator/">Random access iterator</a>
268 \tparam Get_char Bracket functor equivalent to @c operator[], taking a number corresponding to the character offset..
269 \tparam Get_length Functor to get the length of the string in characters. TODO Check this and below and other places!!!
270
271 \param[in] first Iterator pointer to first element.
272 \param[in] last Iterator pointing to one beyond the end of data.
273 \param[in] get_character Number corresponding to the character offset from bracket functor equivalent to @c operator[].
274 \param[in] length Functor to get the length of the string in characters.
275
276 \pre [@c first, @c last) is a valid range.
277 \pre @c RandomAccessIter @c value_type is mutable.
278 \pre @c RandomAccessIter @c value_type is <a href="http://en.cppreference.com/w/cpp/concept/LessThanComparable">LessThanComparable</a>
279 \pre @c RandomAccessIter @c value_type supports the @c operator>>,
280 which returns an integer-type right-shifted a specified number of bits.
281 \post The elements in the range [@c first, @c last) are sorted in ascending order.
282
283 \return @c void.
284
285 \throws std::exception Propagates exceptions if any of the element comparisons, the element swaps (or moves),
286 the right shift, subtraction of right-shifted elements, functors,
287 or any operations on iterators throw.
288
289 \warning Throwing an exception may cause data loss. This will also throw if a small vector resize throws, in which case there will be no data loss.
290 \warning Invalid arguments cause undefined behaviour.
291 \note @c spreadsort function provides a wrapper that calls the fastest sorting algorithm available for a data type,
292 enabling faster generic-programming.
293
294 \remark The lesser of <em> O(N*log(N)) </em> comparisons and <em> O(N*log(K/S + S)) </em>operations worst-case, where:
295 \remark * N is @c last - @c first,
296 \remark * K is the log of the range in bits (32 for 32-bit integers using their full range),
297 \remark * S is a constant called max_splits, defaulting to 11 (except for strings where it is the log of the character size).
298
299 */
300 template <class RandomAccessIter, class Get_char, class Get_length>
301 inline void string_sort(RandomAccessIter first, RandomAccessIter last,
302 Get_char get_character, Get_length length)
303 {
304 //Don't sort if it's too small to optimize
305 if (last - first < detail::min_sort_size)
306 std::sort(first, last);
307 else {
308 //skipping past empties, which allows us to get the character type
309 //.empty() is not used so as not to require a user declaration of it
310 while (!length(*first)) {
311 if (++first == last)
312 return;
313 }
314 detail::string_sort(first, last, get_character, length, get_character((*first), 0));
315 }
316 }
317
318
319
320 /*! \brief String sort algorithm using random access iterators, wraps using default of @c unsigned char.
321
322 (All variants fall back to @c std::sort if the data size is too small, < @c detail::min_sort_size).
323
324 \details @c integer_sort is a fast templated in-place hybrid radix/comparison algorithm,
325 which in testing tends to be roughly 50% to 2X faster than @c std::sort for large tests (>=100kB).\n
326 Worst-case performance is <em> O(N * (lg(range)/s + s)) </em>,
327 so @c integer_sort is asymptotically faster
328 than pure comparison-based algorithms. @c s is @c max_splits, which defaults to 11,
329 so its worst-case with default settings for 32-bit integers is
330 <em> O(N * ((32/11) </em> slow radix-based iterations fast comparison-based iterations).\n\n
331 Some performance plots of runtime vs. n and log(range) are provided:\n
332 <a href="../../doc/graph/windows_integer_sort.htm"> windows_integer_sort</a>
333 \n
334 <a href="../../doc/graph/osx_integer_sort.htm"> osx_integer_sort</a>
335
336
337 \tparam RandomAccessIter <a href="http://www.cplusplus.com/reference/iterator/RandomAccessIterator/">Random access iterator</a>
338 \tparam Get_char ???.
339 \tparam Get_length ??? TODO
340 \tparam Comp To provide @c operator< for user-defined comparison.
341
342
343 \param[in] first Iterator pointer to first element.
344 \param[in] last Iterator pointing to one beyond the end of data.
345 \param[in] comp comparison functor.
346 \param[in] get_character ???
347 \param[in] length ???
348
349
350 \pre [@c first, @c last) is a valid range.
351 \pre @c RandomAccessIter @c value_type is mutable.
352 \pre @c RandomAccessIter @c value_type is <a href="http://en.cppreference.com/w/cpp/concept/LessThanComparable">LessThanComparable</a>
353 \post The elements in the range [@c first, @c last) are sorted in ascending order.
354
355 \return @c void.
356
357 \throws std::exception Propagates exceptions if any of the element comparisons, the element swaps (or moves),
358 the right shift, subtraction of right-shifted elements, functors,
359 or any operations on iterators throw.
360
361 \warning Throwing an exception may cause data loss. This will also throw if a small vector resize throws, in which case there will be no data loss.
362 \warning Invalid arguments cause undefined behaviour.
363 \note @c spreadsort function provides a wrapper that calls the fastest sorting algorithm available for a data type,
364 enabling faster generic-programming.
365
366 \remark The lesser of <em> O(N*log(N)) </em> comparisons and <em> O(N*log(K/S + S)) </em>operations worst-case, where:
367 \remark * N is @c last - @c first,
368 \remark * K is the log of the range in bits (32 for 32-bit integers using their full range),
369 \remark * S is a constant called max_splits, defaulting to 11 (except for strings where it is the log of the character size).
370
371 */
372 template <class RandomAccessIter, class Get_char, class Get_length,
373 class Compare>
374 inline void string_sort(RandomAccessIter first, RandomAccessIter last,
375 Get_char get_character, Get_length length, Compare comp)
376 {
377 //Don't sort if it's too small to optimize
378 if (last - first < detail::min_sort_size)
379 std::sort(first, last, comp);
380 else {
381 //skipping past empties, which allows us to get the character type
382 //.empty() is not used so as not to require a user declaration of it
383 while (!length(*first)) {
384 if (++first == last)
385 return;
386 }
387 detail::string_sort(first, last, get_character, length, comp,
388 get_character((*first), 0));
389 }
390 }
391
392
393 /*! \brief Reverse String sort algorithm using random access iterators.
394
395 (All variants fall back to @c std::sort if the data size is too small, < @c detail::min_sort_size).
396
397 \details @c integer_sort is a fast templated in-place hybrid radix/comparison algorithm,
398 which in testing tends to be roughly 50% to 2X faster than @c std::sort for large tests (>=100kB).\n
399 Worst-case performance is <em> O(N * (lg(range)/s + s)) </em>,
400 so @c integer_sort is asymptotically faster
401 than pure comparison-based algorithms. @c s is @c max_splits, which defaults to 11,
402 so its worst-case with default settings for 32-bit integers is
403 <em> O(N * ((32/11) </em> slow radix-based iterations fast comparison-based iterations).\n\n
404 Some performance plots of runtime vs. n and log(range) are provided:\n
405 <a href="../../doc/graph/windows_integer_sort.htm"> windows_integer_sort</a>
406 \n
407 <a href="../../doc/graph/osx_integer_sort.htm"> osx_integer_sort</a>
408
409
410 \tparam RandomAccessIter <a href="http://www.cplusplus.com/reference/iterator/RandomAccessIterator/">Random access iterator</a>
411 \tparam Get_char ???.
412 \tparam Get_length ??? TODO
413 \tparam Comp To provide @c operator< for user-defined comparison.
414
415
416 \param[in] first Iterator pointer to first element.
417 \param[in] last Iterator pointing to one beyond the end of data.
418 \param[in] comp comparison functor.
419 \param[in] get_character ???
420 \param[in] length ???
421
422
423 \pre [@c first, @c last) is a valid range.
424 \pre @c RandomAccessIter @c value_type is mutable.
425 \pre @c RandomAccessIter @c value_type is <a href="http://en.cppreference.com/w/cpp/concept/LessThanComparable">LessThanComparable</a>
426 \post The elements in the range [@c first, @c last) are sorted in ascending order.
427
428 \return @c void.
429
430 \throws std::exception Propagates exceptions if any of the element comparisons, the element swaps (or moves),
431 the right shift, subtraction of right-shifted elements, functors,
432 or any operations on iterators throw.
433
434 \warning Throwing an exception may cause data loss. This will also throw if a small vector resize throws, in which case there will be no data loss.
435 \warning Invalid arguments cause undefined behaviour.
436 \note @c spreadsort function provides a wrapper that calls the fastest sorting algorithm available for a data type,
437 enabling faster generic-programming.
438
439 \remark The lesser of <em> O(N*log(N)) </em> comparisons and <em> O(N*log(K/S + S)) </em>operations worst-case, where:
440 \remark * N is @c last - @c first,
441 \remark * K is the log of the range in bits (32 for 32-bit integers using their full range),
442 \remark * S is a constant called max_splits, defaulting to 11 (except for strings where it is the log of the character size).
443
444 */
445 template <class RandomAccessIter, class Get_char, class Get_length,
446 class Compare>
447 inline void reverse_string_sort(RandomAccessIter first,
448 RandomAccessIter last, Get_char get_character, Get_length length, Compare comp)
449 {
450 //Don't sort if it's too small to optimize
451 if (last - first < detail::min_sort_size)
452 std::sort(first, last, comp);
453 else {
454 //skipping past empties, which allows us to get the character type
455 //.empty() is not used so as not to require a user declaration of it
456 while (!length(*(--last))) {
457 //If there is just one non-empty at the beginning, this is sorted
458 if (first == last)
459 return;
460 }
461 //making last just after the end of the non-empty part of the array
462 detail::reverse_string_sort(first, last + 1, get_character, length, comp,
463 get_character((*last), 0));
464 }
465 }
466 }
467 }
468
469 #endif
boost
Definition: float_sort.hpp:27
boost::sort::string_sort
void string_sort(RandomAccessIter first, RandomAccessIter last, Get_char get_character, Get_length length, Compare comp)
String sort algorithm using random access iterators, wraps using default of unsigned char...
Definition: string_sort.hpp:374
boost::sort::string_sort
void string_sort(RandomAccessIter first, RandomAccessIter last, Unsigned_char_type unused)
String sort algorithm using random access iterators, allowing character-type overloads. (All variants fall back to std::sort if the data size is too small, < detail::min_sort_size).
Definition: string_sort.hpp:73
boost::sort::reverse_string_sort
void reverse_string_sort(RandomAccessIter first, RandomAccessIter last, Compare comp, Unsigned_char_type unused)
String sort algorithm using random access iterators, allowing character-type overloads.
Definition: string_sort.hpp:183
boost::sort::reverse_string_sort
void reverse_string_sort(RandomAccessIter first, RandomAccessIter last, Get_char get_character, Get_length length, Compare comp)
Reverse String sort algorithm using random access iterators.
Definition: string_sort.hpp:447