使用选择算法编译时间递归排序

Posted

技术标签:

【中文标题】使用选择算法编译时间递归排序【英文标题】:Compile Time Recursive Sort with Selection Algorithm 【发布时间】:2013-12-26 01:34:13 【问题描述】:

是否可以使用选择算法在 C++ 中编写编译时递归排序函数?

我想从元素istart 到元素iend 以升序对数组x 进行排序。数组 x 具有 N 元素。输入数组x 中的数据只有在运行时才知道,因此数据只能在运行时进行排序。但是,我想生成 C++ 代码,即在编译时对 sort_asc() 的所有递归函数调用。此外,我想在 CUDA 设备函数中使用此代码。由于 CUDA 是具有少量扩展的 C++ 子集,因此我认为这是正确的地方。不幸的是,我认为 CUDA 不支持 constexpr 关键字,Boost 和 STL 都不支持。

我想出了下面的升序排序代码。

// sort in ascending order.
template< int istart, int N, int iend, int iend_min_istart >
inline void sort_asc
(
    float *x
)

    int   min_idx = istart;
    float min_val = x[ min_idx ];
    #pragma unroll
    for( int i=istart+1; i<N; i++ )
        if( x[ i ] < min_val )
            min_idx = i;
            min_val = x[ i ];
        
    
    swap( x[ istart ], x[ min_idx ] );
    sort_asc< istart+1, N, iend, iend-(istart+1) >( x );
   

在哪里iend_min_istart = iend - istart。如果iend_min_istart &lt; 0 则递归结束,因此我们可以将终止条件写为:

// sort recursion termination condition.
template< int istart, int N, int iend > 
inline void sort_asc< -1 >
(
    float *x
)

    // do nothing.

swap函数定义为:

void d_swap
( 
    float &a, 
    float &b 
)

    float c = a;
    a = b;
    b = c;

然后我将排序函数称为:

void main( int argc, char *argv[] )

    float x[] =  3, 4, 9, 2, 7 ;   // 5 element array.
    sort_asc< 0, 5, 2, 2-0 >( x );   // sort from the 1st till the 3th element.
    float x_median = cost[ 2 ];      // the 3th element is the median

但是,此代码无法编译,因为 c++ 不支持函数的部分模板特化。此外,我不知道如何在 C++ 元编程中编写它。有什么办法可以让这段代码工作吗?

【问题讨论】:

相关:***.com/q/19559808/420683 通常可以使用重载代替部分特化。使用std::integral_constant&lt;int, N&gt;,让编译器推导出N;另一个重载使用固定的N,因此在重载解析中更加专业和首选。 Boost 解决方案(看起来像快速排序):boost.org/doc/libs/1_55_0/libs/mpl/doc/refmanual/sort.html 另外,为了让我的问题更具体:输入数组x中的数据只有在运行时才知道,因此数据只能在运行时进行排序。但是,我想生成 C++ 代码,即在编译时对 SORT::sort() 的所有递归函数调用。此外,我想在 CUDA 设备函数中使用此代码。由于 CUDA 是具有少量扩展的 C++ 子集,因此我认为这是正确的地方。不幸的是,我认为 CUDA 不支持 constexpr 关键字,Boost 和 STL 都不支持。 我认为您应该将此部分添加到您的问题中(作为编辑,而不仅仅是作为评论),因为它非常重要。 【参考方案1】:

这次使用选择排序。 (Variant using merge sort.) 没有任何保证,但通过了一个简单的测试:

// generate a sequence of integers as non-type template arguments
// (a basic meta-programming tool)
template<int... Is> struct seq ;
template<int N, int... Is> struct gen_seq : gen_seq<N-1, N-1, Is...> ;
template<int... Is> struct gen_seq<0, Is...> : seq<Is...> ;


// an array type that can be returned from a function
// and has `constexpr` accessors (as opposed to C++11's `std::array`)
template<class T, int N>
struct c_array

    T m[N];

    constexpr T const& operator[](int p) const
      return m[p];  

    constexpr T const* begin() const  return m+0; 
    constexpr T const* end() const  return m+N; 
;


// return the index of the smallest element
template<class T, int Size>
constexpr int c_min_index(c_array<T, Size> const& arr, int offset, int cur)

    return Size == offset ? cur :
           c_min_index(arr, offset+1, arr[cur] < arr[offset] ? cur : offset);

我们的目标是能够在编译时进行排序。我们可以为此使用多种工具(宏、类模板、constexpr 函数),但constexpr 函数在许多情况下往往是最简单的。

上面的函数c_min_index是C++11对constexpr函数的限制的一个例子:它只能包含一个return语句(加上static_assertusing),至少对于一些可能的参数必须产生一个常量表达式。这意味着:没有循环,没有赋值。所以我们需要在这里使用递归,并将中间结果传递给下一次调用(cur)。

// copy the array but with the elements at `index0` and `index1` swapped
template<class T, int Size, int... Is>
constexpr c_array<T, Size> c_swap(c_array<T, Size> const& arr,
                                  int index0, int index1, seq<Is...>)

    return arr[Is == index0 ? index1 : Is == index1 ? index0 : Is]...;

由于constexpr 函数限制,我们无法修改参数,因此我们需要返回一个整个数组的副本来交换两个元素。

该函数期望Is... 是一个整数序列0, 1, 2 .. Size-1,由gen_seq&lt;Size&gt;(在其基类中)产生。这些整数用于访问数组arr 的元素。像arr[Is]... 这样的表达式会产生arr[0], arr[1], arr[2] .. arr[Size-1]。在这里,我们通过对当前整数应用条件来交换索引:a[0 == index0 ? index1 : 0 == index1 ? index0 : 0], ..

// the selection sort algorithm
template<class T, int Size>
constexpr c_array<T, Size> c_sel_sort(c_array<T, Size> const& arr, int cur = 0)

    return cur == Size ? arr :
           c_sel_sort( c_swap(arr, cur, c_min_index(arr, cur, cur),
                              gen_seq<Size>),
                       cur+1 );

同样,我们需要用递归替换循环 (cur)。剩下的是一个直接的选择排序实现,语法很尴尬:从索引cur开始,我们找到剩余数组中的最小元素,并将其与cur处的元素交换。然后,我们对剩余的未排序数组重新运行选择排序(通过递增cur)。

#include <iostream>
#include <iterator>

int main()

    // homework: write a wrapper so that C-style arrays can be passed
    //           to an overload of `c_sel_sort` ;)
    constexpr c_array<float,10> f = 4, 7, 9, 0, 6, 2, 3, 8, 1, 5;
    constexpr auto sorted = c_sel_sort(f);
    for(auto const& e : sorted) std::cout << e << ", ";

【讨论】:

我很惊讶c_swap 可以如此轻松地实现。预计会有更多麻烦。 有趣的是这个编译在 clang 但不是 g++。 @remyabel 是的,我在实现合并排序时已经遇到了这个问题。我认为可以通过传递 c_array 本身而不是指针来规避它。 @remyabel Voilà,到处使用c_array,现在 g++4.8.1 也很高兴。虽然我不太清楚那是 clang++ 扩展还是 g++ 错误(倾向于认为是前者)。我认为它现在也变得更简单了,但不幸的是与c_array紧密结合。 @DyP 非常感谢您提供详细的代码和解释。我很感激。我将不得不更深入地研究 C++ 元编程,以了解这段代码是如何在幕后工作的。【参考方案2】:

我想出了以下元代码,它可以工作。

template < class T >
__forceinline void swap
( 
    T &a, 
    T &b 
)

    T c = a;
    a = b;
    b = c;


template< int istart, int N, int iend, int iend_min_istart >
class SORT

    public:
        static __forceinline void sort( float *x, int *idx )
        
            // sort code.
            int   min_idx = istart;
            float min_val = x[ min_idx ];
            for( int i=istart+1; i<N; i++ )
                if( x[ i ] < min_val )
                    min_idx = i;
                    min_val = x[ i ];
                
            
            swap(   x[ istart ],   x[ min_idx ] );
            swap( idx[ istart ], idx[ min_idx ] );
            SORT<istart+1, N, iend, iend-(istart+1)>::sort( x, idx );
        
;

template< int istart, int N, int iend >
class SORT<istart,N,iend,-1>

    public:
        static __forceinline void sort( float *x, int *idx )
        

        
;

void main( int argc, char *argv[] )

    float arr[] = 1,4,2,7,5;
    int   idx[] = 0,1,2,3,4;
    SORT<0,5,3,2-0>::sort( arr, idx );

【讨论】:

但这只是编译时,如果您的编译器将其解析为优化。这意味着您不会得到可以在需要常量表达式的上下文中使用的结果。 @DyP,我有以下情况:输入数组x中的数据仅在运行时已知,其长度Nistartiend在编译时已知时间。 (main 函数中的arr 仅作为示例,但在我的应用程序中编译时不知道其内容)因此,我必须在运行时对数据进行排序。但是,我想生成 C++ 代码,即所有对SORT::sort() 的递归函数调用,用于在编译时将长度为N 的数组从元素istart 排序到元素iend。编译器会为我这样做吗? 这取决于编译器是否真的内联。 __forceinline,尽管它的名字,并不强制内联(至少,不是 MSVC++)。但是现在您的算法对我来说更有意义;)我建议不要使用我的(constexpr)进行运行时排序。也许稍后我会添加另一个答案,以演示我在 cmets 中提到的对您的问题的重载技巧。它通常会简化这种偏特化。

以上是关于使用选择算法编译时间递归排序的主要内容,如果未能解决你的问题,请参考以下文章

算法采用递归方式实现按升序排序的选择排序算法(C++源码)

《图解算法》--二分查找选择排序递归

内部排序常用算法(含动图及算法性能测试程序,了解不同情况下的排序算法的选择)

递归-之二分查找与选择排序算法

4.1算法递归 冒泡,选择插入排序

快速排序算法