qsort用法

qsort包含在<stdlib.h>头文件中，此函数根据你给的比较条件进行快速排序，通过指针移动实现排序。排序之后的结果仍然放在原数组中。使用qsort函数必须自己写一个比较函数。

函数原型

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

函数一共四个参数，没返回值。

一个典型的qsort的写法如下:

void 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个元素，只需要在第一个和第二个参数上进行一些修改:

void qsort(&s[i],m,sizeof(s[i]),cmp);

*** 标程，举例说明 ***

No.1、手工实现QuickSort:

基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 void QuickSort(int *A,int left,int right)
 4 {
 5     if(left>=right) return;
 6     int x=A[(left+right)>>1],low=left,high=right;
 7     while(low<high)
 8     {
 9         while(A[low]<x)
10             low++;
11         while(A[high]>x)
12             high--;
13         if(low<=high)
14         {
15             int Temp=A[low];
16             A[low]=A[high];
17             A[high]=Temp;
18             low++;
19             high--;
20         }
21     }
22     QuickSort(A,left,high);
23     QuickSort(A,low,right);
24 }
25 int main()
26 {
27     int length,i,r[10000];
28     scanf("%d",&length);
29     for(i=1;i<=length;i++)
30         scanf("%d",&r[i]);
31     QuickSort(r,1,length);
32     for(i=1;i<=length;i++)
33         printf(" %d",r[i]);
34     printf("\n");
35     system("pause");
36     return 0;
37 }

或者：

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 int QKPass(int r[],int left,int right)
 4 {
 5     int low,high,x;
 6     x=r[left];//选择基准记录
 7     low=left;
 8     high=right;
 9     while(low<high)
10     {
11         while(low<high&&r[high]>=x)//从右到左找到小于x的记录
12             high--;
13         if(low<high)
14         {
15             r[low]=r[high];//找到后进行替换
16             low++;
17         }
18         while(low<high&&r[low]<x)
19         {
20             low++;
21         }
22         if(low<high)
23         {
24             r[high]=r[low];
25             high--;
26         }
27         r[low]=x;//将基准记录保存在low=high的位置
28         return low;//返回基准记录的位置
29     }
30 }
31 int QKSort(int r[],int low,int high)
32 {
33     int pos;
34     if(low<high)
35     {
36         pos=QKPass(r,low,high);
37         QKSort(r,low,pos-1);
38         QKSort(r,pos+1,high);
39     }
40 }
41 int main()
42 {
43     int length,i,r[10000];
44     scanf("%d",&length);
45     for(i=1;i<=length;i++)
46         scanf("%d",&r[i]);
47     QKSort(r,1,length);
48     for(i=1;i<=length;i++)
49         printf("%-3d",r[i]);
50     printf("\n");
51     system("pause");
52     return 0;
53 }

No.2、最常见的，对int数组排序 :

 1 #include<stdio.h> 
 2 #include<stdlib.h>
 3 int s[10000],n,i;
 4 int cmp(const void *a, const void *b) 
 5 { 
 6      return(*(int *)a-*(int *)b);  //升序 
 7      //return(*(int *)b-*(int *)a); //降序 
 8 }
 9 int main() 
10 { 
11      scanf("%d",&n); 
12      for(i=0;i<n;i++) 
13         scanf("%d",&s[i]); 
14      qsort(s,n,sizeof(s[0]),cmp);     
15      for(i=0;i<n;i++)
16         printf("%d ",s[i]);
17      printf("\n");
18      system("pause");
19      return 0; 
20 }

No.3、对double型数组排序，原理同int：

这里做个注释，本来是因为要判断如果a==b返回0的，但是严格来说，两个double数是不可能相等的，只能说fabs(a-b)<1e-20之类的这样来判断，所以这里只返回了1和-1 

 1 #include<stdio.h> 
 2 #include<stdlib.h>
 3 double s[1000]; 
 4 int i,n;
 5 int cmp(const void * a, const void * b) 
 6 { 
 7      return((*(double*)a-*(double*)b>0)?1:-1); 
 8 }
 9 
10 int main() 
11 { 
12      scanf("%d",&n); 
13      for(i=0;i<n;i++)
14         scanf("%lf",&s[i]);     
15      qsort(s,n,sizeof(s[0]),cmp);     
16      for(i=0;i<n;i++)
17         printf("%.2lf ",s[i]); 
18      printf("\n");
19      system("pause");   
20      return(0); 
21 }

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

 1 #include<stdio.h> 
 2 #include<string.h> 
 3 #include<stdlib.h>
 4 char s[10000],i,n;
 5 int cmp(const void *a,const void *b) 
 6 { 
 7      return(*(char *)a-*(char *)b); 
 8 }
 9 int main() 
10 { 
11      scanf("%s",s); 
12      n=strlen(s); 
13      qsort(s,n,sizeof(s[0]),cmp);     
14      printf("%s",s); 
15      printf("\n");
16      system("pause");
17      return 0; 
18 }

No.5、对结构体排序（一级排序）:

很多时候我们都会对结构体排序，比如2010年校赛的那个根据几个参数排序，一般这个时候都在cmp函数里面先强制转换了类型，不要在return里面转换，我也说不清为什么，但是这样程序会更清晰，并且绝对是没错的。 这里同样请注意double返回0的问题:

 1 #include<stdio.h> 
 2 #include<stdlib.h>
 3 struct node 
 4 { 
 5      double data; 
 6      int no; 
 7 } s[100];
 8 int i,n;
 9 int cmp(const void *a,const void *b) 
10 { 
11      struct node *aa=(node *)a; 
12      struct node *bb=(node *)b; 
13      return(((aa->data)>(bb->data))?1:-1); 
14 }
15 int main() 
16 { 
17      scanf("%d",&n); 
18      for(i=0;i<n;i++) 
19      { 
20          s[i].no=i+1; 
21          scanf("%lf",&s[i].data); 
22      } 
23      qsort(s,n,sizeof(s[0]),cmp); 
24     
25      for(i=0;i<n;i++)
26          printf("%d %lf\n",s[i].no,s[i].data); 
27      system("pause");
28      return 0; 
29 }

No.6、对结构体排序（二级排序）。加入no来使其稳定（即data值相等的情况下按原来的顺序排）:

 1 #include<stdio.h> 
 2 #include<stdlib.h>
 3 struct node 
 4 { 
 5      double data; 
 6      int no; 
 7 } s[100];
 8 
 9 int i,n;
10 int cmp(const void *a,const void *b) 
11 { 
12      struct node *aa=(node *)a; 
13      struct node *bb=(node *)b; 
14      if(aa->data!=bb->data) 
15          return(((aa->data)>(bb->data))?1:-1); 
16      else 
17          return((aa->no)-(bb->no)); 
18 }
19 int main() 
20 { 
21      scanf("%d",&n); 
22      for(i=0;i<n;i++) 
23      { 
24          s[i].no=i+1; 
25          scanf("%lf",&s[i].data); 
26      } 
27      qsort(s,n,sizeof(s[0]),cmp);
28      for(i=0;i<n;i++)
29          printf("%d %lf\n",s[i].no,s[i].data);
30      printf("\n");
31      system("pause");
32      return 0; 
33 }

如果有字符串的话，就这样写：

 1 int cmp(const void *a,const void *b) 
 2 { 
 3      struct node *aa=(node *)a; 
 4      struct node *bb=(node *)b; 
 5      if(aa->data!=bb->data) 
 6          return(((aa->data)>(bb->data))?1:-1); 
 7      else 
 8          return((aa->no)-(bb->no));
 9      else 
10          return strcmp(aa.str,bb.str);
11          //return strcmp(aa->str,bb->str);
12          //按照结构体中字符串str的字典顺序排序
13 }

No.7、对字符串数组的排序（char s[][]型）:

 1 #include<stdio.h> 
 2 #include<string.h> 
 3 #include<stdlib.h>
 4 char s[100][100]; 
 5 int i,n;
 6 int cmp(const void *a,const void *b) 
 7 { 
 8      return(strcmp((char*)a,(char*)b)); 
 9 }
10 int main() 
11 { 
12      scanf("%d",&n); 
13      for(i=0;i<n;i++)
14         scanf("%s",s[i]);
15      qsort(s,n,sizeof(s[0]),cmp);  
16      for(i=0;i<n;i++)
17         printf("%s\n",s[i]); 
18      printf("\n");
19      system("pause");
20      return 0; 
21 }

No.8、对字符串数组排序（char *s[]型）:

 1 #include<stdio.h> 
 2 #include<string.h> 
 3 #include<stdlib.h>
 4 char *s[100]; 
 5 int i,n;
 6 int cmp(const void *a,const void *b)
 7 { 
 8      return(strcmp(*(char**)a,*(char**)b)); 
 9 }
10 int main() 
11 { 
12      scanf("%d",&n); 
13      for(i=0;i<n;i++) 
14      { 
15          s[i]=(char*)malloc(sizeof(char*)); 
16          scanf("%s",s[i]); 
17      }
18      qsort(s,n,sizeof(s[0]),cmp);
19      for(i=0;i<n;i++)
20          printf("%s\n",s[i]);
21      printf("\n");
22      system("pause");
23      return 0; 
24 }

 

posted @ 2016-05-11 22:32  新生代黑马  阅读(1589)  评论(0)  编辑  收藏  举报