qsort函数的用法
qsort 用法
qsort 用法qsort 是一个C库函数,用于对数组进行快速排序。
它可以按照特定的比较函数,对数组中的元素进行排序。
以下是关于 qsort 函数的一些用法:1. 函数原型:```cvoid qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void *));```- base:指向待排序数组的首个元素的指针。
- nitems:待排序数组中元素的个数。
- size:每个元素的字节大小。
- compar:用户自定义的比较函数。
2. 比较函数的定义:比较函数用于定义排序的方式,它必须满足以下规则:- 如果第一个元素小于第二个元素,则返回一个负数。
- 如果第一个元素大于第二个元素,则返回一个正数。
- 如果两个元素相等,则返回零。
比较函数的原型如下:```cint compar(const void *a, const void *b);3. 示例用法:假设我们有一个整型数组,需要按从小到大的顺序进行排序。
下面是一个示例代码:```c#include <stdio.h>#include <stdlib.h>// 比较函数int compar(const void *a, const void *b) {return (*(int*)a - *(int*)b);}int main() {int arr[] = {9, 5, 2, 7, 1};int n = sizeof(arr) / sizeof(arr[0]);// 使用 qsort 对数组进行排序qsort(arr, n, sizeof(int), compar);// 打印排序后的数组for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}return 0;```输出结果:```1 2 5 7 9```在上面的示例中,我们首先定义了一个比较函数 `compar`,该函数按照从小到大的顺序对整数进行比较。
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函数
qsort函数qsort函数是C语言中常用的排序算法之一,它属于快速排序算法,它可以很快地对数组进行排序。
qsort函数的历史可以追溯到1960年代的“快速排序”,当时由爱德华诺夫斯基(EdwardNofsk)提出。
它的原理是,首先在数组中选取一个基准值,然后把所有小于等于基准值的元素放在基准值左边,把所有大于等于基准值的元素放在基准值右边,最后递归地把每个子数组再排序,直到所有的元素都排序完毕。
qsort函数的实现非常简单,只需要定义一个带有四个参数的函数qsort,第一个参数是要排序的数组,第二个参数是数组的元素个数,第三个参数是元素的大小,最后一个参数是用于比较两个元素值的函数。
在实现qsort函数过程中,可以使用递归思想,每次使用一个基准值,把数组中元素分成两部分,分别对其中的元素进行排序,最终实现快速排序。
qsort函数的优势在于它简单易懂,而且在空间复杂度上也比较低,可以达到O(logn),它是一个时间复杂度较低的排序算法,可以实现大量数据的排序,是许多编程语言的核心函数之一,广泛应用于各种应用场景,如搜索引擎、系统工具、数据可视化等。
qsort函数的应用也是十分普遍的,它可以用于排序数组,也可以用于排序链表,同时支持比较函数的自定义,可以根据业务需求定制不同的排序方式,同时还可以作为数据校验的处理过程,可以用来检索并对大量数据进行排序。
qsort函数也有一些缺点,因为在实现快速排序时,使用递归思想,有可能造成堆栈溢出,另外它没有最优比较结构,如果数据集中在一个范围值的话,它的排序效率有可能会变得很低,因此使用者需要仔细分析和调配,获取最佳性能。
qsort函数是当今C语言常用的排序算法之一,它可以实现快速排序,可以快速地对数组进行排序,而且它还支持比较函数的自定义,可以根据业务需求实现不同的排序方式。
但是也有其缺点,需要注意并适度使用,以达到最佳性能。
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)更进⼀步,让这种操作更加能适应变化。
C语言标准库函数 qsort 详解
C语言标准库函数 qsort 详解qsort包含在<stdlib.h>头文件中,此函数根据你给的比较条件进行快速排序,通过指针移动实现排序。
排序之后的结果仍然放在原数组中。
使用qsort函数必须自己写一个比较函数。
函数原型:void qsort ( void * base, size_t num, size_t size, int ( * comparator ) ( const void *, const 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 (无返回值)一、对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 Sample{double data;int other;}s[100]//按照data的值从小到大将结构体排序int cmp( const void *a ,const void *b){return (*(Sample *)a).data > (*(Sample *)b).data ? 1 : -1; }qsort(s,100,sizeof(s[0]),cmp);五、对结构体二级排序struct Sample{int x;int y;}s[100];//按照x从小到大排序,当x相等时按照y从大到小排序int cmp( const void *a , const void *b ){struct Sample *c = (Sample *)a;struct Sample *d = (Sample *)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 Sample{int data;char str[100];}s[100];//按照结构体中字符串str的字典顺序排序int cmp ( const void *a , const void *b ){return strcmp( (*(Sample *)a)->str , (*(Sample *)b)->str ); }qsort(s,100,sizeof(s[0]),cmp);附加一个完整点的代码,对字符串二维数组排序:#include <stdio.h>#include <stdlib.h>#include <string.h>char s[2001][1001];int cmp(const void *a, const void *b){ return strcmp((char *)a,(char *)b); }int main(){int i,n;scanf("%d",&n);getchar();for(i=0;i<n;i++) gets(s[i]);qsort(s,n,1001*sizeof(char),cmp); for(i=0;i<n;i++) puts(s[i]);return 0;}。
qsort 用法 -回复
qsort 用法-回复QSort是一种常见的排序算法,也称为快速排序。
它是一种分治策略的排序算法,通常比较高效,在实践中被广泛使用。
以下是一篇关于QSort用法的1500-2000字文章,逐步回答。
QSort是一种基于比较的内部排序算法,在大多数情况下运行时间是O(nlogn)。
它通过将数组分成较小的子数组并逐步排序这些子数组来工作。
QSort的名字来自于它的排序过程中,快速地将数组分割成两个部分。
首先我们需要了解一些基本概念。
在排序算法中,我们需要比较元素的大小,这可以通过元素之间的某种关系来实现,例如元素可以是数字、字符串或其他可比较的对象。
在QSort中,我们使用一个称为“比较器”的函数来确定元素之间的比较方式。
使用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函数的简介和用法,保证简洁明了!
• 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(),sort()排序函数
qsort(),sort()排序函数⼀.qsort()函数功能:使⽤快速排序例程进⾏排序头⽂件:stdlib.h⽤法:void qsort(void *base,int nelem,int width,int (*fcmp)(const void *,const void *));参数:1待排序数组⾸地址2数组中待排序元素数量3 各元素的占⽤空间⼤⼩4指向函数的指针,⽤于确定排序的顺序qsort(即,quicksort)主要根据你给的⽐较条件给⼀个快速排序,主要是通过指针移动实现排序功能。
排序之后的结果仍然放在原来数组中。
其中qsort和compare的⽤法如下:void qsort( void *base, size_t num, size_t width, int (__cdecl *compare )int compare (const void *elem1, const void *elem2 ) ;1、对int类型数组排序compare函数:int compare(const void *a , const void *b ){return *(int *)a - *(int *)b; //升序排序//return *(int *)b - *(int *)a; //降序排序/*可见:参数列表是两个空指针,现在他要去指向你的数组元素。
所以转型为你当前的类型,然后取值。
升序排列时,若第⼀个参数指针指向的“值”⼤于第⼆个参数指针指向的“值”,则返回正;若第⼀个参数指针指向的“值”等于第⼆个参数指针指向的“值”,则返回零;若第⼀个参数指针指向的“值”⼩于第⼆个参数指针指向的“值”,则返回负。
降序排列时,则刚好相反。
*/}测试实例:#include<iostream>#include<stdlib.h>using namespace std;int compare(const void *a,const void *b){return *(int*)b-*(int*)a; //降序排列}int main(){int a[ ]={2,4,1,23,5,76,0,43,24,65};int i;int length = sizeof(a)/sizeof(int);for(i=0;i<length;i++)cout<<a[i]<<" ";cout<<endl;qsort(a,length,sizeof(int),compare);for(i=0;i<length;i++)cout<<a[i]<<" ";cout<<endl;return 0;}2.对char类型数组排序(同int类型)char word[100];//注意,⽹上很多版本是 “ return *(char *)a - *(int *)b; ”//注意: *(int *)b是错误的⽤法//应该是return *(char *)a - *(char *)b;return *(char *)a - *(char *)b;}qsort(word,100,sizeof(word[0]),compare);3.对double类型数组排序double in[100];int compare( const void *a , const void *b ){return *(double *)a > *(double *)b ? 1 : -1;//返回值的问题,显然compare返回的是⼀个整型,所以避免double返回⼩数⽽被丢失,⽤⼀个判断返回值。
qsort及其用法
qsort及其用法一、函数原型void qsort(void *base, size_t num, size_t width, int (__cdecl *compare )(const void *elem1, const void *elem2 ) );大概的意思是,第一个参数指明了要排序的数组(比如:程序中的num),第二个参数给出了数组的大小(qsort没有足够的智力预知你传给它的数组的实际大小),第三个参数给出了数组中每个元素以字节为单位的大小。
最后那个长长的家伙,给出了排序时比较元素的方式..再给一个例子: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用法
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,
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;}}}。
C语言标准库函数 qsort 详解
C语言标准库函数 qsort 详解qsort包含在<stdlib.h>头文件中,此函数根据你给的比较条件进行快速排序,通过指针移动实现排序。
排序之后的结果仍然放在原数组中。
使用qsort函数必须自己写一个比较函数。
函数原型:void qsort ( void * base, size_t num, size_t size, int ( * comparator ) ( const void *, const 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 (无返回值)一、对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 Sample{double data;int other;}s[100]//按照data的值从小到大将结构体排序int cmp( const void *a ,const void *b){return (*(Sample *)a).data > (*(Sample *)b).data ? 1 : -1; }qsort(s,100,sizeof(s[0]),cmp);五、对结构体二级排序struct Sample{int x;int y;}s[100];//按照x从小到大排序,当x相等时按照y从大到小排序int cmp( const void *a , const void *b ){struct Sample *c = (Sample *)a;struct Sample *d = (Sample *)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 Sample{int data;char str[100];}s[100];//按照结构体中字符串str的字典顺序排序int cmp ( const void *a , const void *b ){return strcmp( (*(Sample *)a)->str , (*(Sample *)b)->str ); }qsort(s,100,sizeof(s[0]),cmp);附加一个完整点的代码,对字符串二维数组排序:#include <stdio.h>#include <stdlib.h>#include <string.h>char s[2001][1001];int cmp(const void *a, const void *b){ return strcmp((char *)a,(char *)b); }int main(){int i,n;scanf("%d",&n);getchar();for(i=0;i<n;i++) gets(s[i]);qsort(s,n,1001*sizeof(char),cmp); for(i=0;i<n;i++) puts(s[i]);return 0;}。
qsort()函数详解
qsort()函数详解参考:排序⽅法有很多种:选择排序,冒泡排序,归并排序,快速排序等。
快速排序是⽬前公认的⼀种⽐较好的排序算法。
因为他速度很快,所以系统也在库⾥实现了这个算法,便于我们的使⽤。
这就是qsort函数(全称quicksort)。
它是ANSI C标准中提供的,其声明在stdlib.h⽂件中,是根据⼆分法写的,其时间复杂度为n*log(n)功能:使⽤快速排序例程进⾏排序头⽂件:stdlib.h函数原型:void qsort(void* base,size_t num,size_t width,int(__cdecl*compare)(const void*,const void*));参数说明:base:待排序数组,排序之后的结果仍放在这个数组中num:数组中待排序元素数量width:各元素的占⽤空间⼤⼩(单位为字节)compare:指向函数的指针,⽤于确定排序的顺序(需要⽤户⾃定义⼀个⼦函数)函数返回值:⽆注意:如果两个元素的值是相同的,那么它们的前后顺序是不确定的。
也就是说qsort()是⼀个不稳定的排序算法。
compar参数详细规则compar参数是⼀个函数指针,指向⼀个⽐较两个元素的函数。
⽐较函数的原型应该像下⾯这样。
注意两个形参必须是const void *型。
另外,因为qsort( )内部在调⽤compar 函数(compar实质为函数指针,这⾥称它所指向的函数也为compar)时,传⼊的实参也已经转换成const void *型,所以在compar函数内部必须将const void *型转换成待排序数组的实际类型,见下⽂。
int cmp(const void *p1, const void *p2);如果cmp返回值⼩于0(< 0),那么p1所指向元素会被排在p2所指向元素的前⾯如果cmp返回值等于0(= 0),那么p1所指向元素与p2所指向元素的顺序不确定如果cmp返回值⼤于0(> 0),那么p1所指向元素会被排在p2所指向元素的后⾯所以,实现cmp函数时,谨记:如果满⾜某个条件时,p1元素应在p2元素前⾯,那么此时返回负数,⽐如-1;如果满⾜某个条件时,p1元素应在p2元素后⾯,那么此时返回正数,⽐如1;如果满⾜某个条件时,p1元素和p2元素顺序不影响,那么返回0.(这个时候⼀般是表⽰p1==p2)使⽤qsort()函数的例⼦1 #include<stdio.h>2 #include<stdlib.h>3 #include<time.h>4 #include<string.h>5 typedef struct6 {7int No;8int yuWen,shuXue,yingYu,zongFen;9 }stu;10 typedef struct11 {12int x,y;13 }point;1415//----------随机数相关⼦函数-----------------------------16int getRandomInt(int a,int b)//返回[a,b]之间⼀个随机整数17 { return (rand() % (b-a+1))+ a; }18double getRandomDouble()//返回0~1之间随机浮点数19 { return rand()/double(RAND_MAX); }20char getUpChar()//返回随机⼤写字母21 { return ((char)(rand()%26+'A')); }22char getDownChar()//返回随机⼩写字母23 { return ((char)(rand()%26+'a')); }24void InitRandom()25 { srand((unsigned)time(0)); }26//-------------------------------------------------------272829int cmp1(const void *a,const void *b)//int数组从⼩到⼤排序30 { return *(int*)a -*(int*)b; }31int cmp2(const void *a,const void *b)//int数组从⼤到⼩排序32 { return *(int*)b -*(int*)a; }3334/*在对浮点或者double型的数据⽐较时⼀定要⽤三⽬运算符,35因为要是使⽤像整型那样相减的话,如果是两个很接近的数,36则可能返回⼀个很⼩的⼩数(⼤于-1,⼩于1),⽽cmp的返37回值是int型,因此会将这个⼩数返回0,系统认为是相等,38失去了本来存在的⼤⼩关系 */39int cmp3(const void *a,const void *b)//double数组从⼩到⼤排序40 {41//return *(double*)a -*(double*)b;//这种写法⽐较危险。
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);}。
Qsort的通用法
Qsort的通用法一、对int类型数组排序intnum[100];Sample:intcmp ( const void *a , const void *b ) {return *(int *)a - *(int *)b;}qsort(num,100,sizeof(num[0]),cmp);二、对char类型数组排序(同int类型)char word[100];Sample:intcmp( const void *a , const void *b ){return *(char *)a - *(int *)b;}qsort(word,100,sizeof(word[0]),cmp);三、对double类型数组排序(特别要注意)double in[100];intcmp( 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的类型可以很多种,参考上面的例子写intcmp( 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从大到小排序intcmp( 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的字典顺序排序intcmp ( const void *a , const void *b ){return strcmp( (*(In *)a)->str , (*(In *)b)->str );}qsort(s,100,sizeof(s[0]),cmp);七、计算几何中求凸包的cmpintcmp(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;}PS:其中的qsort函数包含在<stdlib.h>的头文件里,strcmp包含在<string.h>的头文件里对浮点型快排实例:源程序, vc6通过的:#include <stdio.h>#include <stdlib.h>intfcmp(const float*,const float*);typedefint(*QSORT_UDF)(const void *,const void *);int main(){float fArray[10] ={32.1,456.87,332.67,442.0,98.12,451.79,340.12,54.55,99.87,72.5}; qsort(fArray,10,sizeof(float),(QSORT_UDF)fcmp);for(int i=0;i<10; i++)printf(" %3.2f ",fArray[i]);return 0;}intfcmp(const float *a,const float *b) {if( *a > *b )return 1;else if(*a < *b )return -1;return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
六类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快两年的时候了,却一直没有真正弄懂cmp函数的返回值1,-1,0的函数. 今天在做凸包时,郁闷了...cmp返回值的意识:int cmp(const void *a, const void *b)返回正数就是说 cmp 传入参数第一个要放在第二个后面, 负数就是传入参数第一个要放第二个前面, 如果是 0, 那就无所谓谁前谁后..很多人问这个东西.我以前也看了好久,今天翻到以前学快排的时候写的练习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) return 1; // 若前面的大于后面的,返回1--- 表示升序(交换)else if(k == 0 && distance(*c, point[0]) < distance(*d, point[0]))return 1; // 把距离小的点排在前面else return -1;}11。