纯C++11标准写类topk算法(不稳定排序)类模板

topk排序是指从N个数据中找出最大/小的前K个数据,并以升/降序排列,本文讨论的topk与这个定义稍有差别(所以叫类topk算法):

从N个数据中将临时计算结果t满足阀值T(大于或小于T)的前K个数据找出,并以升/降序排列(不满足阀值的t不允许占用内存)。
比如，从今年中考成绩中挑出总成绩(总成绩是根据各科成绩加总临时计算的结果，不允许保存)大于520分的前20个学生。如果有50个大于520的学生，我也只挑前20个。如果只有10个学生总分大于520，那么结果就是10个。

最适合topk排序的无疑是堆排序算法(heap sort),但因为有阀值T的存在，而且加上”不满足阀值的数据不能占用内存”的要求,所以传统的堆排序算法并不适合(建堆的过程要求临时保存所有排序数据)。
为什么会有”不满足阀值的数据不能占用内存”这么看似奇怪的要求呢?
比如在一个数据库中有千万级至亿级的标明地点的gps位置数据。现在要从数据库中找出距离位置P 1公里以内最近的前100个地点。按传统的堆排序算法就要将P与所有这些地点计算出距离d1,d2,d3....dn，然后在内存中建堆，排序找出topk。这需要消耗大量内存的,很不现实，也很不经济，更没必要。
合适的做法是：

建立一个容量为100条记录的排序缓冲区数组SORT,初始时缓冲区是空的，排序结果数目SIZE为0。
对数据库中每个地址的位置计算与P的距离，当距离大于1公里时，这个地点自然被丢弃。
小于1公里时，把这个地点p按降序插入SORT(对于有序数组采取二分法查找获取插的位置),SORT中已经有的数据中所有小于p的数据自动向后移动一个数据单元,SIZE累加1。如果缓冲区满（SIZE==100）则最后的一条数据自动被丢弃，同时将最后一条记录的距离值做为最小阀值(比如0.9公里),用于下一次计算时的阀值。
对所有的地点处理完之后。SORT中自然是要求的前100个地点。

以下是使用纯C++11标准实现的代码

/* * topk_base.h * *  Created on: 2015年10月22日 *      Author: guyadong */#ifndef CMIMPL_TOPK_BASE_H_#define CMIMPL_TOPK_BASE_H_#include <cstdlib>#include <cstring>#include <cassert>#include <memory>#include <minmax.h>#include <functional>#include <type_traits>#include "utility.h"using namespace std;namespace gyd{/* 计算比较函数的返回值类型 */template<typename N>struct compare_result{    using type=typename std::conditional    <std::is_arithmetic<N>::value,decltype(declval<N>()-declval<N>()),int>::type;};/* 计算比较器对象(Callable Object)的类型 */template<typename N>struct compartor{    using type=std::function<typename gdface::compare_result<N>::type(N,N)const noexcept>;};/* 定义比较器类型,并根据N,CMP,DEC选择合适的比较器类型 * dec为降序,inc为升序  */template <typename N,typename compartor<N>::type *CMP,bool DEC>struct comparator{    /* 缺省的算术比较器,只适用于arithmetic类型 */    struct arithmetic{        struct dec{            typename compare_result<N>::type inline value(N n1,N n2) const noexcept{return n1-n2;};        };        struct inc{            typename compare_result<N>::type inline value(N n1,N n2) const noexcept{return n2-n1;};        };    };    /* 使用CMP提供的自定义比较器  */    struct other{        struct dec{            static_assert(nullptr != CMP,"nullptr==CMP");            const typename compartor<N>::type&_comparator = *CMP;            typename compare_result<N>::type inline value (N n1,N n2)const noexcept {return _comparator(n1-n2);};        };        struct inc{            static_assert(nullptr != CMP, "nullptr==CMP");            const typename compartor<N>::type&_comparator = *CMP;            typename compare_result<N>::type inline value (N n1,N n2)const noexcept {return _comparator(n2-n1);};        };    };    using type=typename std::conditional<            nullptr!=CMP,            typename std::conditional<DEC,typename other::dec,typename other::inc>::type,            typename std::conditional<DEC,typename arithmetic::dec,typename arithmetic::inc>::type            >::type;};template <typename T,typename N,typename compartor<N>::type *CMP=nullptr,bool DEC=true,typename Enable=void>class topk_base;//通例/* * topk排序(不稳定排序)类模板, * 对象内部有一个容量为m_capacity的排序缓冲区m_sort(初始化时生成), * 用insert方法每次加入一个要排序的对象T,当T的排序值N大于阀值时，将T按排序值插入m_sort(始终是一个有序数组) * T为要排序的对象类型, * N为排序依据的值类型, * CMP为比较器函数对象(Callable Object)指针 * DEC为排序类型，true为降序, * N为数字/算术(arithmetic)类型时,CMP可以为nullptr,否则必须提供CMP, * 非算术类型的CMP函数返回值为int,函数签名int(N n1,N n2), * 如果希望n1要排在n2前面,则返回>0的整数,n1==n2,返回0,否则小0; * 特例: 禁止N为bool类型,比较值为bool类型无意义 * + 操作符 将两个对象合并排序成新对象 * += 操作符将参数对象合并到当前对象 */template <typename T,typename N,typename compartor<N>::type *CMP,bool DEC>class topk_base<T,N,CMP,DEC,typename std::enable_if<!is_same<N,bool>::value>::type>{    //静态断言:N为非算术类型时,CMP不能为nullptr    static_assert(std::is_arithmetic<N>::value||nullptr!=CMP,"FUN must not be nullptr while N is not arithmetic");public:    using SIZE_TYPE =size_t;protected:private:    /* 初始阀值 */    const N m_threshold;    /* 排序缓冲区容量 */    const SIZE_TYPE m_capacity;protected:    /* 排序节点 */    struct _CompareNode{        const T* t;        N  n;    };    /* 排序缓冲区 */    unique_ptr<_CompareNode[]> m_sort;    /* 缓冲区中已经排序元素个数,初始为零 */    SIZE_TYPE m_size=0;    /* 当前阀值指针,初始值指向m_threshold */    const N *mp_threshold=&m_threshold;public:    using M_SIZE_TYPE=decltype(m_size);private:    /* 计算比较器类型 */    using _CMP_TYPE=typename comparator<N,CMP,DEC>::type;    /* 比较器对象 _compatator.value(n1,n2)返回值>0则n1排在n2前面 */    _CMP_TYPE _compatator;    /* 二分法获取新排序节点node在排序缓冲区的排序位置(循环) */    auto rank(const _CompareNode &node, SIZE_TYPE from, SIZE_TYPE size)const noexcept->decltype(from){        auto start=from;        auto len=size;        decltype(len>>1) mid;        typename compare_result<N>::type cmp_res;        do{            if(len>1){                mid=len >> 1;                cmp_res=_compatator.value(node.n, m_sort[start+mid].n);                if(cmp_res>0){                    len-=mid;// 前半部搜索                }else   if(cmp_res<0){                    start+=++mid,len-=mid; // 后半部搜索                }else                    return start+mid;            }else if(len==1){                return _compatator.value(node.n,m_sort[start].n)>=0?start:start+1;            }else                return start;        }while(true);    }    /* 更新当前阀值指针 */    void inline update_threshold()noexcept{        if(m_size==m_capacity){            mp_threshold=&m_sort[m_size - 1].n;//当排序缓冲区满的时候,用最后一个节点的值更新当前阀值指针        }    }    /* 断言两个对象类型相同 */    static void inline assert_same_type(const topk_base &t1,const topk_base &t2)noexcept {        assert(t1.m_capacity==t2.m_capacity&&t1.m_threshold==t2.m_threshold);    }public:    /* 构造函数 maxRows必须>0 */    topk_base(SIZE_TYPE maxRows,N threshold) noexcept:        m_capacity(maxRows),        m_threshold(threshold),        m_sort(make_unique<_CompareNode[]>(maxRows)){        assert(m_capacity>0);    }    /* 复制构造函数 *//*  topk_base(const topk_base& v):            m_capacity(v.m_capacity),            m_threshold(v.m_threshold),            m_sort(make_unique<_CompareNode[]>(v.m_capacity)),            m_size(v.m_size){        memcpy(m_sort.get(),v.m_sort.get(),sizeof(_CompareNode)*m_size);//只复制有效数据    };*/    /* 移动构造函数 */    topk_base(topk_base&& rv)noexcept:            m_capacity(rv.m_capacity),            m_threshold(rv.m_threshold),            m_size(rv.m_size){        std::swap(m_sort,rv.m_sort);    }    /* 移动拷贝函数 */    topk_base& operator=(topk_base&& rv) {        if(m_capacity!=rv.m_capacity||m_threshold!=rv.m_threshold)            throw logic_error("m_capacity==rv.m_capacity OR m_threshold==rv.m_threshold");        m_size=rv.m_size;        m_sort=std::move(rv.m_sort);        return *this;    };    virtual ~topk_base()=default;    /* 将obj加入topk,如果cmpValue小于当前阀值,则返回false */    bool insert(const T& obj,const N cmpValue)noexcept {        auto c=_compatator.value(cmpValue,*mp_threshold);        // 大于阀值才进一步执行比较排序，小于阀值则返回        if(c<0||(c==0&&m_size==m_capacity))            return false;        _CompareNode node{std::addressof<const T>(obj),cmpValue};        //将排序节node点加入排序缓冲区        auto offset = rank(node, 0, m_size);        auto sort=m_sort.get();        // 在offset位置插入节点,offset(含)之后的数据向后移一位        memmove(sort + offset + 1, sort + offset,                sizeof(_CompareNode) * (m_size < m_capacity ? m_size++ - offset : m_capacity - offset-1));        sort[offset] = node;        update_threshold();        return true;    }    M_SIZE_TYPE size()const noexcept{return m_size;}    /* 导出排序结果 */    virtual M_SIZE_TYPE result(T * out)const noexcept{        assert(nullptr!=out);        for(M_SIZE_TYPE i=0;i<m_size;i++)out[i]=*m_sort[i].t;        return m_size;    }    /* 将from中排序的数据合并到当前对象中     * buf_in为排序用的临时对象,可以为nullptr,如果不为nullptr,类型必须与当前对象相同     * 返回当前对象引用     */    topk_base& merge(const topk_base &from,topk_base * buf_in=nullptr) noexcept{        if(from.m_size==0)            return *this;        else {            if(nullptr==buf_in){                topk_base buf(m_capacity,this->m_threshold);                merge_to(from,buf);                *this=std::move(buf);            }else{                merge_to(from,*buf_in);                *this=std::move(*buf_in);            }        }        return *this;    }    /* 将当前对象和from合并排序到目标对象to     * 返回to引用     */    topk_base& merge_to(const topk_base &from,topk_base &to) noexcept{        assert_same_type(from,*this);        assert_same_type(from,to);        assert(to.m_size==0);        auto buf = to.m_sort.get();        typename std::remove_const<decltype(m_capacity)>::type idx = 0;        M_SIZE_TYPE idx_this = 0, idx_from = 0;        decltype(rank(m_sort[0],0,0)) offset_this,offset_from;        while ( idx < m_capacity&&idx_this < m_size&&idx_from < from.m_size&&idx_from < from.m_size) {            offset_this=rank(from.m_sort[idx_from],idx_this,m_size-idx_this);            if(offset_this==idx_this){                offset_from = from.rank(m_sort[idx_this], idx_from + 1, from.m_size - idx_from - 1);                auto copy_size=min(this->m_capacity-idx,offset_from-idx_from);                memcpy(buf+idx,from.m_sort.get()+idx_from,copy_size);                idx+=copy_size;                idx_from += copy_size;                if (idx < m_capacity) {                    buf[idx++] = m_sort[idx_this++];                }            }else{                auto copy_size=min(this->m_capacity-idx,offset_this-idx_this);                memcpy(buf+idx,m_sort.get()+idx_this,copy_size);                idx+=copy_size;                idx_this += copy_size;                if (idx < m_capacity) {                    buf[idx++] = from.m_sort[idx_from++];                }            }        }        if (idx < m_capacity) {            if (idx_from < from.m_size)                memcpy(buf + idx, from.m_sort.get() + idx_from, sizeof(_CompareNode) * min(m_capacity-idx, from.m_size - idx_from));            else if (idx_this < this->m_size)                memcpy(buf + idx, m_sort.get()         + idx_this,   sizeof(_CompareNode) * min(m_capacity-idx, this->m_size - idx_this));        }        to.m_size = min(to.m_capacity, from.m_size + m_size);        to.update_threshold();        return to;    }    /* += 操作符 将参数对象合并到当前对象 */    topk_base&  operator+=(const topk_base &from) noexcept{        return merge(from);    }    /* + 操作符 将两个对象合并排序成新对象 */    topk_base  operator+(const topk_base &from) noexcept{        topk_base res(this->m_capacity,this->m_threshold);        return std::move(merge_to(from,res));//转为右值引用以调用移动构造函数    }};/* topk_base */}/* namespace gyd*/#endif /* CMIMPL_TOPK_BASE_H_ *///以上代码在gcc5/vs2015下编译通过

说明：
考虑的并行计算的需求，topk_base支持归并排序，merge方法就用于对两个已经排序过的topk_base对象进行归并排序，生成新的排序结果，新结果的容量m_capacity仍然不变。
在构造函数使用了上一篇文章《C++11:unique_ptr 自己定义类似make_shared的make_unique模板函数》中提到的make_unique函数(#included "utility.h"),所以代码中虽然有使用堆内存，但没有使用new/delete内存申请释放代码,内存管理都由智能指针unique_ptr自动完成。

topk_base(SIZE_TYPE maxRows,N threshold) noexcept:        m_capacity(maxRows),        m_threshold(threshold),        m_sort(make_unique<_CompareNode[]>(maxRows)){        assert(m_capacity>0);    }

为减少手工定义数据类型经常出容量出现不一致的问题，代码中大量使用了C++11的新特性”类型推导”,除了类最开始的代码出现了具体数据类型using SIZE_TYPE =size_t;，类中所有的成员变量局部变量，返回值都由此推导。
例如：

using M_SIZE_TYPE=decltype(m_size);M_SIZE_TYPE size()const noexcept{return m_size;}//根据m_size的类型推导size方法的返回值类型

        auto buf = to.m_sort.get();        typename std::remove_const<decltype(m_capacity)>::type idx = 0;//根据m_capacity的类型推导idx的类型        M_SIZE_TYPE idx_this = 0, idx_from = 0;//根据m_size的类型推导idx_this，idx_from的类型        decltype(rank(m_sort[0],0,0)) offset_this,offset_from;//根据rank方法的返回类型定义offset_this，offset_from的类型

以下是topk_base调用方法的示范代码

    topk_base<code_bean,float>top(200, 0.75f);    //迭代器循环调用insert，将当前对象*itor和临时计算出来的排序依据值(FCUtils::compare(itor->code, code))加入top    for (auto itor = begin(); !itor.end(); ++itor) {        top.insert(*itor, FCUtils::compare(itor->code, code));    }    //循环结束,top对象就是排序结果。可以调用 size()获取排序结果数目，然后调用 result方法获取排序结果。    topk_base<code_bean,float> tb1(200,0.5f);//创建一个对象    topk_base<code_bean,float> tb2(200,0.5f);    tb1.merge(tb2);//合并tb1到tb1    topk_base<code_bean,float> tb3=tb1+tb2;//tb1,tb2合并到tb3