算法导论第三版--桶排序

理解了基数排序，也就理解了桶排序。

桶排序就是基数排序的一种优化，从MSD开始，即取最高位来排一次序，如果最高位没有重复（意味着没有冲突需要处理），是算法的最佳状态，O（n）。

如果有冲突，就将冲突的元素存放到对应的桶里（代码就是一个链表或者数组或者stl容器），然后对每个桶进行一次插入排序，平均情况的话冲突很小的，桶里的元素的数量就不多，速度很快，

如果冲突集中在几个桶甚至一个桶里，那么就出现了算法的最差情形，也就是O(n^2)的复杂度。

下面是例子代码实现：

template<typename _InIt>
void bucket_sort(_InIt first, _InIt last, short decimal_bits) {
    typedef typename iterator_traits<_InIt>::value_type _ValueType;
    typedef typename vector<_ValueType>::iterator _Iterator;

    int n = last - first;
    if (n <= 0) return;

    vector< vector<_ValueType> > v(n, vector<_ValueType>());
    _InIt it = first;
    for(; it!=last; ++it) {
        int i = bucket_index(*it, decimal_bits);
        v[i].insert(v[i].begin(), *it);
    }

    typename vector< vector<_ValueType> >::iterator ite = v.begin();
    less_equal<_ValueType> cmp;
    it = first;

    for(; ite!=v.end(); ++ite) {
        if (ite->empty()) continue;
        insert_sort(ite->begin(), ite->end(), cmp);
        for(_Iterator _it=ite->begin(); _it!=ite->end(); ++_it)
            *it++ = *_it;
    }
}

上面默认采用了递增排序，如果要递减，就反向迭代并使用greater_equal。

为图简便，这里把元素直接放到输入的容器了。

整个测试程序：

#include <iostream>
#include <vector>
#include <cassert>

using namespace std;

template<typename _InIt, typename _Func>
void __insert_sort(_InIt first, _InIt last, _Func& Func) {
    typedef typename iterator_traits<_InIt>::value_type _ValueType;

    for (_InIt it = first+1; it != last+1; ++it) {
        _ValueType key = *it;
        _InIt ite = it - 1;
        for (; (ite - first)>=0 && !Func(*ite, key); --ite)
            *(ite + 1) = *ite;
        *(ite + 1) = key;
    }
}

template<typename _InIt, typename _Func>
void insert_sort(_InIt first, _InIt last, _Func& Func) {
    __insert_sort(first, last-1, Func);
}

int bucket_index(int num, int p) {
    assert(num >0 && p > 0);
    int s = 1;
    while (p-->0) s *= 10;
    return ((num%s)*10)/s;
}

template<typename _InIt>
void bucket_sort(_InIt first, _InIt last, short decimal_bits) {
    typedef typename iterator_traits<_InIt>::value_type _ValueType;
    typedef typename vector<_ValueType>::iterator _Iterator;

    int n = last - first;
    if (n <= 0) return;

    vector< vector<_ValueType> > v(n, vector<_ValueType>());
    _InIt it = first;
    for(; it!=last; ++it) {
        int i = bucket_index(*it, decimal_bits);
        v[i].insert(v[i].begin(), *it);
    }

    typename vector< vector<_ValueType> >::iterator ite = v.begin();
    less_equal<_ValueType> cmp;
    it = first;

    for(; ite!=v.end(); ++ite) {
        if (ite->empty()) continue;
        insert_sort(ite->begin(), ite->end(), cmp);
        for(_Iterator _it=ite->begin(); _it!=ite->end(); ++_it)
            *it++ = *_it;
    }
}

template<typename T>
void print(const vector<T>& v) {
    for(vector<int>::const_iterator it=v.begin(); it != v.end(); it++)
           cout << *it << " ";
        cout << endl;
}

int main() {
    int lst[] = {78,17,39,26,72,94,21,12,23,68};
    vector<int> v(lst, lst+10);

    bucket_sort(v.begin(), v.end(), 2);
    print(v);

    return 0;
}

写完这些例子，在准备刷难度高一点的算法之前，小小的总结了一下。

这些例子的适用范围都很小，仅供学习使用，比如上面的插入排序，迭代器仅仅对vector有效，如果有自己的数据结构容器，最好是为它实现一个随机访问迭代器。