qsort和sort的用法
qsort,sort排序
C语言标准库函数qsort详解qsort包含在<stdlib.h>头文件中,此函数根据你给的比较条件进行快速排序,通过指针移动实现排序。
排序之后的结果仍然放在原数组中。
使用qsort函数必须自己写一个比较函数。
函数原型:void qsort ( void * base, size_t num, size_t size, int ( * comparator ) ( const void *, const void * ) );指向任意数据类型的指针都可以转换为void*类型用法以及参数说明:Sorts the num elements of the array pointed by base, each element size bytes long, using the comparator function to determine the order.The sorting algorithm used by this function compares pairs of values by calling the specified comparator function with two pointers to elements of the array.The function does not return any value, but modifies the content of the array pointed by base reordering its elements to the newly sorted order.base Pointer to the first element of the array to be sorted.(数组起始地址)num Number of elements in the array pointed by base.(数组元素个数)size Size in bytes of each element in the array.(每一个元素的大小)comparator Function that compares two elements.(函数指针,指向比较函数)1、The function must accept two parameters that are pointers to elements, type-casted as void*. These parameters should be cast back to some data type and be compared.2、The return value of this function should represent whether elem1 is considered less than, equal to, or greater than elem2 by returning, respectively, a negative value, zero or a positive value. Return Value none (无返回值)给你们的C++帮助文档上面的语法及定义是:语法:对buf指向的数据(包含num项,每项的大小为size)进行快速排序。
qsort和sort的区别
qsort和sort学习与比较1.qsort函数:原型: void qsort(void *base, int nelem, int width, int (*fcm p)(constvoid *,constvoid *));功能:使用快速排序例程进行排序参数:1 待排序数组首地址2 数组中待排序元素数量3 各元素的占用空间大小4 指向函数的指针,用于确定排序的顺序说明:qsort函数是ANS I C标准中提供的,其声明在st dlib.h文件中,是根据二分法写的,其时间复杂度为n*log(n)。
qsort要求提供的函数是需要自己定义的一个比较函数,比较函数使得qsort通用性更好。
有了比较函数qsort可以实现对数组、字符串、结构体等结构进行升序或降序排序。
如int cm p(constvoid *a, constvoid *b)中有两个元素作为参数(参数的格式不能变的。
)返回一个in t值,如果比较函数返回大于0,qsort就认为a > b,返回小于0,qsort就认为a < b。
qsort知道元素的大小了,就可以把大的放前面去。
如果你的比较函数返回本来应该是1的(即a > b),而却返回-1(小于0的数),那么qsor t认为a< b,就把b放在前面去,但实际上是a > b的,所以就造成了降序排序的差别了。
简单来说,比较函数的作用就是给q sort指明元素的大小事怎么比较的。
2.qsort中几种常见的cmp函数:一、对int类型数组排序int num[100];int cm p ( constvoid *a , constvoid *b ){return *(int *)a - *(int *)b;}qsort(num,100,sizeof(num[0]),c m p);二、对char类型数组排序(同int类型)char word[100];int cm p( constvoid *a , constvoid *b ){return *(char *)a - *(int *)b;}qsort(word,100,sizeof(word[0]),cmp);三、对doubl e类型数组排序(特别要注意)double in[100];int cm p( constvoid *a , constvoid *b ){return *(double *)a > *(double *)b ? 1 : -1;}qsort(in,100,sizeof(in[0]),c m p);四、对结构体一级排序struct In{double data;int other;}s[100]//按照data的值从小到大将结构体排序,关于结构体内的排序关键数据dat a的类型可以很多种,参考上面的例子写int cm p( constvoid *a ,constvoid *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 cm p( constvoid *a , constvoid *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];//按照结构体中字符串st r的字典顺序排序int cm p ( constvoid *a , constvoid *b ){return strcmp( (*(In *)a)->str , (*(In *)b)->str );}qsort(s,100,sizeof(s[0]),cmp);七、计算几何中求凸包的cm pint cm p(constvoid *a,constvoid *b) //重点cm p函数,把除了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和q soort比较:1.cmp函数和qsort中cmp函数的不同int cm p(constint &a,constint &b){return a>b}Sort中的cmp函数参数可以直接是参与比较的引用类型。
STL中qsort的七种用法
STL中qsort的七种用法qsort() 应该就是用的快排。
貌似是以数据块的方式移动数据,速度较快。
原型:_CRTIMP void __cdecl qsort (void*, size_t, size_t,int (*)(const void*, const void*));解释: qsort ( 数组名,元素个数,元素占用的空间(sizeof),比较函数)比较函数是一个自己写的函数遵循 int com(const void *a,const void *b) 的格式。
当a b关系为 > < = 时,分别返回正值负值零(或者相反)。
使用a b 时要强制转换类型,从void * 转换回应有的类型后,进行操作。
数组下标从零开始,个数为N, 下标0-(n-1)。
示例:int nn[100],n=100;int com(const void *a,const void *b){return *(int*)a-*(int*)b;}qsort((void *)nn,n,sizeof(int),com);相关:为什麽你必须给予元素个数?(因为阵列不知道它自己有多少个元素)为什麽你必须给予double 的大小?(因为 qsort 不知道它要排序的单位是 doubles.)为什麽你必须写那个丑陋的、用来比较 doubles 数值的函式?(因为 qsort 需要一个指标指向某个函式,因为它不知道它所要排序的元素型别)为什麽 qsort 所使用的比较函式接受的是 const void* 引数而不是 char* 引数?(因为 qsort 可以对非字串的数值排序)Bjarne Stroustrup一、对int类型数组排序int num[100];Sample: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];Sample: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);自己写一个纯字符串的:(temp是二维的字符串数组,j是一共需排序的字符串个数)int cmpstr(const void *a,const void *b){return strcmp((char*)a,(char*)b);}qsort(temp, j,sizeof(temp[0]),cmpstr);七、计算几何中求凸包的cmpint cmp(const void *a,const void *b) //重点cmp函数,把除了1点外的所有点,旋转角度排序。
C函数qsort的简介和用法,新手入门
自定义比较函数
比较函数的名字是自定义的(这里我们用CMP命名); Cmp:qsort 要求提供的这个函数是一个需要自己定义的比较函 : 要求提供的这个函数是一个需要自己定义的 自己定义 比较函数使得qsort通用性更好。有了比较函数 通用性更好。 数,比较函数使得 通用性更好 有了比较函数qsort可以实 可以实 现对数组,字符串,结构体等结构进行升序或降序排序。 现对数组,字符串,结构体等结构进行升序或降序排序。 Int Cmp(const void *a , const void *b )中有两个元素作为参数, 中有两个元素作为参数, 中有两个元素作为参数 返回一个int值 如果比较函数返回大于0, 返回一个 值, 如果比较函数返回大于 ,qsort就认为 a>b , 就认为 如果比较函数返回等于0 就认为a 这两个元素相等, 如果比较函数返回等于 qsort就认为 和b 这两个元素相等,返 就认为 回小于零 qsort就认为 a<b 。 就认为 qsort 知道元素大小,就可以把大的放到前面去。 知道元素大小,就可以把大的放到前面去。 如果你的比较函数放回本来应该是1 如果你的比较函数放回本来应该是 的(a>b),你比较函数却返 你比较函数却返 小于零的)那么qsort认为 认为a<b 的,就把 b放到前面 回一个 -1 (小于零的)那么 认为 放到前面 但实际上是a大于 大于b的 所以就造成升降序的差别了。 去,但实际上是 大于 的,所以就造成升降序的差别了。 简单来说,比较函数的作用就是给 简单来说,比较函数的作用就是给qsort指明元素的大小是怎么 指明元素的大小是怎么 比较的。 比较的。
应用qsort对结构体二级排序: 对结构体二级排序: 应用 对结构体二级排序
#include <stdio.h> #include <stdlib.h> struct coord { int x; int y; }data[100]; int cmp(struct coord *a ,struct coord *b) { if(a->x != b->x) return a->x - b->x; ////按照 从小到大排序,当x相等时按照 从大到小排序 按照x从小到大排序 相等时按照y从大到小排序 按照 从小到大排序, 相等时按照 else return a->y - b->y ; } void main() { int sum=0,n; int i,j; freopen("in.txt","r",stdin); while(scanf("%d",&n)!=EOF&&n) { for(i=0;i<n;i++) scanf("%d %d",&data[i].x,&data[i].y); for(i=0;i<n;i++) printf("%d %d ",data[i].x,data[i].y); printf("\n"); qsort(data,n,sizeof(data[0]),cmp); for(i=0;i<n;i++) printf("%d %d ",data[i].x,data[i].y); printf("\n"); } } 输入: 输入: 5 22 21 43 39 42 0
qsort函数的用法
qsort函数的用法一、qsort函数的概述qsort函数是C语言中的标准库函数,用于对数组进行快速排序。
它可以按照用户定义的比较函数将数组元素排序,并且具有较高的效率和灵活性。
二、qsort函数的语法qsort函数的语法如下:```void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));```其中,参数解释如下:- base:要排序的数组首元素地址。
- nmemb:要排序的元素个数。
- size:每个元素的大小。
- compar:比较函数指针,用于确定元素之间的大小关系。
三、qsort函数的使用步骤使用qsort函数进行数组排序需要以下步骤:1. 定义一个比较函数,用于确定元素之间的大小关系。
2. 调用qsort函数进行数组排序。
四、定义比较函数比较函数是一个用户自己定义的用于确定元素之间大小关系的函数。
它接收两个参数,分别为待比较元素a和b,返回值为整型。
比较函数需要满足以下条件:1. 如果a小于b,则返回负数。
2. 如果a等于b,则返回0。
3. 如果a大于b,则返回正数。
例如,如果要对一个int类型数组进行升序排列,则可以定义如下比较函数:```int cmp(const void *a, const void *b) {return (*(int*)a - *(int*)b);}```五、调用qsort函数进行数组排序调用qsort函数进行数组排序需要传入以下参数:1. 要排序的数组首元素地址。
2. 要排序的元素个数。
3. 每个元素的大小。
4. 比较函数指针。
例如,对一个int类型数组进行升序排列,可以使用以下代码:```int arr[] = {5, 3, 1, 2, 4};int n = sizeof(arr) / sizeof(arr[0]);qsort(arr, n, sizeof(int), cmp);```六、注意事项1. qsort函数只能对内存中的数据进行排序,不能对文件中的数据进行排序。
c语言 qsort 用法
qsort 是C 语言标准库中的一个函数,用于对数组进行排序。
它的函数原型如下:void qsort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*));其中,base 是数组的基址,num 是数组中元素的个数,size 是每个元素占用的字节数,compar 是比较函数,用于指定排序的方式。
qsort 函数的排序方式是冒泡排序,其具体实现过程如下:1. 从数组的第一个元素开始,依次比较相邻的两个元素的大小;2. 如果前一个元素比后一个元素大,则交换这两个元素的位置;3. 重复上述操作,直到数组全部排序完成。
compar 函数用于指定排序的方式,其函数原型如下:int compar(const void* a, const void* b);其中,a 和 b 分别指向数组中的两个元素,compar 函数返回值为一个整数,如果 a 小于b,则返回一个负整数;如果a 等于b,则返回0;如果a 大于b,则返回一个正整数。
下面是一个简单的例子,演示如何使用qsort 函数对数组进行排序:#include <stdio.h>#include <stdlib.h>int main() {int arr[] = { 6, 2, 9, 7, 1, 5, 3 };int i, num = sizeof(arr) / sizeof(arr[0]);// 使用qsort 函数对数组进行排序qsort(arr, num, sizeof(int), (int (*)(const void*, const void*))compar);printf("排序后的数组为:");for (i = 0; i < num; i++) {printf("%d ", arr[i]);}printf("\n");return 0;}// 比较函数int compar(const void* a, const void* b) {return (*(int*)a - *(int*)b);}在上面的代码中,我们定义了一个数组arr,然后使用qsort 函数对数组进行排序,指定比较函数为compar。
C语言qsort函数的简介和用法,保证简洁明了!
• int cmp ( const void *a , const void *b ) •{ • return strcmp( (*(In *)a)->str , (*(In *)b)->str ); •}
• qsort(s,100,sizeof(s[0]),cmp);
Cmp()定义了两个const void(类型为空)的指针*a和*b; 在*(int *)a - *(int *)b; 这句中把指针强制转换为 int型; 我们可以将const void 改为你需要排序对象的类型; int num[100]; int cmp ( int *a , int *b ) { return *a - *b; } qsort(num,100,sizeof(num[0]),cmp); 如果要对num[100]中的元素从大到小排序,只需要将return *a - *b改为 return *b -*a 就可以实现;
qsort简单实例
• 应用qsort对int数组进行排序:
• #include <stdio.h>
• #include <stdlib.h>
• int cmp_1 ( int *a , int *b )
•{
• return *a - *b;
•}
• int cmp_2 ( int *a , int *b )
qsort简介
• qsort函数是ANSI C标准中提供的,其声明在 stdlib.h文件中,是根据二分发写的,其时间复杂 度为n*log(n),其结构为:
• void qsort(void *base,size_t nelem,size_t width, cmp);
C语言中qsort函数用法
C语⾔中qsort函数⽤法最近在刷PAT时C语⾔中qsort函数的使⽤极多,所以在这⾥总结整理了⼀下,需要的朋友可以参考下。
qsort函数⽤法C语⾔中qsort函数的⽤法实例详解快速排序是⼀种⽤的最多的排序算法,在C语⾔的标准库中也有快速排序的函数,下⾯说⼀下详细⽤法。
qsort函数包含在<stdlib.h>中qsort函数声明如下:void qsort(void * base,size_t nmemb,size_t size ,int(*compar)(const void *,const void *));参数说明:base,要排序的数组nmemb,数组中元素的数⽬size,每个数组元素占⽤的内存空间,可使⽤sizeof函数获得compar,指向函数的指针也即函数指针。
这个函数⽤来⽐较两个数组元素,第⼀个参数⼤于,等于,⼩于第⼆个参数时,分别显⽰正值,零,负值。
⽤法实例⼩结C语⾔中的qsort函数包含在<stdlib.h>的头⽂件⾥,排序默认都是采⽤的从⼩到⼤排序。
(如果要降序排序,只需将return⾥的a,b反过来写即可。
)⼀、对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 - *(char *)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 node{double one;int two;} s[100];完整代码struct node{double one;int two;} s[100];int cmp( const void *a ,const void *b){return ( * (node * )a).one > ( * (node * )b).one ? 1 : -1;}qsort(s,100,sizeof(s[0]),cmp);五、对结构体⼆级排序struct node{double one;int two;} s[100];//按照x从⼩到⼤排序,当x相等时按照y从⼤到⼩排序int cmp( const void *a , const void *b ){if((* (node * )a).one != ( * (node * )b).one)return ( * (node * )a).one > ( * (node * )b).one ? 1 : -1;else return (* (node * )a).two -( * (node * )b).two;}qsort(s,100,sizeof(s[0]),cmp);六、对字符串进⾏排序char am = { {"...."}, {"....."}, .....};//根据字符串⾸字母排序int cmp(const void *a, const void *b){return * (char *)a - *(char * )b;}qsort(a, m, sizeof(char * ) * n, cmp);char am = { {"...."}, {"....."}, .....};//根据字符串长度排序int cmp(const void *a, const void *b){return strlen((char * )a) > strlen((char * )b) ? 1 : -1;}qsort(a, m, sizeof(char * ) * n, cmp);char am = { {"...."}, {"....."}, .....};//按照结构体中字符串str的字典顺序排序int cmp(const void *a, const void *b){return (strcmp((char *)a, (char *)b));}qsort(a, m, sizeof(char * ) * n, cmp);七、计算⼏何中求凸包的cmpint 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)) //如果在⼀条直线上,则把远的放在前⾯}具体样例1.int类型数组排序#include<stdio.h>#include<stdlib.h>#define L 20int cmp(const void *a, const void *b){return *(int *)a - *(int *)b;}int main (){int a[L] = {0, 5, 2, 3, 4, 9, 8, 7, 6, 1,11, 15, 14, 12, 13, 16, 17, 18, 19, 10};qsort(a, L, sizeof(int), cmp);for (int i = 0; i < L; i++){printf("%d ", a[i]);}}2.double类型数组排序#include<stdio.h>#include<stdlib.h>#define L 20int cmp(const void *a, const void *b){return *(double *)a > *(double *)b? 1 : -1;}int main (){double a[L] = {0.1, 0.11, 1.1, 1.5, 1.8, 1.51, 2.5, 2.9, 1.3, 0.8, 15.5, 7.9, 8.5, 8.51, 8.6, 3, 1.41, 1.11, 1.51, 2};qsort(a, L, sizeof(double), cmp);for (int i = 0; i < L; i++){printf("%.2lf\n", a[i]);}}3.char类型数组排序#include<stdio.h>#include<stdlib.h>#define L 20int cmp(const void *a, const void *b){return *(char *)a - *(char *)b;}int main (){char a[L] = {'q', 'w', 'r', 'h', 'a', 'v', 'g', 'e', 'b', 'l','o', 'p', 'u', 'y', 't', 'c', 'x', 'i', 'z', 's'};qsort(a, L, sizeof(char), cmp);for (int i = 0; i < L; i++){printf("%c ", a[i]);}}4.字符串进⾏排序按⾸字母排序#include<stdio.h>#include<stdlib.h>#define L 10#define K 10int cmp(const void *a, const void *b){return *(char *)a - *(char *)b;}int main (){char a[L][K] = {"rbsgc","jcghse","gfgd","abbbs","bbbvs","cbfgfe","ofggd","mbgcv",};qsort(a, L, sizeof(char) * K, cmp);for (int i = 0; i < L; i++){printf("%s\n", a[i]);}}按长度排序#include<stdio.h>#include<stdlib.h>#include<string.h>#define L 10#define K 10int cmp(const void *a, const void *b){return strlen((char *)a) > strlen((char *)b) ? 1 : -1; }int main (){char a[L][K] = {"rbsgc","jcghse","gfgd","abbbs","bbbvs","cbfgfe","drgafg" ,"ewqgrta","ofggd","mbgcv",};qsort(a, L, sizeof(char) * K, cmp);for (int i = 0; i < L; i++){printf("%s\n", a[i]);}}按字典顺序#include<stdio.h>#include<stdlib.h>#include<string.h>#define L 10#define K 10int cmp(const void *a, const void *b){return strcmp((char * )a, (char *)b);}int main (){char a[L][K] = {"rbsgc","jcghse","gfgd","abbbs","bbbvs","cbfgfe","drgafg" ,"ewqgrta","ofggd","mbgcv",};qsort(a, L, sizeof(char) * K, cmp);for (int i = 0; i < L; i++){printf("%s\n", a[i]);}}5.结构体⼆级排序#include<stdio.h>#include<stdlib.h>#include<string.h>#define L 10typedef struct node {double first;int numb;}node;int cmp(const void *a, const void *b){if((* (node *)a).first != ( * (node *)b).first)return ( * (node * )a).first > ( * (node * )b).first ? 1 : -1; else return (* (node * )a).numb -( * (node * )b).numb; }int main (){node arr[L] = {1.0, 1,2.0, 2,1.1, 3,2.1, 4,3.5, 5,1.0, 6,1.1, 7,5.1, 8,5.0, 9,3.6, 10,};qsort(arr, L, sizeof(node), cmp);for (int i = 0; i < L; i++){printf("%.2lf %d\n", arr[i].first, arr[i].numb);}}。
qsort用法
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的例⼦就是说明这个问题的)。
qsort函数用法
举个简单点的例子来说:
inta=10;
int&b=a;
这样b就和a完全一样啦
这个东东是相当好用的,比如我们想调用f(a,b,c)函数,并且希望对abc的值进行改变的话
。在c里面ms只可以用指针来实现。
但是用指针比较麻烦
有&这个符号就好用啦。
深入分析qsort库函数收藏
正如大家所知道的,快速排序算法是现在作为数据排序中很常用的算法,它集成在ANSI C的函数库中。我们经常使用快速排序,就是调用qsort函数,那么qsort函数里面到底是怎么实现的呢?我们现在就来看一看。
{
intn,m,i,j;
while(1)
{
scanf("%d%d",&n,&m);
if(n==0&&m==0) break;
for(i=0;i<n;i++)
{
scanf("%s",a[i]);
}
qsort((void*)a,n,sizeof(a[0]),cmp);
for(i=0;i<n;i++)
printf("%s\n",a[i]);
#include <stdlib.h>
#include <search.h>
#include <internal.h>
/*加快运行速度的优化选项*/
#pragmaoptimize("t", on)
/*函数原型*/
staticvoid __cdeclshortsort(char *lo, char *hi,size_twidth,
qsort和sort的区别
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);七、计算几何中求凸包的cmpint 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函数参数可以直接是参与比较的引用类型。
qsort函数常见用法v1.1
qsort函数常见用法由于之前共享的qsort的资料和网上流传的一些关于qsort的资料确实有些问题,故根据个人的经历现将qsort的用法按我自己的理解整理了一下。
第一次写“学术”性质的东西,写得不好的地方还望大家多多包涵。
另外此篇文章系入门材料,留作以后的新人作为参考,各位老手可以跳过。
一、qsort函数简介qsort的函数原型是void __cdecl qsort ( void *base, size_t num, size_t width, int (__cdecl *cmp)(const void *, const void* ) ),所要包含的头文件为stdlib.h。
其中base是排序的一个集合数组,num是你需要进行排序的数组段的长度,width是你希望排序的数组元素的大小(一般用sizeof()来表示),cmp是一个比较函数,需要用户自己编写。
正是因为cmp的编写权交给了用户自己,因而它所能实现的功能便变得丰富起来。
下附一段简单的qsort的代码,用以辅助说明qsort的运行原理。
#include<stdio.h>#include<stdlib.h>#define SIZE 1000int a[SIZE];int cmp(const void *_p,const void *_q){int *p=(int *)_p;int *q=(int *)_q;return *p-*q;}int main(){int i=0,j;while(scanf("%d",&a[i])==1)i++;qsort(a,i,sizeof(a[0]),cmp);for(j=0;j<i;j++)printf("%d\n",a[j]);//system("pause");return 0;}上面的代码实现了将输入的整数进行升序排列并输出的功能。
C语言qsort用法
C语言qsort用法qsort用法 C++sort的前身<qsort函数包含在<stdlib.h>的头文件里,strcmp包含在<string.h>的头文件里>一、对int类型数组排序int num[100];Sample: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];Sample:int cmp( const void *a , const void *b ){return *(char *)a - *(char *)b;}qsort(word,100,sizeof(word[0]),cmp);三、对double类型数组排序 !!!!!!!!!!!!(特别要注意)double arry[100];int cmp( const void *a , const void *b ){return *(double *)a > *(double *)b ? 1 : -1;}qsort(arry,100,sizeof(arry[0]),cmp);四、对结构体一级排序struct In{double data;int other;}s[100];//按照data的值从小到大将结构体排序,关于结构体内的排序关键数据data的类型可以很多种int cmp( const void *a ,const void *b){struct In *c=(In *)a;struct In *d=(In *)b;return c->data > d->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 ){struct In *c = ( In *)a;struct In *d = (In *)b;return strcmp( c->str , d->str );}qsort(s,100,sizeof(s[0]),cmp);七、计算几何中求凸包的cmpint 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;}#include <stdio.h>#include <stdlib.h>int comp(const void *, const void *);int main(int argc, char *argv[]){int i;int array[] = {6, 8, 2, 9, 1, 0};qsort(array, 6, sizeof(int), comp);for (i = 0; i < 6; i ++) {printf("%d\t", array[i]);}printf("\n");return 0;}int comp(const void *p, const void *q) {return (*(int *)p - *(int *)q);}。
C++排序函数sort(),qsort()的用法
C++排序函数sort(),qsort()的⽤法想起来⾃⼰天天排序排序,冒泡啊,⼆分查找啊,结果在STL中就⾃带了排序函数sort,qsort,总算把⾃⼰解脱了~所以⾃⼰总结了⼀下,⾸先看sort函数见下表:sort对给定区间所有元素进⾏排序stable_sort对给定区间所有元素进⾏稳定排序partial_sort对给定区间所有元素部分排序partial_sort_copy对给定区间复制并排序nth_element找出给定区间的某个位置对应的元素is_sorted判断⼀个区间是否已经排好序partition使得符合某个条件的元素放在前⾯stable_partition相对稳定的使得符合某个条件的元素放在前⾯要使⽤此函数只需⽤#include <algorithm> sort即可使⽤,语法描述为:sort(begin,end),表⽰⼀个范围,例如:int _tmain(int argc, _TCHAR* argv[]){int a[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按升序排序,说到这⾥可能就有⼈会问怎么样⽤它降序排列呢?这就是下⼀个讨论的内容.⼀种是⾃⼰编写⼀个⽐较函数来实现,接着调⽤三个参数的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[]){int a[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)更进⼀步,让这种操作更加能适应变化。
sort语句的用法
sort语句的用法sort语句是许多编程语言中常用的排序工具,用于对一组数据进行排序。
本文将介绍sort语句的基本用法、参数和示例,帮助读者了解sort语句在各种编程环境中的应用。
sort语句通常用于对一组数字、字符串或对象进行排序。
在大多数编程语言中,sort语句需要接受一个或多个要排序的变量或数组作为参数,并返回一个新的排序后的数组。
sort语句通常会按照升序(从小到大)或降序(从大到小)对数据进行排序。
sort语句的参数因编程语言而异,但通常包括以下几种:1.排序方式:指定升序或降序排序。
2.排序规则:指定排序的规则,如字符串的字典序、数字的大小等。
3.排序依据:指定排序的字段或变量,如根据姓名、年龄或价格进行排序。
4.排序结果:指定排序后的结果数组的名称或变量名。
以下是一些sort语句的示例,演示了其在不同编程环境中的应用:1.Python语言:```pythonnumbers=[5,2,9,1,7]sorted_numbers=sorted(numbers)print(sorted_numbers)#输出:[1,2,5,7,9]```2.JavaScript语言:```javascriptletnumbers=[5,2,9,1,7];letsortedNumbers=numbers.sort((a,b)=>a-b);console.log(sortedNumbers);//输出:[1,2,5,7,9]```3.C++语言:```c++#include<algorithm>#include<vector>#include<iostream>usingnamespacestd;intmain(){vector<int>numbers={5,2,9,1,7};sort(numbers.begin(),numbers.end());for(intnum:numbers){cout<<num<<"";//输出:[12579]}return0;}```这些示例展示了sort语句在Python、JavaScript和C++中的基本用法。
qsort函数
qsort函数qsort函数是C语言中常用的排序算法之一,它属于快速排序算法,它可以很快地对数组进行排序。
qsort函数的历史可以追溯到1960年代的“快速排序”,当时由爱德华诺夫斯基(EdwardNofsk)提出。
它的原理是,首先在数组中选取一个基准值,然后把所有小于等于基准值的元素放在基准值左边,把所有大于等于基准值的元素放在基准值右边,最后递归地把每个子数组再排序,直到所有的元素都排序完毕。
qsort函数的实现非常简单,只需要定义一个带有四个参数的函数qsort,第一个参数是要排序的数组,第二个参数是数组的元素个数,第三个参数是元素的大小,最后一个参数是用于比较两个元素值的函数。
在实现qsort函数过程中,可以使用递归思想,每次使用一个基准值,把数组中元素分成两部分,分别对其中的元素进行排序,最终实现快速排序。
qsort函数的优势在于它简单易懂,而且在空间复杂度上也比较低,可以达到O(logn),它是一个时间复杂度较低的排序算法,可以实现大量数据的排序,是许多编程语言的核心函数之一,广泛应用于各种应用场景,如搜索引擎、系统工具、数据可视化等。
qsort函数的应用也是十分普遍的,它可以用于排序数组,也可以用于排序链表,同时支持比较函数的自定义,可以根据业务需求定制不同的排序方式,同时还可以作为数据校验的处理过程,可以用来检索并对大量数据进行排序。
qsort函数也有一些缺点,因为在实现快速排序时,使用递归思想,有可能造成堆栈溢出,另外它没有最优比较结构,如果数据集中在一个范围值的话,它的排序效率有可能会变得很低,因此使用者需要仔细分析和调配,获取最佳性能。
qsort函数是当今C语言常用的排序算法之一,它可以实现快速排序,可以快速地对数组进行排序,而且它还支持比较函数的自定义,可以根据业务需求实现不同的排序方式。
但是也有其缺点,需要注意并适度使用,以达到最佳性能。
c qsort函数用法 -回复
c qsort函数用法-回复Qsort函数是C语言中的一个标准库函数,用于对数组进行排序。
它的用法十分灵活,可以根据不同的情况和需求来自定义排序规则。
本文将一步一步回答有关qsort函数的用法以及如何自定义排序规则的问题。
一、什么是qsort函数?Qsort函数是C语言标准库中的一个排序函数,它可以对数组进行排序。
它的原型定义在头文件stdlib.h中,函数的完整声明如下:void qsort(void *base, size_t nmemb, size_t size,int(*compar)(const void *, const void *));二、参数解析1. base:需要排序的数组的首地址。
2. nmemb:数组中元素的个数。
3. size:每个元素的大小,单位为字节。
4. compar:比较函数的指针,用于定义排序的规则。
三、默认排序规则如果没有提供自定义的比较函数,qsort函数将按照默认的升序排序规则对数组进行排序。
默认的比较函数使用元素的大小来进行比较。
需要特别注意的是,数组中的元素必须具有可比较性,即元素类型必须支持'<'和'>'操作符。
四、自定义比较函数对于某些特殊情况下的排序需求,我们可能需要使用自定义的比较函数来定义排序规则。
比较函数的原型定义如下:int compar(const void *a, const void *b);比较函数必须返回一个整数值,用于指示a和b的大小关系。
返回值的语义如下:- 如果返回值小于0,则表示a小于b。
- 如果返回值等于0,则表示a等于b。
- 如果返回值大于0,则表示a大于b。
五、自定义排序规则的示例假设我们有一个存储了学生信息的结构体数组,每个学生信息包括姓名和年龄。
我们想要按照年龄从小到大的顺序对学生信息进行排序,可以使用qsort函数配合自定义的比较函数来实现。
首先,我们需要定义一个比较函数:int compare_age(const void *a, const void *b) {Student *student_a = (Student *)a;Student *student_b = (Student *)b;return student_a->age - student_b->age;接下来,我们可以调用qsort函数进行排序:qsort(students, num_students, sizeof(Student), compare_age);在上面的代码中,students是存储学生信息的结构体数组的首地址,num_students是数组中学生信息的个数,sizeof(Student)是每个学生信息的大小。
sort用法
sort⽤法1、sort(a,a+7) a表⽰要排序的⾸地址,数组名代表的就是⼀个数组的⾸地址,7是要排序的元素个数1int a[] = { 8,2,9,1,0,5,6 };2 sort(a, a + 7);3for (int i = 0; i < 7; i++) {4 cout << a[i] << "";//0 1 256 8 95 }2、sort(a+1,a+5) 表⽰将[a+1,a+5)区间中的元素排序1int a[] = { 8,2,9,1,0,5,6 };2 sort(a+1, a + 5);3for (int i = 0; i < 7; i++) {4 cout << a[i] << "";//8 0 1 2 95 65 }3、sort(a,a+7,greater<int>()) 按从⼤到⼩的顺序排列 sort默认是按照从⼩到⼤的顺序排列的,greater表⽰更⼤的意思,即更⼤的数排在前⾯,<int>表⽰要排序的数组中的元素是int类型的1int a[] = { 8,2,9,1,0,5,6 };2 sort(a, a + 7,greater<int>());3for (int i = 0; i < 7; i++) {4 cout << a[i] << "";//9 8 65 2 1 05 }4、定义⼀个⽐较⼤⼩的函数cmp1 #include<iostream>2 #include<algorithm>3using namespace std;4bool cmp(int x, int y) {5return x > y;//表⽰⼤的排在前⾯6 }7int main() {8int a[] = { 8,2,9,1,0,5,6 };9 sort(a, a + 7,cmp);10for (int i = 0; i < 7; i++) {11 cout << a[i] << "";//9 8 6 5 2 1 012 }1314return0;15 }5、⽐较结构体⼤⼩⽅法⼀:1 #include<iostream>2 #include<algorithm>3using namespace std;4struct A {5int x;6int y;7 };8bool cmp(A m, A n) {9return m.y> n.y;//y更⼤的排在前⾯10 }11int main() {12 A a[] = { {1,3},{4,1},{5,9},{1,6},{8,2} };13 sort(a, a + 5,cmp);14for (int i = 0; i < 5; i++) {15 cout << "(" << a[i].x << "," << a[i].y << ")" << "";16//(5,9) (1,6) (1,3) (8,2) (4,1)17 }1819return0;20 }⽅法⼆:1 #include<iostream>2 #include<algorithm>3using namespace std;4struct A {5int x;6int y;7bool operator<(const A &s)const {8return y > s.y;//y⼤的在此结构体中定义的‘<’的左边,sort中<左边的在前⾯9 }10 };11int main() {12 A a[] = { {1,3},{4,1},{5,9},{1,6},{8,2} };13 sort(a, a + 5);14for (int i = 0; i < 5; i++) {15 cout << "(" << a[i].x << "," << a[i].y << ")" << "";16//(5,9) (1,6) (1,3) (8,2) (4,1)17 }1819return0;20 }。
sort排序的用法
sort排序的用法
sort排序是一种常用的排序方法,它可以按照指定的规则对列
表或数组进行排序。
sort排序的用法非常简单,只需要将要排序的
列表或数组作为参数传递给sort函数即可。
sort函数可以接受一个可选的比较函数作为参数,用于指定排
序的规则。
如果不指定比较函数,默认情况下,sort函数会将列表
或数组元素按照字母顺序进行排序。
比较函数通常包含两个参数,用于比较列表或数组中的两个元素。
如果第一个元素小于第二个元素,则比较函数返回一个负数;如果第一个元素大于第二个元素,则返回一个正数;如果两个元素相等,则返回0。
sort排序的时间复杂度通常为O(nlogn),因此它是一种非常高
效的排序方法。
无论是进行大规模数据处理还是排序小型数据集,sort排序都是一种非常实用的工具。
- 1 -。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
qsort和sort的区别First 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 得自己写。
Second sortsort 使用时得注明: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项取样,更完全的三路划分算法,更细致的对不同数组大小采用不同方法排序。
Third 区别:sort是qsort的升级版,如果能用sort尽量用sort,使用也比较简单,不像qsort还得自己去写cmp 函数,只要注明使用的库函数就可以使用,参数只有两个(如果是普通用法)头指针和尾指针;默认sort排序后是升序,如果想让他降序排列,可以使用自己编的cmp函数bool compare(int a,int b) /////注意:此处的返回值是bool类型,和qsort不一样!{return a>b; //降序排列,如果改为return a<b,则为升序}sort(*a,*b,cmp);#include <algorithm>#include <cstdio>#include <cstring>using namespace std;class Node {public:char a[100];}all[10];bool cmp(const Node a,const Node b){return 0>=strcmp(a.a,b.a);}int main(){for(int i=0;i<10;i++){scanf("%s",all[i].a);}sort(all,all+10,cmp);return 0;}//自己写的例子#include<iostream>using namespace std;//定义个结构体typedef struct{char ss[35];string s[39];}node;//定义个比较函数,sort里排序要用到bool cmp(const node &a,const node &b) {return strcmp(a.ss,b.ss)<=0;}//主函数int main(){node a[10];for(int i=0;i<4;i++)cin>>a[i].ss;sort(a,a+4,cmp);for(int i=0;i<4;i++)cout<<a[i].ss<<endl;return 0;}//用string和sort不是更简单?就不写注视了,估计自己以后也能看明白吧#include<iostream>using namespace std;int main(){string ss[10];for(int i=0;i<4;i++)cin>>ss[i];sort(ss,ss+4);for(int i=0;i<4;i++)cout<<ss[i]<<endl;return 0;}//如果要给string内的字符串排序//可以这样#include<iostream>using namespace std;int main(){string ss;cin>>ss;sort(ss.begin(),ss.end());//完活牛逼啊!不用自己写比较函数啦!cout<<ss[i]<<endl;return 0;}。