C函数qsort的简介和用法,新手入门

合集下载

c qsort原函数 -回复

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函数进行排序。

qsort函数在c语言中的含义

qsort函数在c语言中的含义

一、概述qsort函数是C语言标准库中的一个用于排序数组的函数。

它可以根据用户自定义的比较函数对数组进行排序,是C语言中非常常用的排序函数之一。

二、函数原型qsort函数的函数原型如下:void qsort(void *base, size_t nmemb, size_t size, int (par)(const void *, const void *));其中,参数说明如下:1. base:指向要排序的数组的指针。

2. nmemb:数组中元素的数量。

3. size:数组中每个元素的大小。

4.par:比较函数的指针,用于指定排序时的比较规则。

三、比较函数qsort函数的核心在于比较函数,比较函数的定义如下:intpar(const void* a, const void* b);比较函数接受两个参数a和b,分别指向待比较的数组元素。

比较函数需要根据实际需求编写,它应该按照排序的规则来比较a和b,并返回结果。

比较函数返回值的含义为:- 若a应排在b之前,则返回负值;- 若a应排在b之后,则返回正值;- 若a与b相等,则返回0。

四、函数用法使用qsort函数进行排序的一般步骤如下:1. 定义比较函par,根据排序需求编写比较规则。

2. 调用qsort函数进行排序,示例代码如下:```cintpare(const void* a, const void* b) {return *(int*)a - *(int*)b;}int m本人n() {int arr[] = {4, 2, 8, 5, 1};int len = sizeof(arr) / sizeof(arr[0]);qsort(arr, len, sizeof(int),pare);return 0;}```这段示例代码演示了如何使用qsort函数对整型数组进行升序排序。

五、注意事项在使用qsort函数时,需要注意以下几点:1. 比较函数的正确性和效率会直接影响排序结果和性能,因此需要仔细编写和测试比较函数。

c语言qsort结构题

c语言qsort结构题

c语言qsort结构题
对于C语言中的qsort函数结构题,我们需要首先了解qsort 函数的基本用法和参数结构。

qsort函数是C标准库中的函数,用于对数组进行快速排序。

它的基本结构如下:
c.
void qsort(void base, size_t nitems, size_t size, int (compar)(const void , const void))。

其中,参数解释如下:
base,指向要排序的数组的指针。

nitems,数组中的元素个数。

size,每个元素的大小,以字节为单位。

compar,指向比较函数的指针,用于确定元素的顺序。

在解决qsort结构题时,我们通常需要自定义比较函数,以便根据特定的排序规则来排序数组元素。

比较函数的结构如下:
c.
int compare(const void a, const void b) {。

// 比较逻辑。

}。

在比较函数中,我们需要根据题目要求编写适当的比较逻辑,比如按照元素大小升序或降序排列,或者按照自定义的规则进行排序。

除了编写比较函数,我们还需要考虑如何使用qsort函数对特定类型的数组进行排序。

在处理结构体数组时,我们可以借助指针来访问结构体的成员,并在比较函数中编写相应的比较逻辑。

总的来说,解决qsort结构题需要我们熟练掌握qsort函数的基本用法和比较函数的编写,以及灵活运用这些知识来解决特定的排序问题。

同时,对于结构体数组的排序,我们需要注意如何访问
结构体成员并进行比较。

希望这些内容能够帮助你更好地理解和解决C语言中的qsort结构题。

qsort函数的用法

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函数只能对内存中的数据进行排序,不能对文件中的数据进行排序。

qsort函数使用方法总结(详细全面+代码)

qsort函数使用方法总结(详细全面+代码)

qsort函数使⽤⽅法总结(详细全⾯+代码)⽬录qsort函数原型void qsort(void *base,size_t nmemb,size_t size,int (*compar)(const void *, const void *)); 头⽂件:<stdlib.h> 函数功能:qsort()函数的功能是对数组进⾏排序,数组有nmemb个元素,每个元素⼤⼩为size。

参数base - base指向数组的起始地址,通常该位置传⼊的是⼀个数组名 参数nmemb - nmemb表⽰该数组的元素个数 参数size - size表⽰该数组中每个元素的⼤⼩(字节数) 参数(*compar)(const void *, const void *) - 此为指向⽐较函数的函数指针,决定了排序的顺序。

函数返回值:⽆ 注意:如果两个元素的值是相同的,那么它们的前后顺序是不确定的。

也就是说qsort()是⼀个不稳定的排序算法。

compar参数 compar参数是qsort函数排序的核⼼内容,它指向⼀个⽐较两个元素的函数,注意两个形参必须是const void *型,同时在调⽤compar 函数(compar 实质为函数指针,这⾥称它所指向的函数也为compar)时,传⼊的实参也必须转换成const void *型。

在compar函数内部会将const void *型转换成实际类型,见下⽂。

int compar(const void *p1, const void *p2); 如果compar返回值⼩于0(< 0),那么p1所指向元素会被排在p2所指向元素的前⾯ 如果compar返回值等于0(= 0),那么p1所指向元素与p2所指向元素的顺序不确定 如果compar返回值⼤于0(> 0),那么p1所指向元素会被排在p2所指向元素的后⾯ 因此,如果想让qsort()进⾏从⼩到⼤(升序)排序,那么⼀个通⽤的compar函数可以写成这样:int compare (const void * a, const void * b){if ( *(MyType*)a < *(MyType*)b ) return -1;if ( *(MyType*)a == *(MyType*)b ) return 0;if ( *(MyType*)a > *(MyType*)b ) return 1;} 注意:你要将MyType换成实际数组元素的类型。

C语言qsort函数的简介和用法,保证简洁明了!

C语言qsort函数的简介和用法,保证简洁明了!
• //按照结构体中字符串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()定义了两个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函数的简单用法

关于C语⾔qsort函数的简单⽤法qsort()括号⾥⾯有4个参数第⼀个参数是将要排序的数组名array第⼆个参数是将要排序的数量n第三个参数是每个要排序的参数的⼤⼩sizeof(array[0])第四个参数是⾃⼰写⼀个⽐较函数cmp前⾯三个参数⽐较通俗易懂,主要是最后⼀个cmp函数重写1:数字的qsort排序a:从⼤到⼩排序#include<stdlib.h> //头⽂件int cmp ( const void *a , const void *b ) //排序函数{return *(int *)b - *(int *)a;}qsort(s,n,sizeof(s[0]),cmp); //调⽤函数b:从⼩到⼤排序#include<stdlib.h>int cmp ( const void *a , const void *b ){return *(int *)a - *(int *)b;}qsort(s,n,sizeof(s[0]),cmp);>七种qsort排序⽅法<排序都是采⽤的从⼩到⼤排序>⼀、对int类型数组排序int num[100];int cmp ( const void *a , const void *b ){return *(int *)a - *(int *)b;}⼆、对char类型数组排序(同int类型)int cmp( const void *a , const void *b ){return *(char *)a - *(char *)b;}三、对double类型数组排序int cmp( const void *a , const void *b ){return *(double *)a > *(double *)b ? 1 : -1;//注意这⾥⽤的三⽬运算符}四、对结构体⼀级排序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; //这⾥切记这种写法,如果你利⽤减法规定顺序,patOj会出现问题,亲测}五、对结构体⼆级排序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;}六、对结构体三级排序(都是从⼩到⼤)#include<stdlib.h>typedef struct item{int num,length,width;};int comp(const void *p1,const void *p2){struct item *c=(item*)p1;struct item *d=(item*)p2;if(c->num!=d->num){return d->num<c->num?1:-1;}else if(c->length!=d->length&&c->num==d->num)return d->length<c->length?1:-1;else return d->width<c->width?1:-1;}七、对字符串进⾏排序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 );}⼋、计算⼏何中求凸包的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) return1;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)) //如果在⼀条直线上,则把远的放在前⾯return1;else return -1;}。

c语言 函数中使用嵌套qsort函数

c语言 函数中使用嵌套qsort函数

C语言中函数中使用嵌套qsort函数1. qsort函数简介qsort是C语言标准库中的一个非常实用的排序函数,用于对数组进行排序。

该函数的主要特点是它使用了快速排序算法,并允许用户自定义比较函数来决定排序的顺序。

qsort函数的原型如下:void qsort(void*base, size_t nitems, size_t size, int (*compar)(const void*, const void*));其中:base是指向要排序的数组的指针。

nitems是数组中的元素个数。

size是数组中每个元素的大小(以字节为单位)。

compar是一个比较函数,用于决定排序的顺序。

2. 嵌套qsort函数的使用场景在某些情况下,我们需要对嵌套数组或者结构体数组进行排序。

这时,我们可以使用嵌套的qsort函数来达到目的。

嵌套的qsort函数可以让我们对数组中的每个元素进行排序,从而实现多维度的排序。

3. 如何实现嵌套的qsort函数实现嵌套的qsort函数,需要我们提供两个比较函数。

外层qsort函数的比较函数决定了外层元素的排序顺序,而内层qsort函数的比较函数决定了内层元素的排序顺序。

在比较函数中,我们可以使用指针参数来访问嵌套的数组或结构体。

4. 示例代码下面是一个使用嵌套qsort函数的示例代码,用于对二维整数数组进行排序:#include<stdio.h>#include<stdlib.h>// 比较函数1,用于决定外层数组元素的排序顺序int compare1(const void*a, const void*b) {int*p1 = (int*)a;int*p2 = (int*)b;return*p1 -*p2; // 根据外层元素的值进行排序}// 比较函数2,用于决定内层数组元素的排序顺序int compare2(const void*a, const void*b) {int*p1 = (int*)a;int*p2 = (int*)b;return*p1 -*p2; // 根据内层元素的值进行排序}int main() {int arr[6][3] = {{5, 2, 9}, {1, 5, 6}, {7, 3, 8}, {4, 0, 2}, {3, 8, 1}, {0, 6, 4}};int n =sizeof(arr) /sizeof(arr[0]); // 外层数组元素个数int size =sizeof(arr[0]) /sizeof(int); // 内层数组元素个数qsort(arr, n, size *sizeof(int), compare1); // 外层排序,使用compare1比较函数for (int i =0; i < n; i++) { // 输出外层排序后的结果qsort(arr[i], size, sizeof(int), compare2); // 内层排序,使用compare2比较函数for (int j =0; j < size; j++) { // 输出内层排序后的结果printf("%d ", arr[i][j]); // 输出内层元素的值}printf("\n"); // 每行输出一个内层数组的结果}return0;}在上面的示例代码中,我们首先定义了两个比较函数compare1和compare2,分别用于决定外层和内层的排序顺序。

C语言讲义——库函数排序qsort

C语言讲义——库函数排序qsort
qsort(arr, 6, sizeof(int), compare); // 输出结果 int i=0; for(; i<sizeof(arr)/sizeof(int); i++) { printf("%d ", arr[i]); }
return pare使用 int compare(const void *value1, const void *value2) { // 升序 return (*(int*)value1 - *(int*)value2); }
int main(int argc, char *argv[]) { int arr[]= {-1,5,6,2,7,9};
参数
base -- 这就是指针的数组的第一个元素进行排序 nitems -- 这是由基部指向的数组中的元素数目 size -- 这是在数组中的每个元素的大小(以字节为单位) compar -- 这个函数比较两个元素 返回值:不返回任何值 缺点:对于有多个重复值的数组来说,效率较低不稳定。
#include <stdio.h> #include <stdlib.h>
博客园 用户登录 代码改变世界 密码登录 短信登录 忘记登录用户名 忘记密码 记住我 登录 第三方登录/注册 没有账户, 立即注册
C语言讲义 ——库函数排序 qsort
qsort函数在在stdlib.h中。 函数原型
void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*))

qsort用法

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()函数的使用与注意

qsort()函数的使用与注意

总结一下qsort()函数的使用与注意一、简介原型: void qsort(void *base, int nelem, int width, int (*fcmp)(const void *,const void *));功能: 使用快速排序例程进行排序说明:qsort函数是ANSI C标准中提供的,其声明在stdlib.h文件中,是根据二分法写的,其时间复杂度为n*log(n)。

其中第一个参数是参与排序的数组名(或者也可以理解成开始排序的地址,因为可以写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,其他的依次类推,后面有例子来说明对不同的类型如何进行排序.下面举例:No.2.最常见的,对int数组排序#include stdio.h#include string.h#include stdlib.hint 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;in;i++) scanf("%d",s[i]); qsort(s,n,sizeof(s[0]),cmp); for(i=0;in;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.hdouble s[1000];int i,n;int cmp(const void * a, const void * b){return((*(double*)a-*(double*)b0)?1:-1);}int main(){scanf("%d",n);for(i=0;in;i++) scanf("%lf",s[i]); qsort(s,n,sizeof(s[0]),cmp); for(i=0;in;i++)printf("%lf ",s[i]); return(0);}答案补充因为qsort函数中的参数cmp(也可以取另外名字,反正就是最后一个参数)一定要是int cmp(const void *a,const void *b)这样定义的(系统指定我也没办法).而void*类型是不能直接转换的,所以先(int*)a的意思是将void* a转为int *a,而*((int*)a)则是取a的值,相当于int* a后的*a二、使用举例(MinGW5测试通过)1、对一维数组排序:2、对字符串排序:3、按结构体中某个关键字排序(对结构体一级排序):]:。

C语言qsort

C语言qsort

C语⾔qsortC/C++中有⼀个快速排序的标准库函数 qsort ,在stdlib.h 中声明,其原型为:void qsort(void *base, int nelem, unsigned int width, int ( * pfCompare)( const void *, const void *)); 使⽤该函数,可以对任何类型的⼀维数组排序。

该函数参数中,base 是待排序数组的起始地址,nelem 是待排序数组的元素个数,width 是待排序数组的每个元素的⼤⼩(以字节为单位),最后⼀个参数 pfCompare 是⼀个函数指针,它指向⼀个“⽐较函数”。

修改排序数组排序起始基地址和带排序元素个数可以实现数组部分排序。

qsort 函数的⽤法规定,“⽐较函数”的原型应是:int 函数名(const void * elem1, const void * elem2);该函数的两个参数,elem1 和elem2,指向待⽐较的两个元素。

也就是说, * elem1 和* elem2 就是待⽐较的两个元素。

该函数必须具有以下⾏为: 1) 如果 * elem1 应该排在 * elem2 前⾯,则函数返回值是负整数(任何负整数都⾏)。

2) 如果 * elem1 和* elem2 哪个排在前⾯都⾏,那么函数返回0 3) 如果 * elem1 应该排在 * elem2 后⾯,则函数返回值是正整数(任何正整数都⾏)。

例如:1 #include <iostream>2 #include <stdio.h>3 #include <stdlib.h>45using namespace std;67int compare(const void *a, const void *b)8 {9int *pa = (int*)a;10int *pb = (int*)b;11return (*pa )- (*pb); //从⼩到⼤排序12 }1314void main()15 {16int a[10] = {5, 6, 4, 3, 7, 0 ,8, 9, 2, 1};17 qsort(a, 10, sizeof(int), compare);18for (int i = 0; i < 10; i++)19 cout << a[i] << "" << endl;20 }View Code如果要从⼤到⼩排列,只需要将⽐较函数中return (*pa )- (*pb); 改为return (*pb )- (*pa); 即可。

qsort函数详解

qsort函数详解

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 要求提供一个比较函数,是为了做到通用性更好一点。

比如你不仅仅的是要排序一个数字而已,可能你要用来排序几个数字,比如有一个结构struct num{int a;int b;};然后我有一个num 类型的数组,num dddd[100];我想给dddd这个数组排序,那怎么办?我想让 a +b 最大的num元素排在数组的最前面,那又怎么办?这都可以通过定义比较函数来做到的。

比较函数的作用就是给qsort指明元素的大小是怎么比较的。

像这样的比较函数inline int MyCmp(const void* a, const void* b)都是有两个元素作为参数,返回一个int值,如果比较函数返回大于0,qsort 就认为a>b , 如果比较函数返回等于0 qsort就认为a 和b 这两个元素相等,返回小于零qsort就认为a<b 。

C语言 快排qsort简单小结

C语言 快排qsort简单小结

快排qsort简单小结1。

qsort, 即快速排序, 包含在<cstdlib>或<stdlib.h>中,函数有四个参数, 没有返回值下面是一个典型的写法:qsort(s,n,sizeof(s[0]),cmp);其中, s是需要排序的数组名, 也可以理解成开始地址,因为你如果只需要对数组的部分排序的话, s可以写成&s的形式的第二个参数n是参与排序的元素个数, 第三个参数是单个元素的大小,通常我们用sizeof()来获取大小, 因为它足够放心绝对无毒^_^而且很多时候我们需要对结构体进行排序的你很难把握它的大小的~最后一个参数, 也就是我今天对着愣了很久的东东了什么鸟东西嘛,搞得忒神密-_-!!!!cmp是一个比较函数不过这不是系统定义好的函数而是需要自己手动写的也就是说你可以把它叫做abcd或是rubbish什么因为是比较函数我比较习惯用cmpcmp的典型定义是int cmp(const void *a,const void *b);其中返回值必须是int,两个参数的类型必须都是const void *, 这样你可以对他进行强制转换成任何其他类型有点想C#中的box 哈~~假设是对int排序的话,如果是升序,那么就是如果a比b大cmp返回一个正值,小则负值,相等返回0当然当你对具体的数组进行排序的话 cmp里面就要做具体的处2。

七种常见排法!!!一、对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);七、计算几何中求凸包的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;}冒泡排序:for (j=1;j<=n;j++){for (i=1;i<=n-j;i++){if (c[i]<c[i+1]){p=c[i];c[i]=c[i+1];c[i+1]=p;p=d[i];d[i]=d[i+1];d[i+1]=p;p=e[i];e[i]=e[i+1];e[i+1]=p;}}}。

qsort及其用法

qsort及其用法

qsort及其用法一、函数原型void qsort(void *base, size_t num, size_t width, int (__cdecl *compare )(const void *elem1, const void *elem2 ) );用法: void qsort(void *base,int nelem,int width,int (*fcmp)(const void *,const void *));各参数:1 待排序数组首地址2 数组中待排序元素数量3 各元素的占用空间大小4 指向函数的指针,用于确定排序的顺序(指定排序规则)int a[n];qsort(a,n,sizeof(int),comp); //从小到大排序int comp(const void* a,const void *b){int *x=(int*)a;int *y=(int*)b;return *x-*y; //如果a>b返回正数,如果a<b,返回负数,相等返回0;}二、qsort用法1、对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);2、对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);3、对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);4、对结构体一级排序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);5、对结构体二级排序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);6、对字符串进行排序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);7、计算几何中求凸包的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;}qsort()是c程序库stdlib.h中的一个函数,需要比较函数完成排序;sort()是STL中的标准算法。

qsort函数常见用法v1.1

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用法

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);}。

qsort用法--完整版(解释了cmp)【转】

qsort用法--完整版(解释了cmp)【转】

qsort⽤法--完整版(解释了cmp)【转】原⽂地址:⽤qsort快两年的时候了,却⼀直没有真正弄懂cmp函数的返回值1,-1,0的函数. 今天在做凸包时,郁闷了....所以请教了snoopy,终于弄懂了cmp返回值的意识:int cmp(const void *a, const void *b)返回正数就是说 cmp 传⼊参数第⼀个要放在第⼆个后⾯, 负数就是传⼊参数第⼀个要放第⼆个前⾯, 如果是 0, 那就⽆所谓谁前谁后..下⾯就把snoopy曾经写的介绍qsort的完整版贴出来好了,我想有与我⼀样经历的朋友也可以弄懂的:很多⼈问这个东西.我以前也看了好久,今天翻到以前学快排的时候写的练习code,基本上能覆盖绝⼤部分⽤法了.⾥⾯有很多地⽅没判断相等的情况,按道理来说相等情况下应该返回0的,这个请看代码的时候注意.我尽量保证代码不出错了.下⾯的这些说明和问题都是个⼈原创,没查什么资料,所以不保证其完全正确性,在此表⽰个⼈不对出现的问题负任何责任,⼤家WA了或者⼲吗的不要怪我,不过⾄少⽬前来说我⽤起来是没问题的 :)/*----------------------------------------------------------------------------*/** 关于快排函数的⼀些说明 **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);}9、计算⼏何中求凸包的cmpint cmp(const void *a, const void *b){TPoint *c = (TPoint *)a;TPoint *d = (TPoint *)b;double k = multi(*c, *d, point[0]); //p0c×p0d (若>0 说明c的极⾓⼩于d, 若<0, c的极⾓⼤于d) if( k< 0) return1; // 若前⾯的⼤于后⾯的,返回1--- 表⽰升序(交换) else if(k == 0 && distance(*c, point[0]) >= distance(*d, point[0]))return1; // 把距离远的丢在后⾯,这么做扫描时才可以删掉近的else return -1;}。

c语言qsort函数详解

c语言qsort函数详解

c语言qsort函数详解qsort函数是C语言中的一个库函数,用于对数组进行排序。

它在stdlib.h头文件中声明,其主要目的是为了提高排序效率。

下面详细介绍一下qsort函数的语法和用法:1. qsort函数的语法void qsort (void* base, size_t num, size_t size, int(*compar)(const void*, const void*));2. 参数解释这个函数的参数包括:base:要排序的数组首元素的地址。

num:数组中元素的个数。

size:每个元素的大小,单位是字节。

compar:排序的比较函数,比较函数的原型为:int (* compar) (const void *, const void*),其中,它需要接收两个指向常量的void指针变量,用来指向待比较的两个元素。

如果第一个元素小于第二个元素,则返回负数;如果第一个元素大于第二个元素,则返回正数;如果两个元素相等,则返回0。

3. qsort函数的用法qsort函数使用的时候只需要将要排序的数组作为参数,以及一个比较函数即可。

例如,我们要对一个数组进行从小到大排序,可以这样:```c#include<stdio.h>#include<stdlib.h>int cmp(const void *a, const void *b){return (*(int*)a - *(int*)b);}int main(){int a[5] = {1, 5, 2, 6, 4};qsort(a, 5, sizeof(int), cmp);for(int i = 0; i < 5; i++){printf("%d ", a[i]);}return 0;}```上述代码中,我们自定义了一个cmp函数,用于比较两个元素的大小。

然后我们以a这个数组为基础,长度为5,每个元素大小为int类型,调用了qsort函数。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

自定义比较函数
比较函数的名字是自定义的(这里我们用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对结构体一级排序: 对结构体一级排序: 应用 对结构体一级排序
#include <stdio.h> #include <stdlib.h> struct coord { int x; int y; }data[100]; int cmp(struct coord *a ,struct coord *b) { return a->y - b->y ; } //根据 的大小排序 根据y的大小排序 根据
qsort(s,100,sizeof(s[0]),cmp); strcmp包含在 包含在<string.h>的头文件里 包含在 (简单了解): 对字符串排序(简单了解): 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 ); }
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 ) { return *b - *a; } void main() { int num[10]={1,3,5,7,9,2,4,6,8,0}; int i; qsort(num,10,sizeof(num[0]),cmp_1);//从小到大 for(i=0;i<10;i++) printf("%d ",num[i]); printf("\n"); qsort(num,10,sizeof(num[0]),cmp_2);//从大到小 for(i=0;i<10;i++) printf("%d ",num[i]); printf("\n"); }
应用qsort对char数组进行排序: 应用 对 数组进行排序: 数组进行排序
#include <stdio.h> #include <stdlib.h> int cmp_1 ( char *a , char *b ) { return *a - *b; } int cmp_2 ( char *a , char *b ) { return *b - *a; } void main() { char ch[10]={"bcadfegihj"}; int i; qsort(ch,10,sizeof(ch[0]),cmp_1);//从小到大 for(i=0;i<10;i++) printf("%c ",ch[i]); printf("\n"); qsort(ch,10,sizeof(ch[0]),cmp_2);//从大到小 for(i=0;i<10;i++) printf("%c ",ch[i]); printf("\n"); }
C函数qsort的简介和用法
BY:SMJUN
C函数qsort实现快速排序
排序方法有很多种:选择排序,冒泡排序, 排序方法有很多种:选择排序,冒泡排序, 归并排序,快速排序等。 归并排序,快速排序等。 看名字都知道快速排序 是目前公认的一种 比较好的排序算法,比选择排序, 比较好的排序算法,比选择排序,冒泡排 序都要快。因为它的速度很快, 序都要快。因为它的速度很快,所以系统 也在库里实现这个算法,便于我们的使用。 也在库里实现这个算法,便于我们的使用。 这就是qsort。 这就是 。
简单示例: 中的元素从小到大排序。 简单示例:对int num[100]中的元素从小到大排序。 中的元素从小到大排序 int num[100]; int cmp ( const void *a , const void *b ) { return *(int *)a - *(int *)b; //强制转换类型 强制转换类型 } qsort(num,100,sizeof(num[0]),cmp);
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"); } } 输入: 输入: 4 02 21 38 63 0
qsort简介
qsort函数是 函数是ANSI C标准中提供的,其声明在 标准中提供的, 函数是 标准中提供的 stdlib.h文件中,是根据二分发写的,其时间复杂 文件中, 文件中 是根据二分发写的, 度为n*log(n),其结构为: 其结构为: 度为 其结构为 void qsort(void *base,size_t nelem,size_t width, cmp); *base 为要排序的数组 nelem 为要排序的数组的长度 width 为数组元素的大小(一字节为单位) 为数组元素的大小(一字节为单位) 简单示例:对int num[100]排序,qsort中各参数 简单示例: 排序, 排序 中各参数 怎么写? 怎么写? qsort(num,100,sizeof(num[0]),cmp);
相关文档
最新文档