qsort和sort的用法

qsort和sort的区别 

 

一 、qsort函数

基本快速排序的方法，每次把数组分成两分和中间的一个划分值，而对于有多个重复值的数组来说，基本排序的效率较低。集成在C语言库函数里面的的qsort函数，使用 三 路划分的方法解决这个问题。所谓三路划分，是指把数组划分成小于划分值，等于划分值和大于划分值的三个部分。

函数对buf 指向的数据按升序排序。

使用方法：

void qsort( void *base, size_t num, size_t width, int (__cdecl *compare )

int compare (const void *elem1, const void *elem2 ) );

qsort（quicksort）主要根据你给的比较条件给一个快速排序，主要是通过指针移动实现排序功能。排序之后的结果仍然放在原来数组中。

参数意义如下:

base:需要排序的目标数组开始地址

num:目标数组元素个数

width:目标数组中每一个元素长度

compare:函数指针，指向比较函数

 

 

一、对int类型数组排序

int num[100];

int cmp ( const void *a , const void *b )

{

return *(int *)a - *(int *)b;

可见：参数列表是两个空指针，现在他要去指向你的数组元素。所以转型为你当前的类型，然后取值。升序排列。

因为是按照acs码的值进行的，所以在前面的字符的值一定小于后面的字符。

那么，对于a b，如果a的值>b的值，就说明在字母表中a在b的后面，返回值为1表示ture，执行交换。

}

qsort(num,100,sizeof(num[0]),cmp);

 

二、对char类型数组排序（同int类型）

char word[100];

int cmp( const void *a , const void *b )

{

return *(char *)a - *(int *)b;

}

qsort(word,100,sizeof(word[0]),cmp);

 

三、对double类型数组排序（特别要注意）

double in[100];

int cmp( const void *a , const void *b )

{

return *(double *)a > *(double *)b ? 1 : -1;

返回值的问题，显然cmp返回的是一个整型，所以避免double返回小数而被丢失。 

来一个判断。 

}

qsort(in,100,sizeof(in[0]),cmp)；

 

四、对结构体一级排序

struct In

{

double data;

int other;

}s[100]

 

//按照data的值从小到大将结构体排序,关于结构体内的排序关键数据data的类型可以很多种，参考上面的例子写

 

int cmp( const void *a ,const void *b)

{

return (*(In *)a).data > (*(In *)b).data ? 1 : -1;

}

 

qsort(s,100,sizeof(s[0]),cmp);

五、对结构体二级排序

struct In

{

  int x;

  int y;

}s[100];

 

//按照x从小到大排序，当x相等时按照y从大到小排序

 

int cmp( const void *a , const void *b )

{

struct In *c = (In *)a;

struct In *d = (In *)b;

if(c->x != d->x) return c->x - d->x;

else return d->y - c->y;

}

qsort(s,100,sizeof(s[0]),cmp);

六、对字符串进行排序

char str[100][100];

int cmp(const void* a,const void* b )

{

    return strcmp((char *)a,(char*)b);

}

qsort(str,n,sizeof(str[0]),cmp);

值得注意的是，上面的n，很有可能你会误认为是100，这里实际应该是你要排序的个数，比如说你实际上只有str[0],str[1],str[2]这三个字符串要排序，那么n就应该是3，而不是100； 

struct In

{

int data;

char str[100];

}s[100];

//按照结构体中字符串str的字典顺序排序

int cmp ( const void *a , const void *b )

{

return strcmp( (*(In *)a)->str , (*(In *)b)->str );

}

 

qsort(s,100,sizeof(s[0]),cmp);

 

注意！qsort 中的  cmp 得自己写 。

七、计算几何中求凸包的cmp

int cmp(const void *a,const void *b)

//重点cmp函数，把除了1点外的所有点，旋转角度排序

{

struct point *c=(point *)a;

struct point *d=(point *)b;

if( calc(*c,*d,p[1]) < 0)

         return 1;

else if( !calc(*c,*d,p[1]) && dis(c->x,c->y,p[1].x,p[1].y) < dis(d->x,d->y,p[1].x,p[1].y))

//如果在一条直线上，则把远的放在前面

        return 1;

else return -1;

}

PS: 其中的qsort函数包含在的头文件里，strcmp包含在的头文件里

二、sort函数

sort 使用时得注明：using namespace std;   或直接打 std::sort()  还得加上  #include <algorithm> 

例： 

#include<iostream>

#include<algorithm>

using namespace std;

int main(){

      int a[20];

      for(int i=0;i<20;++i)

           cin>>a[i];

 

sort(a,a+20);          //范围，很明显这里是a+20 注意，这是必要的，如果是a+19

for(i=0;i<20;i++)        //最后一个值a[19]就不会参与排序。

     cout<<a[i]<<endl;

      return 0;

}

 

std::sort是一个改进版的qsort. std::sort函数优于qsort的一些特点：对大数组采取9项取样，更完全的三路划分算法，更细致的对不同数组大小采用不同方法排序。

 

 

qsort和sort的区别 区别：

 

sort是qsort的升级版，如果能用sort尽量用sort，使用也比较简单，不像qsort还得自己去写 cmp 函数，只要注明  使用的库函数就可以使用，参数只有两个（如果是普通用法）头指针和尾指针；

 

默认sort排序后是升序，如果想让他降序排列，可以使用自己编的cmp函数

 

bool compare(int a,int b)

{

  return a>b; //降序排列，如果改为return a<b，则为升序

} 

sort(*a,a+n,cmp);

sort函数拓展

sort 对给定区间所有元素进行排序

stable_sort 对给定区间所有元素进行稳定排序

partial_sort 对给定区间所有元素部分排序

partial_sort_copy 对给定区间复制并排序

nth_element 找出给定区间的某个位置对应的元素

is_sorted 判断一个区间是否已经排好序

partition 使得符合某个条件的元素放在前面

stable_partition 相对稳定的使得符合某个条件的元素放在前面

语法描述为：

（1）sort(begin,end)，表示一个范围，例如：

int _tmain(int argc, _TCHAR* argv[])

{

 inta[20]={2,4,1,23,5,76,0,43,24,65},i;

 for(i=0;i<20;i++)

 cout<<a[i]<<endl;

 sort(a,a+20);

 for(i=0;i<20;i++)

 cout<<a[i]<<endl;

 return 0;

}

输出结果将是把数组a按升序排序，说到这里可能就有人会问怎么样用它降序排列呢？这就是下一个讨论的内容。

（2）sort(begin,end,compare)

一种是自己编写一个比较函数来实现，接着调用三个参数的sort：sort(begin,end,compare)就成了。对于list容器，这个方法也适用，把compare作为sort的参数就可以了，即：sort(compare)。

1）自己编写compare函数：

bool compare(int a,int b)

{

 return a<b; //升序排列，如果改为return a>b，则为降序

}

int _tmain(int argc, _TCHAR* argv[])

{

  inta[20]={2,4,1,23,5,76,0,43,24,65},i;

 for(i=0;i<20;i++)

 cout<<a[i]<<endl;

  sort(a,a+20,compare);

 for(i=0;i<20;i++)

 cout<<a[i]<<endl;

 return 0;

}

2）更进一步，让这种操作更加能适应变化。也就是说，能给比较函数一个参数，用来指示是按升序还是按降序排,这回轮到函数对象出场了。

为了描述方便，我先定义一个枚举类型EnumComp用来表示升序和降序。很简单：

enum Enumcomp{ASC,DESC};

然后开始用一个类来描述这个函数对象。它会根据它的参数来决定是采用“<”还是“>”。

class compare

{

 private:

 Enumcomp comp;

 public:

 compare(Enumcomp c):comp(c) {};

 bool operator () (int num1,int num2)

  {

 switch(comp)

  {

 case ASC:

 return num1<num2;

  case DESC:

  return num1>num2;

  }

  }

};

 

接下来使用 sort(begin,end,compare(ASC))实现升序，sort(begin,end,compare(DESC))实现降序。

主函数为：

int main()

{

  inta[20]={2,4,1,23,5,76,0,43,24,65},i;

 for(i=0;i<20;i++)

 cout<<a[i]<<endl;

 sort(a,a+20,compare(DESC));

 for(i=0;i<20;i++)

 cout<<a[i]<<endl;

 return 0;

}

3)其实对于这么简单的任务（类型支持“<”、“>”等比较运算符），完全没必要自己写一个类出来。标准库里已经有现成的了，就在functional里，include进来就行了。functional提供了一堆基于模板的比较函数对象。它们是（看名字就知道意思了）：equal_to<Type>、not_equal_to<Type>、greater<Type>、greater_equal<Type>、less<Type>、less_equal<Type>。对于这个问题来说，greater和less就足够了，直接拿过来用：

 

升序：sort(begin,end,less<data-type>());

降序：sort(begin,end,greater<data-type>()).

int _tmain(int argc, _TCHAR* argv[])

{

  inta[20]={2,4,1,23,5,76,0,43,24,65},i;

 for(i=0;i<20;i++)

 cout<<a[i]<<endl;

 sort(a,a+20,greater<int>());

 for(i=0;i<20;i++)

 cout<<a[i]<<endl;

 return 0;

}

4)既然有迭代器，如果是string 就可以使用反向迭代器来完成逆序排列，程序如下：

int main()

{

 string str("cvicses");

 string s(str.rbegin(),str.rend());

 cout << s <<endl;

 return 0;

}

 

 

这是我在百度上找到的1011题的答案，我觉得用它来说明sort()函数最具有代表性

 

#include <iostream>

#include <algorithm>

#include <cstdio>

#include <functional>

using namespace std;

int stick[100], n;

bool used[100];

 

//unused:没有使用的棍子的数目

//left:剩下的长度

//len:当前认为的计算的长度

bool dfs(int unused, int left, int len)

{

       // 所有的棍子已经用了，且没有剩余的长度,符合搜索条件

       if (unused == 0 && left == 0)

       return true;

       int i;

       //没有剩下的.则新开一条棍子

       if (left == 0)

        left = len;

       //寻找没有使用过的棍子

       for (i=0; i<n; ++i)

       {

                //找到没有用过的,而且长度比left值要小(能够填进去)

                if (!used &&stick<=left)

                {

                        //使用当前棍子

                        used = true;

                       //若在当前情况下能够扩展出正确答案,则返回

                        if (dfs(unused-1,left-stick, len))

                                //成功搜索,返回

                                return true;

                        //否则不使用当前的棍子

                        used = false;

                        //若使用stick不能扩展出正确结果,那么如果stick与left等长,则证明len不可能是正确答案

                        //若left与len等长,就是没有办法扩展

                        if (stick == left ||left == len)

                                break;

                }

       }

        //经过一轮搜索仍得不到正确答案,则返回false

       return false;

} 

int main()

{

       int i, sum;

       while (scanf("%d", &n) != EOF && n)

        {

                sum = 0;

                for (i=0; i<n; ++i)

                {

                        scanf("%d",&stick);

                        used = false;

                        sum += stick;

                }

                //先进行从大到小排序

                sort(stick, stick+n,greater<int>());

                //根据题目条件，从小向大寻找

                for (i=stick[0]; i<=sum;++i)

                {

                        //棍子总长被i整除才进行搜索,否则没用

                        if (sum % i == 0)

                        {

                                if (dfs(n, 0,i))

                                {

                                        printf("%d\n", i);

                                        break;

                                }

                        }

                }

       }

       return 0;

}