区间模糊排序---快排思路的应用

#include<iostream>
#include<ctime>
using namespace std;
#define max(a,b) (a>b)?a:b
#define min(a,b) (a>b)?b:a
class Interval
{
public:
    double leftbound;
    double rightbound;
    Interval(int a, int b) :leftbound(a), rightbound(b){}
    Interval(Interval &i){ leftbound = i.leftbound; rightbound = i.rightbound; }
    Interval(){}
};
void swap(Interval &a, Interval &b)
{
    Interval temp = a;
    a = b;
    b = temp;

}
void display(Interval a[], int begin, int end)
{
    for (int i = begin; i <= end; ++i)
        cout << "[" << a[i].leftbound << "," << a[i].rightbound << "]" << ",";
    cout << endl;
}
void partition(Interval a[], int begin, int end, int &ini, int &ter)   //参数ini、ter是引用，是为了作为返回值
{

    Interval pivot = a[begin];        //主元区间
    ini = begin;
    ter = end + 1;            //注意，这里ter从数组外部开始

    int cur = begin + 1;
    while (cur < ter && cur<end)
    {
        if (a[cur].rightbound <= pivot.leftbound && ini<end)        //小于主元区间
        {
            ++ini;
            swap(a[cur], a[ini]);
            ++cur;
            //cout << "1: ";
            //display(a, begin, end);
        }
        else if (a[cur].leftbound >= pivot.rightbound && ter>begin) //大于主元区间
        {
            --ter;
            swap(a[cur], a[ter]);
            //cout << "2: ";
            //display(a, begin, end);

        }
        else            //和主元区间相等， 所以取交集作为新的主元
        {
            pivot.leftbound = max(pivot.leftbound, a[cur].leftbound);
            pivot.rightbound = min(pivot.rightbound, a[cur].rightbound);
            //cout << "pivot: " << pivot.leftbound<<" ,"<<pivot.rightbound << endl;
            ++cur;
            //cout << "3: ";
            //display(a, begin, end);
        }
    }
    swap(a[ini], a[begin]);    //调整

    --ini;
    //cout << "ini: " << ini <<"  "<< "ter: " << ter << endl;
    //display(a, begin,end);


}
void fuzzySortingOfInterval(Interval a[], int begin, int end)
{
    if (begin < end)
    {
        int ini, ter;
        partition(a, begin, end, ini, ter);
        fuzzySortingOfInterval(a, begin, ini);
        fuzzySortingOfInterval(a, ter, end);
    }
}
int main()
{
    srand(time(NULL));
    const int size = 8;
    Interval a(28508, 31359), b(4712, 30466), c(23267, 30245), d(7134, 8098), e(25400, 26351), f(8079, 29052), g(31163, 31738), h(6346, 24352);
    Interval array[size] = { a, b, c, d, e, f, g, h };
    Interval *array = new Interval[size];
    for (int i = 0; i < size; ++i)
    {
    array[i].leftbound = rand() % 100;
    array[i].rightbound = rand() % 100;
    while (array[i].rightbound < array[i].leftbound)
    array[i].rightbound = rand() % 100;
    }
    display(array, 0, size - 1);
    fuzzySortingOfInterval(array, 0, size - 1);
    display(array, 0, size - 1);
    system("pause");
}

关于算法呢，其实很简单，区间的比较结果有三种：小于，等于（有交集），大于，这里的优化在于，每次有等于情况时都取交集作为新的主元，这样的好处在于：扩大中间等于的区域，减少递归深度。

关于代码呢，这里partition函数我们要返回一个区间，是要返回其左右的数字，而C++只能有一个返回值，因此这里借助了引用返回的技巧来实现，另一方面，我们可以借助STL 的pair类型

pair<int,int>& partition(int begin,int end)

{　　
　　.....

　　

　　return pair<int,int>(ini,ter);

}

调用时  ini=partiton(begin,end).first;ter=partition(begin,end).second;