C++ 中的 MSD 基数排序（字典顺序）

Question

Thanks for reading this post.

I wanted to create an MSD radix sort that's supposed to sort a vector of unsigned integers in lexicographic (alphabetic) order.

Given "1, 3, 32, 1254, 3, 165, 50000, 11, 213"

Sorted "1, 11, 1254, 165, 213, 3, 3, 32, 50000"

Since I think I should do it recursively, I tried to capture the highest digits and call the function recursively with the next digit for all the numbers. However, I just realized that I got the logic wrong since this would sort in the regular numeric order as I iterated on all numbers from the highest digit with the same digit (eg the 5th one, which could be 0 for numbers that have no more than 5 digits). So I abandoned this algorithm but could not come up with new thoughts.

Since this could deal with any numbers, it should operate recursively. I have some ideas now, but they seemed not to be working:

1. Since this is similar to an alphabetic order, I could change the integers into strings by using std::to_string() , and use std::sort() , but I don't think this is a good option since it's no longer seeking an algorithm outcome, and I don't know how to change the string back to an unsigned integer.
2. I wanted to find the largest digit by repeatedly dividing 10 until the result is less than 10, then sort by this digit for each number, but it's not working since the digits of the number vary, and I cannot do it recursively as I already lost most part of the data by dividing. I think I am still sticking to the numeric sorting model. I don't really see the steps that we could make recursion possible when we cannot determine a fixed digit or any possible point to compare so we could implement the recursive sort.

Do you have any implementation ideas about this different kind of number sorting?

Answer 1

#include <vector>
#include <algorithm>
#include <iostream>
#include <array>
#include <numeric>
#include <cassert>

namespace details
{
    const int kNoDigit = -1;
    int ExtractDigit(int i, int pos) {
        const int digitsCount = log10(i) + 1;
        if (pos > digitsCount) return kNoDigit;
        return (int)(i / pow(10, digitsCount - pos)) % 10;
    }

    // For pos equals to 2 and {10 20 1} -> {0, 1, 3, 3, ...},
    // 1 ends with empty digit in the second digit and 2 ends with 0
    template <class It>
    auto CountingSort(It begin, It end, int pos) {
        std::array<int, 12> bins;
        std::fill(bins.begin(), bins.end(), 0);
        for (auto it = begin; it < end; ++it) {
            const int digit = ExtractDigit(*it, pos);
            ++bins[digit + 1];
        }
        std::partial_sum(bins.cbegin(), bins.cend(), bins.begin());
        std::move(bins.cbegin(), bins.cend() - 1, bins.begin() + 1);
        return bins;
    }

    template <class It>
    void MsdRadixInternal(It begin, It end, int pos) {
        const auto bins = CountingSort(begin, end, pos);
        // We finish when i is 1, because the last part ends up sorted anyway
        for (int i = 10; i > 0; --i) {
            const int digit = i - 1;
            const auto local_begin = begin + bins[i];
            const auto local_end = begin + bins[i + 1];
            if (local_begin == begin) break;
            if (std::distance(local_begin, local_end) > 0) {
                auto crsrForward = begin;
                auto crsrBackward = local_end - 1;
                while (crsrForward < crsrBackward) {
                    assert(crsrForward < local_begin && local_begin <= crsrBackward);
                    while (ExtractDigit(*crsrBackward, pos) == digit) --crsrBackward;
                    while (ExtractDigit(*crsrForward, pos) != digit) ++crsrForward;
                    if (crsrForward < local_begin) {
                        std::swap(*crsrBackward, *crsrForward);
                    }
                    ++crsrForward;
                }
            }
        }
        // Start from 1 as we don't want to sort numbers wich are out of digits in pos already
        for (int i = 1; i < 11; ++i) {
            if (bins[i + 1] - bins[i] > 1)
                MsdRadixInternal(begin + bins[i], begin + bins[i + 1], pos + 1);
        }
    }
}

template <class It>
void MsdRadix(It begin, It end) {
    details::MsdRadixInternal(begin, end, 1);
}

int main()
{
    std::vector<int> v = { 1, 3, 32, 1254, 3, 165, 50000, 11, 213 };
    MsdRadix(v.begin(), v.end());
    std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
    return 0;
}

1 11 1254 165 213 3 3 32 50000

This implementation doesn't aim for efficiency, eg extract digit could be implemented in a much faster way.