qsort和sort的区别
qsort快速排序的整理
qsort快速排序的整理最近⽤到了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[100],n,temp;void QuickSort(int h,int t){if(h>=t) return;int mid=(h+t)/2,i=h,j=t,x;x=a[mid];while(1){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-1);QuickSort(j+1,t);return;}int main(){int i;scanf("%d",&n);for(i=0;i<n;i++) scanf("%d",&a[i]);QuickSort(0,n-1);for(i=0;i<n;i++) printf("%d ",a[i]);return(0);}No.2.最常见的,对int数组排序#include <stdio.h>#include <string.h>#include <stdlib.h>int s[10000],n,i;int cmp(const void *a, const void *b){return(*(int *)a-*(int *)b);}int main(){scanf("%d",&n);for(i=0;i<n;i++) scanf("%d",&s[i]);qsort(s,n,sizeof(s[0]),cmp);for(i=0;i<n;i++) printf("%d ",s[i]);return(0);}No.3.对double型数组排序,原理同int这⾥做个注释,本来是因为要判断如果a==b返回0的,但是严格来说,两个double数是不可能相等的,只能说fabs(a-b)<1e-20之类的这样来判断,所以这⾥只返回了1和-1#include <stdio.h>#include <stdlib.h>double s[1000];int i,n;int cmp(const void * a, const void * b){return((*(double*)a-*(double*)b>0)?1:-1);}int main(){scanf("%d",&n);for(i=0;i<n;i++) scanf("%lf",&s[i]);qsort(s,n,sizeof(s[0]),cmp);for(i=0;i<n;i++) printf("%lf ",s[i]);return(0);}No.4.对⼀个字符数组排序.原理同int#include <stdio.h>#include <string.h>#include <stdlib.h>char s[10000],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[0]),cmp);printf("%s",s);return(0);}No.5.对结构体排序注释⼀下.很多时候我们都会对结构体排序,⽐如校赛预选赛的那个樱花,⼀般这个时候都在cmp函数⾥⾯先强制转换了类型,不要在return⾥⾯转,我也说不清为什么,但是这样程序会更清晰,并且绝对是没错的. 这⾥同样请注意double返回0的问题#include <stdio.h>#include <stdlib.h>struct node{double date1;int no;} s[100];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))?1:-1);}int main(){scanf("%d",&n);for(i=0;i<n;i++){s[i].no=i+1;scanf("%lf",&s[i].date1);}qsort(s,n,sizeof(s[0]),cmp);for(i=0;i<n;i++) printf("%d %lf/n",s[i].no,s[i].date1);return(0);}No.6.对结构体排序.加⼊no来使其稳定(即data值相等的情况下按原来的顺序排)#include <stdio.h>#include <stdlib.h>struct node{double date1;int no;} s[100];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))?1:-1);elsereturn((aa->no)-(bb->no));}int main(){scanf("%d",&n);for(i=0;i<n;i++){s[i].no=i+1;scanf("%lf",&s[i].date1);}qsort(s,n,sizeof(s[0]),cmp);for(i=0;i<n;i++) printf("%d %lf/n",s[i].no,s[i].date1); return(0);}No.7.对字符串数组的排序(char s[][]型)#include <stdio.h>#include <string.h>#include <stdlib.h>char s[100][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++) scanf("%s",s[i]);qsort(s,n,sizeof(s[0]),cmp);for(i=0;i<n;i++) printf("%s/n",s[i]);return(0);}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函数很好⽤，但有时不太会⽤⽐如按结构体⼀级排序、⼆级排序、字符串排序等，故通过查资料将其整理⼀番。
C语言之qsort函数详解
C语⾔之qsort函数详解⽬录⼀.qsort函数原型⼆.qsort常见的⼏种⽐较函数1.int类型的排序2.double类型的排序3.char类型的排序4.字符串的排序：1.按⾸字母排序2.按字符串长度排序：总结⼀.qsort函数原型qsort 功能: 使⽤快速排序例程进⾏排序，这个函数是根据⼆分法写的，其时间复杂度为n*log(n)#include<stdlib.h>void qsort(void *base, int nelem, int width, int (*fcmp)(const void *,const void *))各参数：1. 待排序数组⾸地址（可直接输⼊待排序数组名，或是指向数组的指针）2. 数组中待排序元素数量（可以⽤sizeof（）来求）3. 各元素的占⽤空间⼤⼩（可以⽤sizeof（arr[0]）来求）4. 指向函数的指针这个qsort需要我们⾃⼰创建⼀个⽐较函数，基本都是这个函数int cmp(const void* _a, const void* _b)；⼆.qsort常见的⼏种⽐较函数1.int类型的排序int cmp(const void* _a, const void* _b){int* a = (int*)_a;int* b = (int*)_b;return *a-*b;}int main(){int num[10] = { 5,7,8,1,26,52,9,3,14,56 };int sz = sizeof(num) / sizeof(num[0]);qsort(num, sz, sizeof(num[0]), cmp);int i = 0;for (i = 0; i < sz; i++){printf("%d ", num[i]);}}*a-*b这个是从⼩到⼤排序，如果想从⼤到⼩排序就是*b-*a；升序排序结果图：降序排列：int cmp(const void* _a, const void* _b){int* a = (int*)_a;int* b = (int*)_b;return *b-*a;}int main(){int num[10] = { 5,7,8,1,26,52,9,3,14,56 };int sz = sizeof(num) / sizeof(num[0]);qsort(num, sz, sizeof(num[0]), cmp);int i = 0;for (i = 0; i < sz; i++){printf("%d ", num[i]);}}其实降序排序就是换成*b-*a降序排序效果图：2.double类型的排序int cmp(const void* _a, const void* _b){double* a = (double*)_a;double* b = (double*)_b;return *(double*)_a > *(double*)_b ? 1 : -1;;}int main(){double num[4] = { 2.1,5.2,3.2,445.2};int sz = sizeof(num) / sizeof(num[0]);qsort(num, sz, sizeof(num[0]), cmp);int i = 0;for (i = 0; i < sz; i++){printf("%.2f ", num[i]);}}double类型的⽐较特殊，因为返回值是int，所以如果是两个特别相近的浮点数相减，那么就有可能会出现的结果⽐-1⼤并且⽐1⼩，这样系统就会默认为0，所以这⾥使⽤了⼀个三⽬运算，⽤来⽐较。
c qsort原函数 -回复
c qsort原函数-回复c qsort原函数是C语言中的一个排序函数，即快速排序函数，广泛应用于各种排序场景中。
快速排序是一种高效的排序算法，其时间复杂度为O(nlogn)，对于大规模的数据排序非常高效，因此被广泛应用。
首先，我们来介绍一下qsort函数的基本用法。
在C语言中，qsort函数位于stdlib.h头文件中，并且被定义为以下原型：void qsort(void *base, size_t num, size_t size, int (*compar)(const void *, const void *));其中，参数base是一个指向要排序的数组的指针，参数num是数组中元素的个数，参数size是数组中每个元素的大小（以字节为单位），参数compar是一个指向比较函数的指针。
qsort函数通过对数组中的元素进行比较，并按照比较结果进行排序。
排序需要使用到参数compar指向的比较函数，比较函数的形式如下：int compar(const void *a, const void *b);比较函数需要返回一个整数值，如果返回值小于0，则表示a小于b；如果返回值等于0，则表示a等于b；如果返回值大于0，则表示a大于b。
下面我们来详细解释一下qsort函数的使用步骤。
步骤一：引入必要的头文件在使用qsort函数之前，需要引入头文件stdlib.h。
可以使用以下方式引入：#include <stdlib.h>步骤二：编写比较函数根据实际需求，需要编写一个比较函数，用于指定排序的规则。
比较函数的定义类似于以下形式：int compare(const void *a, const void *b) {比较逻辑}比较函数需要根据实际需要进行定义，比如可以根据元素的大小进行比较，或者根据元素的其他属性进行比较。
步骤三：调用qsort函数进行排序在比较函数编写完成后，可以通过调用qsort函数进行排序。
sort函数参数和头文件c语言 -回复
sort函数参数和头文件c语言-回复关于sort函数参数和头文件的讨论在C语言中，sort函数广泛应用于数组或链表的排序操作。
它是一个快速且高效的排序算法，可以根据用户定义的比较函数将元素按照指定的顺序进行排列。
本文将详细介绍sort函数的参数和头文件，以帮助读者更好地理解和使用这一功能强大的函数。
首先，我们需要知道sort函数的基本用法和功能。
sort函数被定义在C 标准库中的<unistd.h>头文件中，因此在使用之前，我们需要在代码中引入这个头文件。
同时，为了使用sort函数，我们还需要了解它的参数和原型。
sort函数的原型如下：cvoid sort(void *base, size_t num, size_t size, int (*cmp_func)(const void *, const void *));下面我们一步一步解释每个参数的作用和含义。
1. base:这个参数是指向要排序数组或链表的指针。
在排序算法中，sort函数会根据用户提供的比较函数来比较这些元素的大小，并对它们进行排序。
要确保指针指向的内存区域足够容纳要排序的元素。
2. num:这个参数表示要排序的元素的数量。
sort函数会根据用户提供的比较函数，将这些元素按照指定的顺序进行排列。
要确保这个参数的值和实际要排序的元素数量一致，否则可能导致排序结果不正确。
3. size:这个参数表示要排序元素的大小，以字节为单位。
sort函数会根据这个参数来确定每个元素的大小，从而进行正确的排序。
要确保这个参数的值和实际要排序的元素大小一致，否则可能导致排序结果不正确。
4. cmp_func:这个参数是一个指向比较函数的指针。
sort函数会调用这个函数，来比较要排序的元素的大小。
比较函数需要满足以下条件：- 它需要返回一个整数值，根据这个返回值来确定两个元素的大小关系。
如果返回值小于0，表示第一个元素小于第二个元素；如果返回值大于0，表示第一个元素大于第二个元素；如果返回值等于0，表示两个元素相等。
qsort函数的用法
六类qsort排序方法以下是其具体分类及用法(若无具体说明是以降序排列)：1、对一维数组排序：（Element_type是一位数组中存放的数据类型，可以是char, int, float, double, etc ）使用qsort之前，必须自己定义一个比较函数。
这个比较函数用于比较两个元素的大小。
由于qsort可以排序任意数据类型，包括自定义的结构类型，因此，做一个自定义的比较函数是必要的。
int Comp(const void *p1,const void *p2 ) {return *((Element_type *)p2) > *((Element_type *)p1) ? 1 : -1;}int main(){Element_type list[MAX];initial(list);qsort(list, sizeof(list),sizeof(Element_type),Comp);// qsort的4个参数：数组的首地址、数组的实际大小，元素的实际大小，比较函数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 ? 1 : -1; }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的用法
qsort的用法
qsort是C语言中的一个函数，用于对数组元素进行排序。
它的用法可以参考下面的示例代码：
```c
#include <stdio.h>
#include <stdlib.h>
int compare(const void *a, const void *b) {
return *(int*)a - *(int*)b;
}
int main() {
int arr[] = { 4, 2, 8, 0, 5, 7, 1, 3, 9, 6 };
int n = sizeof(arr) / sizeof(arr[0]);
qsort(arr, n, sizeof(int), compare);
for (int i = 0; i < n; i++) {
printf('%d ', arr[i]);
}
return 0;
}
```
在该代码中，我们定义了一个整数数组arr，它包含10个随机值。
然后我们调用qsort来对数组进行排序。
qsort需要四个参数：要排序的数组的起始地址，数组中元素的数量，每个元素的字节数，
以及一个比较函数。
比较函数是用来比较数组元素的大小的，它需要接受两个指向数组元素的指针，并返回一个整数值，表示它们的相对大小。
在上面的示例中，我们定义了一个名为compare的比较函数，它将两个整数指针转换为整数，并返回它们的差值。
这个函数用在qsort函数中，以决定数组元素的顺序。
最后，我们使用for 循环打印排好序的数组。
qsort排序原理
qsort排序原理
qsort是一种快速排序算法，它的原理是通过递归将待排序的数组分成两个子数组，一个子数组的所有元素都小于另一个子数组的所有元素。
然后对两个子数组分别进行排序，最终将两个子数组合并起来得到有序的数组。
具体的原理如下：
1. 选择一个基准元素（通常是数组的第一个元素）。
2. 将所有小于基准元素的元素放在基准元素的左边，将所有大于基准元素的元素放在基准元素的右边，形成两个子数组。
3. 对两个子数组递归地重复步骤1和步骤2，直到子数组的长度为1或0。
4. 将两个子数组合并起来，得到最终排序的数组。
快速排序的关键在于如何选择基准元素和如何将元素重新排列。
一种常用的选择基准元素的方法是取数组的第一个元素，然后通过比较将小于它的元素放到它的左边，将大于它的元素放到它的右边。
这样，基准元素就被放置在了它最终的位置上。
然后对左右两个子数组分别重复这个过程，直到子数组的长度为1或0。
快速排序的时间复杂度为O(nlogn)，其中n是待排序的数组长度。
这是因为每次递归将数组划分成两个大小大致相等的子数组，而对这两个子数组的排序都可以通过递归实现。
所以，每次递归的时间复杂度是O(n)，一共需要递归logn次，
所以总的时间复杂度是O(nlogn)。
【C语言】qsort使用详解
【C语⾔】qsort使⽤详解qsort函数是C语⾔的属于<stdlib.h>头⽂件的快速排序函数，qsort(array,array+n,cmp);关于cmp函数的定义规则我们只需简单的记得，当cmp的返回值为true时，即表⽰cmp函数的第⼀个参数将会排在第⼆个参数之前（即在我们定义的规则中，cmp表⽰第⼀个参数是否⽐第⼆个参数⼤，若是，则排在前⾯）。
下⾯通过⼏个例⼦来说明：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:函数指针，指向⽐较函数1.对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);2.对char类型数组排序（同int类型）char word[100];int cmp( const void *a , const void *b ){ return *(char *)a - *(char *)b;}qsort(word,100,sizeof(word[0]),cmp);3.对double类型数组排序（特别要注意）double in[100];int cmp( const void *a , const void *b ){ return *(double *)a > *(double *)b ? 1 : -1;}返回值的问题，显然cmp返回的是⼀个整型，所以避免double返回⼩数⽽被丢失。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1.qsort函数：
原型: void qsort(void *base, int nelem, int width, int (*fcmp)(const void *,const void *));
功能:使用快速排序例程进行排序
参数：
1 待排序数组首地址
2 数组中待排序元素数量
3 各元素的占用空间大小
4 指向函数的指针，用于确定排序的顺序
说明：qsort函数是ANSI C标准中提供的，其声明在stdlib.h文件中，是根据二分法写的，其时间复杂度为n*log(n)。
qsort要求提供的函数是需要自己定义的一个比较函数，比较函数使得qsort通用性更好。
有了比较函数qsort可以实现对数组、字符串、结构体等结构进行升序或降序排序。
如int cmp(const void *a, const void *b)中有两个元素作为参数（参数的格式不能变的。
）返回一个int值，如果比较函数返回大于0，qsort就认为a > b，返回小于0,qsort就认为a < b。
qsort 知道元素的大小了，就可以把大的放前面去。
如果你的比较函数返回本来应该是1的（即a > b），而却返回-1（小于0的数），那么qsort认为a < b，就把b放在前面去，但实际上是a > b的，所以就造成了降序排序的差别了。
简单来说，比较函数的作用就是给qsort指明元素的大小事怎么比较的。
2.qsort中几种常见的cmp函数：
一、对int类型数组排序
int num[100];
int cmp ( const void *a , const void *b )
{
return *(int *)a - *(int *)b;
}
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;
}
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);
六、对字符串进行排序
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);
七、计算几何中求凸包的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;
}
3.sort和qsoort比较：
1．cmp函数和qsort中cmp函数的不同
int cmp(const int &a,const int &b)
{
return a>b
}
Sort中的cmp函数参数可以直接是参与比较的引用类型。
2．cmp函数比较时qsort用“-”，而sort用”>”.这也是一个重要的区别。
3．sort函数是c++中标准模板库的的函数，在qsort()上已经进行了优化，根据情况的不同可以采用不同的算法，所以较快。
在同样的元素较多和同样的比较条件下，sort()的执行速度都比qsort()要快。
另外，sort()是类属函数，可以用于比较任何容器，任何元素，任何条件。
使用时需调用
<algorithm>
sort(begin(),end(),cmp),
（注：文档可能无法思考全面，请浏览后下载，供参考。
可复制、编制，期待你的好评与关注）。