qsort的使用

转自

http://blog.csdn.net/eroswang/archive/2009/04/15/4075580.aspx

最近用到了qsort,简单整理一下，方便以后的查找

qsort,包含在stdlib.h头文件里,函数一共四个参数,没返回值.一个典型的qsort的写法如下

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

其中第一个参数是参与排序的数组名(或者也可以理解成开始排序的地址,因为可以写&s[i]

这样的表达式,这个问题下面有说明); 第二个参数是参与排序的元素个数; 第三个三数是

单个元素的大小,推荐使用sizeof(s[0])这样的表达式,下面也有说明 :) ;第四个参数就是

很多人觉得非常困惑的比较函数啦,关于这个函数,还要说的比较麻烦...

我们来讨论cmp这个比较函数(写成cmp是我的个人喜好,你可以随便写成什么,比如qcmp什么

的).典型的cmp的定义是

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

返回值必须是int,两个参数的类型必须都是const void *,那个a,b是我随便写的,个人喜好.

假设是对int排序的话,如果是升序,那么就是如果a比b大返回一个正值,小则负值,相等返回

0,其他的依次类推,后面有例子来说明对不同的类型如何进行排序.

在函数体内要对a,b进行强制类型转换后才能得到正确的返回值,不同的类型有不同的处理

方法.具体情况请参考后面的例子.

** 关于快排的一些小问题 **

1.快排是不稳定的,这个不稳定一个表现在其使用的时间是不确定的,最好情况(O(n))和最

坏情况(O(n^2))差距太大,我们一般说的O(nlog(n))都是指的是其平均时间.

2.快排是不稳定的,这个不稳定表现在如果相同的比较元素,可能顺序不一样,假设我们有

这样一个序列,3,3,3,但是这三个3是有区别的,我们标记为3a,3b,3c,快排后的结果不一定

就是3a,3b,3c这样的排列,所以在某些特定场合我们要用结构体来使其稳定(No.6的例子就

是说明这个问题的)

3.快排的比较函数的两个参数必须都是const void *的,这个要特别注意,写a和b只是我的

个人喜好,写成cmp也只是我的个人喜好.推荐在cmp里面重新定义两个指针来强制类型转换,

特别是在对结构体进行排序的时候

4.快排qsort的第三个参数,那个sizeof,推荐是使用sizeof(s[0])这样,特别是对结构体,

往往自己定义2*sizeof(int)这样的会出问题,用sizeof(s[0)既方便又保险

5.如果要对数组进行部分排序,比如对一个s[n]的数组排列其从s[i]开始的m个元素,只需要

在第一个和第二个参数上进行一些修改:qsort(&s[i],m,sizeof(s[i]),cmp);

** 标程,举例说明 **

No.1.手工实现QuickSort

#include <stdio.h>

int a[],n,temp;

void QuickSort(int h,int t)

{

     if(h>=t) return;

     int mid=(h+t)/,i=h,j=t,x;

     x=a[mid];

     while()

     {

         while(a[i]<x) i++;

         while(a[j]>x) j--;

         if(i>=j) break;

         temp=a[i];

         a[i]=a[j];

         a[j]=temp;

     }

     a[mid]=a[j];

     a[j]=x;

     QuickSort(h,j-);

     QuickSort(j+,t);

     return;

}

int main()

{

     int i;

     scanf("%d",&n);

     for(i=;i<n;i++) scanf("%d",&a[i]);

     QuickSort(,n-);

     for(i=;i<n;i++) printf("%d ",a[i]);

     return();

}

No.2.最常见的,对int数组排序

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

int s[],n,i;

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

{

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

}

int main()

{

     scanf("%d",&n);

     for(i=;i<n;i++) scanf("%d",&s[i]);

     qsort(s,n,sizeof(s[]),cmp);

     for(i=;i<n;i++) printf("%d ",s[i]);

     return();

}

No.3.对double型数组排序,原理同int

这里做个注释,本来是因为要判断如果a==b返回0的,但是严格来说,两个double数是不可能相

等的,只能说fabs(a-b)<1e-20之类的这样来判断,所以这里只返回了1和-1

#include <stdio.h>

#include <stdlib.h>

double s[];

int i,n;

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

{

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

}

int main()

{

     scanf("%d",&n);

     for(i=;i<n;i++) scanf("%lf",&s[i]);

     qsort(s,n,sizeof(s[]),cmp);

     for(i=;i<n;i++) printf("%lf ",s[i]);

     return();

}

No.4.对一个字符数组排序.原理同int

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

char s[],i,n;

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

{

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

}

int main()

{

     scanf("%s",s);

     n=strlen(s);

     qsort(s,n,sizeof(s[]),cmp);

     printf("%s",s);

     return();

}

No.5.对结构体排序

注释一下.很多时候我们都会对结构体排序,比如校赛预选赛的那个樱花,一般这个时候都在

cmp函数里面先强制转换了类型,不要在return里面转,我也说不清为什么,但是这样程序会

更清晰,并且绝对是没错的. 这里同样请注意double返回0的问题

#include <stdio.h>

#include <stdlib.h>

struct node

{

     double date1;

     int no;

} s[];

int i,n;

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

{

     struct node *aa=(node *)a;

     struct node *bb=(node *)b;

     return(((aa->date1)>(bb->date1))?:-);

}

int main()

{

     scanf("%d",&n);

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

     {

         s[i].no=i+;

         scanf("%lf",&s[i].date1);

     }

     qsort(s,n,sizeof(s[]),cmp);

     for(i=;i<n;i++) printf("%d   %lf\n",s[i].no,s[i].date1);

     return();

}

No.6.对结构体排序.加入no来使其稳定(即data值相等的情况下按原来的顺序排)

#include <stdio.h>

#include <stdlib.h>

struct node

{

     double date1;

     int no;

} s[];

int i,n;

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

{

     struct node *aa=(node *)a;

     struct node *bb=(node *)b;

     if(aa->date1!=bb->date1)

         return(((aa->date1)>(bb->date1))?:-);

     else

         return((aa->no)-(bb->no));

}

int main()

{

     scanf("%d",&n);

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

     {

         s[i].no=i+;

         scanf("%lf",&s[i].date1);

     }

     qsort(s,n,sizeof(s[]),cmp);

     for(i=;i<n;i++) printf("%d   %lf\n",s[i].no,s[i].date1);

     return();

}

No.7.对字符串数组的排序(char s[][]型)

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

char s[][];

int i,n;

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

{

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

}

int main()

{

     scanf("%d",&n);

     for(i=;i<n;i++) scanf("%s",s[i]);

     qsort(s,n,sizeof(s[]),cmp);

     for(i=;i<n;i++) printf("%s\n",s[i]);

     return();

}

No.8.对字符串数组排序(char *s[]型)

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

char *s[100];

int i,n;

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

{

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

}

int main()

{

scanf("%d",&n);

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

{

s[i]=(char*)malloc(sizeof(char*));

scanf("%s",s[i]);

}

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

for(i=0;i<n;i++) printf("%s\n",s[i]);

return(0);

}

/////////////////////////////////////////////////////////////////////////////////

#include<iostream>

#include <stdlib.h>

using namespace std;

int Comp(const void *p1,const void *p2)

{

return *((int *)p2) - *((int *)p1);

}

int main()

{

int a[50],n,i;

while(cin>>n)

{

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

cin>>a[i];

qsort(a,n,sizeof(a[0]),Comp);

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

cout<<a[i]<<" ";

}

}

/*六类qsort排序方法

前一段时间做题觉得qsort函数很好用，但有时不太会用比如按结构体一级排序、二级排序、字符串排序等，故通过查资料将其整理一番。

以下是其具体分类及用法(若无具体说明是以降序排列)：

1、对一维数组排序：

（Element_type是一位数组中存放的数据类型，可以是char, int, float, double, etc ）

int Comp(const void *p1,const void *p2 )

{

return *((Element_type *)p2) > *((Element_type *)p1)

}

int main()

{

Element_type list[MAX];

initial(list);

qsort(list, sizeof(list),sizeof(Element_type),Comp);

return 0;

}

2、对字符串排序：

int Comp(const void *p1,const void *p2)

{

return strcmp((char *)p2,(char *)p1);

}

int main()

{

char a[MAX1][MAX2];

initial(a);

qsort(a,lenth,sizeof(a[0]),Comp);

}

//lenth 为数组a的长度

3、按结构体中某个关键字排序（对结构体一级排序）：

struct Node

{

double data;

int other;

}s[100];

int Comp(const void *p1,const void *p2)

{

return (*(Node *)p2)->data-(*（Node *）p1)->data;

}

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

4、按结构体中多个关键字排序（对结构体多级排序）[以二级为例]：

struct Node

{

int   x;

int y;

}s[100];

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

int Comp(const void *p1,const void *p2)

{

struct Node   *c = (Node *)p1;

struct Node *d = (Node *)p2;

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

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

}

5、对结构体中字符串进行排序：

struct Node

{

int data;

char str[100];

}s[100];

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

int Comp(const void *p1,const void *p2)

{

return strcmp((*(Node *)p1)->str,(*(Node *)p2)->str);

}

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

6、计算几何中求凸包的Comp

//以下是俺从别人那儿抄来的，暂时还没用过

int Comp(const void *p1,const void *p2)

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

{

struct point   *c=(point *)p1;

struct point *d=(point *)p2;

if( cacl(*c, *d,p[1]) < 0) return 1;

else if(!cacl(*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;

}

P.S.:qsort函数是ANSI   C标准中提供的，其声明在stdlib.h文件中，是根据二分发写的，其时间复杂度为n*log(n),其结构为：

void qsort(void *base,size_t nelem,size_t width,int (*Comp)(const void *,const void *));

其中：

*base 为要排序的数组

nelem 为要排序的数组的长度

width 为数组元素的大小（一字结为单位）

（* Comp）(const void *p1,const void *p2) 为判断大小函数的指针，这个函数需要自己定义，如果p1>p2,函数返回-1；a<b,函数返回1；a==b函数返回0。

//////////////

又见qsort--------zju2727

一道按给定关键字三级排序题，直接套入曾总结过的qsort模型就AC了。算是上次总结的一个补充实例吧。

源代码：

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

struct Node{

char Name[100];

int Year,Price;

}Book[100];

/*----------------------------------------------------------------------------*/

/*int CompY(const void *p1,const void *p2)//首先按year排序

{

struct Node   *c = (Node *)p1;

struct Node *d = (Node *)p2;

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

else if(strcmp((*(Node *)p1).Name,(*(Node *)p2).Name))

return strcmp((*(Node *)p1).Name,(*(Node *)p2).Name);

else return c->Price-d->Price;

}

int CompP(const void *p1,const void *p2)//首先按price排序

{

struct Node   *c = (Node *)p1;

struct Node *d = (Node *)p2;

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

else if(strcmp((*(Node *)p1).Name,(*(Node *)p2).Name))

return strcmp((*(Node *)p1).Name,(*(Node *)p2).Name);

else return c->Year-d->Year;

}

int CompN(const void *p1,const void *p2)//首先按name排序

{

struct Node   *c = (Node *)p1;

struct Node *d = (Node *)p2;

if(strcmp((*(Node *)p1).Name,(*(Node *)p2).Name))

return strcmp((*(Node *)p1).Name,(*(Node *)p2).Name);

else if(c->Year != d->Year) return c->Year-d->Year;

else return c->Price-d->Price;

}

/*-------------------------------------------------------------------*/

/*void outres(int n)

{

int i;

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

printf("%s %d %d\n",Book[i].Name,Book[i].Year,Book[i].Price);

}

/*-----------------------------------------------------------------*/

/*int main()

{

int n;

char format[15];

//freopen("in.txt","r",stdin);

scanf("%d",&n);

while(n)

{

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

scanf("%s%d%d",Book[i].Name,&Book[i].Year,&Book[i].Price);

scanf("%s",format);

if(format[0]=='Y')

{

qsort(Book, n, sizeof(Book[0]), CompY);

}

else if(format[0]=='P')

{

qsort(Book, n, sizeof(Book[0]), CompP);

}

else

{

qsort(Book, n, sizeof(Book[0]), CompN);

}

outres(n);

scanf("%d",&n);

if(n)printf("\n");

}

return 0;

}