stl sort和qsort的使用

好不容易使用了下stl的qsort函数，顺便和sort函数一起总结下：

很多时候我们都需要用到排序。

 例如：
 1 #include <iostream>
 #include <algorithm>

 using namespace std;

 int a[] = {, , , , };//对这个数组排序
 int main()
 {
     sort(a, a + );
     for (int i = ; i < ; i++)
         cout<<a[i]<<endl;
     return ;
 }

aaarticlea/png;base64,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" alt="" />

可以看到，sort默认是从小到达排序的,那如何自定义排序呢。

先看看sort的函数声明：

template <class RandomAccessIterator>
  void sort (RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class Compare>
  void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

sort函数将[first, last]区间按升序进行排序，排序是使用值类型的<运算符进行比较。第一个版本使用<来确定顺序，也就是从大到小，

第二个版本则使用自定义的比较对象或比较函数。

现在要对a[] = {, , , , };进行升序。

#include <iostream>
#include <algorithm>

using namespace std;

int a[] = {, , , , };
int b[] = {, , , , };
bool cmp(const int a, const int b)
{
    return a > b;
}
class cmpClass
{
public:
    bool operator () (const int a, const int b)
    {
        return a > b;
    }
};
struct cmpStruct/**< 使用类似cmpClass */
{
    bool operator () (const int a, const int b)/**< 自定义比较对象需要重载()才行 */
    {
        return a > b;
    }
};
int main()
{
    sort(a, a + , cmp);/**< 使用自定义函数 */
    cout<<"a[]:";
    for (int i = ; i < ; i++)
        cout<<' '<<a[i];
    cout<<endl;
    cmpClass a;/**< 先声明个对象 */
    sort(b, b + , a);/**< 使用比较对象 */
    cout<<"b[]:";
    for (int i = ; i < ; i++)
        cout<<' '<<b[i];
    cout<<endl;
    return ;
}
运行结果:
a[]:
b[]:     

对于自定义类型也可以使用sort，但必须提供比较函数。
例如

#include <iostream>
#include <algorithm>

using namespace std;
struct point
{
    int x, y;
    bool operator < (const point &b)const/**<重载<号，可根据自己需要实现内部代码 */
    {
        if (x == b.x)
            return y < b.y;
        return x < b.x;
    }
};
point p[] =
{
    , ,
    , ,
    , ,
    , ,
    ,
};
/**< 对p数组进行排序,先按x小的，如果x相等，再按y小的排序 */
int main()
{
    sort(p, p + );
    cout<<"p[]:";
    for (int i = ; i < ; i++)
        cout<<'('<<p[i].x<<','<<p[i].y<<')';
    cout<<endl;
    return ;
}
也可以自己用自定义的比较函数或比较对象来排序。
运行结果:
p[]:(,)(,)(,)(,)(,)

下面就来讲讲qsort函数

/**< 对于下面的a数组，如何使用qsort来排序呢，先看看代码实现 */
#include <iostream>
#include <algorithm>

using namespace std;

int a[] = {, , , , };
int cmp(const void *a, const void *b)/**< 从小到大排序 */
{
    return ((*(int *)a) - (*(int *)b);
}
int main()
{
    qsort(a, , sizeof(a[]), cmp);
    cout<<"a[]:";
    for (int i = ; i < ; i++)
        cout<<' '<<a[i];
    return ;
}
运行结果:
a[]:     

对于整数和字符类型可以直接返回差值，
但对于实数需要注意，因为比较函数返回的是int类型。
例如:

#include <iostream>
#include <algorithm>

using namespace std;

double a[] = {2.4, 1.5, 3.4, 5.5, 1.6};
int cmp(const void *a, const void *b)/**< 从小到大排序 */
{
    return (*(double *)a) > (*(double *)b) ?  : -;
}
int main()
{
    qsort(a, , sizeof(a[]), cmp);
    cout<<"a[]:";
    for (int i = ; i < ; i++)
        cout<<' '<<a[i];
    return ;
}
运行结果:
a[]: 1.5 1.6 2.4 3.4 5.5

还是先来看看qsort函数原型
_CRTIMP void __cdecl qsort(void*, size_t, size_t, int (*)(const void*, const void*));
对于为何要那样定义比较函数应该有个大概明白了吧。
原型要与int (*)(const void*, const void*)(函数指针的应用)对应。

qsort也可对自定义类型排序

#include <iostream>
#include <algorithm>

using namespace std;
struct point
{
    int x, y;
};
point p[] =
{
    , ,
    , ,
    , ,
    , ,
    ,
};

int cmp(const void *a, const void *b)
{
    point *pa = (point *)a;
    point *pb = (point *)b;
    if (pa->x == pb->y)
        return pa->y - pb->y;
    return pa->x - pb->y;
}
/**< 对p数组进行排序,先按x小的，如果x相等，再按y小的排序 */
int main()
{
    qsort(p, , sizeof(p[]), cmp);
    cout<<"p[]:";
    for (int i = ; i < ; i++)
        cout<<'('<<p[i].x<<','<<p[i].y<<')';
    cout<<endl;
    return ;
}
运行结果:
p[]:(,)(,)(,)(,)(,)

对于其它自定义类型也是类似。

sort和qsort函数的平均时间复杂度都是NlogN,log以2为底。
都在algorithm文件里，同时别忘了使用命名空间
using namespace std。
看到这以后就不用在担心自己不会写排序函数了，学会了这两个函数，应付大部分排序就足够用了。