双调排序算法Bitonic Sort的实现

双调排序（bitonic sort）属于排序网络(Sorting Network）的一种，是一个可并行计算的排序算法。

Bitonic Sort是一个叫Batcher的数学家在1968年提出的。基础是关于双调序列的Batcher定理。

这个排序算法其实实现起来比较简单（当然我说的是递归实现），但是隐藏在其背后的数学原理就不是那么简单就能说明白的了。在参考了维基百科（http://en.wikipedia.org/wiki/Bitonic_sorter）上面的介绍以及小例子之后，基本明白了这个算法的实现原理。

1、对于一个给定的整形数组A，我们将其均分为两个部分A1,A2；

2、对A1进行升序排序，对A2进行降序排序；

3、将A1和A2进行合并，成为一个升序的数组；

算法的重点在于合并的部分，这其中利用了所谓的Batcher定理。

废话不说了，下面上代码：

#include <iostream>
#include <string>
using namespace std;

//双调排序类
class Bitonic_Sorter
{
private:
    int* array;//改造后的输入数组，是真正进行排序处理的数组
    int* tmp_array;//实际输入的数组
    int length;//改造后的输入数组的长度
    int tmp_length;//输入数组的实际长度
    int gap;//原数组长度和改造后数组长度差值（0或一个正数）
    bool dire;//排序方式，true为升序
    int ret_gap();
    void transfer();
    void bitonic_sort(int lowbundary, int len,bool direction);
    void bitonic_merge(int lowbundary,int len,bool direction);
    void compare_and_swap(int i,int j,bool direction);
public:
    Bitonic_Sorter(int arr[],int len);
    void printData();
    void Sorter(bool dir);
};

//构造函数，完成属性赋值
Bitonic_Sorter::Bitonic_Sorter(int arr[],int len)
{
    tmp_array = arr;
    tmp_length = len;
    gap = ret_gap();
    
}

//根据输入数组的长度返回gap的值
int Bitonic_Sorter::ret_gap()
{
    double x = (double)log(tmp_length) / log(2);//求log2(length);
    int z = x + 1;
    int a = (int)pow(2,z);
    int b = a - tmp_length;//若length是2^n，则b=0；否则b为其与下一个2^n的差值；
    if (b == tmp_length)
    {
        return 0 ;//说明输入的数组长度满足2^n
    }
    else{
        return b ;//说明输入的数组长度与2^n相差b
    }
}

//改造函数，将长度不是2^n的输入数组改造成2^n数组
void Bitonic_Sorter::transfer()
{
    if(gap == 0){//输入数组长度满足2^n
        array = tmp_array;
        length = tmp_length;
    }
    else{
        int *temp = new int[tmp_length+gap];//tmp_length+gap即是改造后的数组长度
        for(int i = 0;i<tmp_length;i++)//完成原数组对新数组的赋值
        {
            temp[i] = tmp_array[i];
        }
        for (int j = tmp_length;j<tmp_length+gap;j++)//对新数组的多余部分赋值
        {
            if (dire)//升序的话，则填充整型数最大值，不会影响排序及输出，仍取排序后的前tmp_length个数
            {
                temp[j] = INT_MAX;
            }
            else//降序的话，则填充整型数最小值。
            {
                temp[j] = INT_MIN;
            }
        }
        array = temp;
        length = tmp_length+gap;
    }
}

//打印改造后的数组，用于排序后输出
void Bitonic_Sorter::printData()
{
    for(int i=0;i<tmp_length;i++)//tmp_length才是我们实际需要的排序结果长度
    {
        cout<<array[i]<<", ";
    }
}

//公有排序函数，调用私有函数实现
void Bitonic_Sorter::Sorter(bool dir)
{
    dire = dir;//排序方式
    transfer();//调用改造函数
    bitonic_sort(0,length,dire);
}

//私有排序函数,递归调用实现
void Bitonic_Sorter::bitonic_sort(int lowbundary,int len,bool direction){
    if(len>1){
        int m=len/2;
        bitonic_sort(lowbundary,m,direction);//对前半部分进行排序
        bitonic_sort(lowbundary+m,m,!direction);//后半部分
        bitonic_merge(lowbundary,len,direction);//两部分组合
    }
}

//合并函数，递归调用实现
void Bitonic_Sorter::bitonic_merge(int lowbundary,int len,bool direction){
    if(len>1){
        int m=len/2;
        for(int i=lowbundary;i<lowbundary+m;i++){
            compare_and_swap(i,i+m,direction);
        }
        bitonic_merge(lowbundary,m,direction);//递归合并前半部分
        bitonic_merge(lowbundary+m,m,direction);//后半部分
    }
}

//比较交换函数
void Bitonic_Sorter::compare_and_swap(int i, int j,bool direction){
    if(direction==(array[i]>array[j])){
        swap(array[i],array[j]);
    }
}

//主函数
void main()
{
    int inputarray[1000];
    int count = 0;
    cout<<"Please Input Your Numbers, Each One With An Enter, Finished By Ctrl+Z!"<<endl<<"Start>>";
    while (cin>>inputarray[count])
    {
        cout<<"Next>>";
        count++;
    }
    //以上为输入数组
    cout<<endl<<"INPUT: 【 ";

    for (int i=0;i<count;i++)
    {
        cout<<inputarray[i]<<", ";
    }
    cout<<"】"<<endl;
    //输出输入的数组
    Bitonic_Sorter bs = Bitonic_Sorter(inputarray,count);
    bs.Sorter(true);
    cout<<"OUTPUT IN ASCENDING ORDER: 【 ";
    bs.printData();
    cout<<"】"<<endl;
    //升序排序
    bs.Sorter(false);
    cout<<"OUTPUT IN DESCENDING ORDER: 【 ";
    bs.printData();
    cout<<"】"<<endl;
    //降序排序
    system("pause");//等待结束

}

在编码时参考了http://blog.csdn.net/here1009/article/details/7918185，但是经过实际运行发现它的代码虽然支持任意长度数组排序，但是总是有错。我的代码做了一些修改，即如果数组长度不是2^n，那么我们就将它改造成2^n长度的数组，多出来的部分填充INT_MAX或者INT_MIN，这样的话就不会影响排序结果啦~