qsort函数用法
C语言之qsort函数详解
C语⾔之qsort函数详解⽬录⼀.qsort函数原型⼆.qsort常见的⼏种⽐较函数1.int类型的排序2.double类型的排序3.char类型的排序4.字符串的排序：1.按⾸字母排序2.按字符串长度排序：总结⼀.qsort函数原型qsort 功能: 使⽤快速排序例程进⾏排序，这个函数是根据⼆分法写的，其时间复杂度为n*log(n)#include<stdlib.h>void qsort(void *base, int nelem, int width, int (*fcmp)(const void *,const void *))各参数：1. 待排序数组⾸地址（可直接输⼊待排序数组名，或是指向数组的指针）2. 数组中待排序元素数量（可以⽤sizeof（）来求）3. 各元素的占⽤空间⼤⼩（可以⽤sizeof（arr[0]）来求）4. 指向函数的指针这个qsort需要我们⾃⼰创建⼀个⽐较函数，基本都是这个函数int cmp(const void* _a, const void* _b)；⼆.qsort常见的⼏种⽐较函数1.int类型的排序int cmp(const void* _a, const void* _b){int* a = (int*)_a;int* b = (int*)_b;return *a-*b;}int main(){int num[10] = { 5,7,8,1,26,52,9,3,14,56 };int sz = sizeof(num) / sizeof(num[0]);qsort(num, sz, sizeof(num[0]), cmp);int i = 0;for (i = 0; i < sz; i++){printf("%d ", num[i]);}}*a-*b这个是从⼩到⼤排序，如果想从⼤到⼩排序就是*b-*a；升序排序结果图：降序排列：int cmp(const void* _a, const void* _b){int* a = (int*)_a;int* b = (int*)_b;return *b-*a;}int main(){int num[10] = { 5,7,8,1,26,52,9,3,14,56 };int sz = sizeof(num) / sizeof(num[0]);qsort(num, sz, sizeof(num[0]), cmp);int i = 0;for (i = 0; i < sz; i++){printf("%d ", num[i]);}}其实降序排序就是换成*b-*a降序排序效果图：2.double类型的排序int cmp(const void* _a, const void* _b){double* a = (double*)_a;double* b = (double*)_b;return *(double*)_a > *(double*)_b ? 1 : -1;;}int main(){double num[4] = { 2.1,5.2,3.2,445.2};int sz = sizeof(num) / sizeof(num[0]);qsort(num, sz, sizeof(num[0]), cmp);int i = 0;for (i = 0; i < sz; i++){printf("%.2f ", num[i]);}}double类型的⽐较特殊，因为返回值是int，所以如果是两个特别相近的浮点数相减，那么就有可能会出现的结果⽐-1⼤并且⽐1⼩，这样系统就会默认为0，所以这⾥使⽤了⼀个三⽬运算，⽤来⽐较。
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`，该函数按照从小到大的顺序对整数进行比较。
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排序的介绍与使用2007-05-22 19:24qsort函数包含在<stdlib.h>的头文件里。
qsort函数声明如下：void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));参数说明如下：base: 要排序的数组nmemb: 数组中的元素数目size: 每个数组元素占用内存空间，可使用sizeof获得compar: 比较两个数组元素的比较函数。
本比较函数的第一个参数值小于、等于、大于第二参数值时，本比较函数的返回值应分别小于、等于、大于零。
也就说你要实现一个这样的函数（升序）：int cmp(const void *a, const void *b)如果a > b，返回>0如果a == b, 返回0如果a < b，返回<0这里的a和b的关系仅仅是逻辑上的，并不是值比较，所以排序的可以不仅仅是数字，还可以是字符。
<以下排序都是采用的从小到大排序>一、对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);对一个二维数组的进行排序：int a[1000][2]; 其中按照a[i][0]的大小进行一个整体的排序，其中a[i][1]必须和a[i][0]一起移动交换。
qsort(a,1000,sizeof(int)*2,comp);int comp(const void *a,const void *b){return ((int *)a)[0]-((int *)b)[0];}二、对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 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;}众所周知，C语言中qsort是在一个数组中以升序对数据进行排序。
c语言qsort函数
c语言qsort函数c语言qsort函数是一种根据指定模式进行排序的函数，是一个快速排序算法，它可以实现O（nlog（n））的最坏时间复杂度，并且可以使用少量的主调数据空间，是一种常用的排序算法。
c语言中的qsort函数是由ANSI C库中的函数 qsort()现的，该函数由C标准库提供，是属于stdlib.h头文件中的函数，用于根据指定排序规则对数组中的元素进行排序，可以实现快速地进行排序。
qsort()数的原型如下：void qsort (void *base, size_t num, size_t size, int(*compare)(const void *, const void *));它的参数如下：base：指向数组的指针num：数组中的元素数量size：每个数组元素的大小compare：指向函数的指针，用来比较两个元素的大小，比较的函数的返回值应当为一个整数，大于零则表示前一个元素大于后一个元素，小于零则表示前一个元素小于后一个元素，等于零则表示两个元素相等。
qsort()函数采用了快速排序算法来进行排序，它的基本原理是将数组中的元素划分为两个部分，左边的元素都小于右边的元素，再对两个部分分别调用qsort函数进行排序。
qsort函数的优点是可以快速排序，其算法复杂度定义如下：时间复杂度：O(nlog(n))空间复杂度：O(n)这意味着qsort函数可以在最差的情况下对一个元素数量为n的数组进行排序，时间复杂度为O（nlog（n）），空间复杂度为O（n）。
事实上，qsort()的时间复杂度在较小的数量级下，可用O(n^2)表示，这是因为每个元素都要消耗一定时间，即使用O(nlogn)的时间复杂度进行循环，也会出现时间复杂度为O（n^2）的情况。
如果要在C言中使用 qsort数，只需要包含 stdlib.h文件，并将数组名、元素的个数、元素的大小以及比较函数的指针作为参数传入即可：#include <stdlib.h>int a[10000];int compare (const void *a, const void *b) {return (*(int*)a - *(int*)b);}qsort(a, 10000, sizeof(int), compare);qsort函数虽然是一个简单易用又高效的排序函数，但它也存在一定的局限性，比如，当比较函数传入指针时，通常只能比较数字类型，无法比较字符串类型；另外，比较函数传入指针时，也只能比较两个元素，无法比较多个元素。
qsort 用法 -回复
qsort 用法-回复QSort是一种常见的排序算法，也称为快速排序。
它是一种分治策略的排序算法，通常比较高效，在实践中被广泛使用。
以下是一篇关于QSort用法的1500-2000字文章，逐步回答。
QSort是一种基于比较的内部排序算法，在大多数情况下运行时间是O(nlogn)。
它通过将数组分成较小的子数组并逐步排序这些子数组来工作。
QSort的名字来自于它的排序过程中，快速地将数组分割成两个部分。
首先我们需要了解一些基本概念。
在排序算法中，我们需要比较元素的大小，这可以通过元素之间的某种关系来实现，例如元素可以是数字、字符串或其他可比较的对象。
在QSort中，我们使用一个称为“比较器”的函数来确定元素之间的比较方式。
使用QSort进行排序的第一步是选择一个称为“主元”的元素。
该元素将在排序过程中作为参考值，其他元素将与它进行比较和排序。
通常情况下，我们选择数组的第一个或最后一个元素作为主元，但也可以选择其他元素。
选择主元的方式对算法的性能有一定的影响。
一旦选择了主元，我们将数组分为两个部分，同时建立两个指针。
第一个指针从数组的左侧开始，往右扫描数组，找到一个大于或等于主元的元素。
第二个指针从数组的右侧开始，往左扫描数组，找到一个小于或等于主元的元素。
这样，我们得到了两个指针指向的元素，它们需要在排序后的数组中交换位置。
一旦指针交汇，我们就可以确定主元在排序后数组的位置。
将主元元素放置在这个位置，并分别对主元的左侧和右侧进行递归排序。
这个过程叫做快速排序的分割阶段。
递归排序的基本思想是，如果一个数组可以正确地排序并且可以将它分成两个较小的数组进行排序，那么整个数组也可以正确地排序。
这种思想被称为分治策略。
在QSort中，我们将数组分割成两个较小的子数组，并分别对它们进行排序。
在递归过程中，我们继续选择主元并分割数组，直到只剩下一个元素或者子数组为空。
当数组只剩下一个元素时，我们可以认为它已经被排序了。
c++qsort
qsort包含在<stdlib.h>头文件中，此函数根据你给的比较条件进行快速排序，通过指针移动实现排序。
其排序是根据二分法写的，其时间复杂度为n*log(n)。
排序之后的结果仍然放在原数组中。
使用qsort函数必须自己写一个比较函数。
其实qsort的用法跟sort十分的相像。
关于sort的用法见下一篇文章。
函数原型：void qsort ( void * base, size_t num, size_t size, int ( * comparator )( const void *, const void * ) );用法以及参数说明：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 isconsidered 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;//因为自定义函数的返回值必须是int型，所以这里不能直接相减}qsort(in,100,sizeof(in[0]),cmp);四、对结构体一级排序struct Sampledouble 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;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
举个简单点的例子来说：
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,
在这个系列的文章中，我们主要研究一下ANSI C的库函数qsort的源代码，并给出它
的性能特性分析。其中使用的源代码是 2003中VC++自带的源代码，大家可以在
X:\Program Files\Microsoft Visual Studio .NET 2003\Vc7\crt\src文件夹中找到这
}
intmain()
{
iHale Waihona Puke tn;scanf("%d",&n);
for(inti=0;i<n;i++)
scanf("%d",&a[i]);
qsort((void*)a,n,sizeof(a[0]),cmp);
for(inti=0;i<n;i++)
printf("%d\n",a[i]);
//while(1);
staticvoid __cdeclshortsort(
char*lo,
char*hi,
size_twidth,
int(__cdecl*comp)(constvoid *,constvoid *)
)
{
char*p, *max;
/* Note: in assertions below, i and j arealwayinside original bound of
大小小于CUTOFF的数组，就调用这个函数来进行排序，而不是继续拆分数组进入下一层
递归。因为虽然这里用的是基本排序方法，它的运行时间和O(n^2)成比例，但是如果是
只有8个元素，它的速度比需要递归的快速排序要快得多。另外，在源代码的注释中，说
这是一个插入排序(insertion sort)，但是我觉得这个应该是一个选择排序才对
下面我们开始分析源代码，在源代码中的解释以注释的形式出现：
/***
*qsort.c- quicksort algorithm;qsort() library function for sorting arrays
*
* Copyright (c) Microsoft Corporation. All rights reserved.
return0;
}
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
chara[20005][25];
intcmp(constvoid *p,constvoid *q)
{
returnstrcmp((char*)p,(char*)q);
}
intmain()
sort(a,a+n,comp)
comp的写法：
boolcomp(const&a,const&b){retuana<b;}
这样也是一样从小到大排序，如果要从大到小排序就return a>b
如果是一个结构体的话：
structnode{
intx,y;
}
按x排序的话，就这样用：
boolcomp(const&a,const&b){returna.x<b.x;}
intcmp(constvoid *a,constvoid *b) //重点cmp函数，把除了1点外的所有点，旋转角度排序
{
structpoint *c=(point *)a;
structpoint *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)) //如果在一条直线上，则把远的放在前面
*
*Purpose:
* To implement theqsort() routine for sorting arrays.
*
*****************************************************************************
**/
#include <cruntime.h>
经过测试以后能够时快速排序算法达到最快的CUTOFF的值。*/
#define CUTOFF 8 /* testing shows that this is good value */
/*源代码中这里是qsort的代码，但是我觉得先解释了qsort要调用的函数的功能比较
好。
shortsort函数：
这个函数的作用，上面已经有提到。就是当对快速排序递归调用的时候，如果遇到
structIn *d = (In *)b;
if(c->x != d->x) return c->x - d->x;
elsereturn d->y - c->y;
}
qsort(s,100,sizeof(s[0]),cmp);
六、对字符串进行排序
structIn
{
intdata;
charstr[100];
}
.
.
.
qsort(q,n,sizeof(int),cmp);
.
.
.
}
qsort对一维数组和字符串数组的排序：
#include "stdio.h"
#include "stdlib.h"
inta[100];
intcmp(constvoid *p,constvoid *q)
{
return(*(int*)p)-*((int*)q);
右边。经过一次这样的处理之后，这个数在最终的已排序的数列的位置就确定了。然后
我们把比这个数小和比这个数大的数分别当成两个子数列调用下一次递归，最终获得一
个排好序的数列。上面介绍的是基本快速排序的方法，每次把数组分成两分和中间的一个划分值，而对于有多个重复值的数组来说，基本排序的效率较低。集成在C语言库函数里面的的qsort函数，使用三路划分的方法解决这个问题。所谓三路划分，是指把数组划分成小于划分值，等于划分值和大于划分值的三个部分。
快速排序qsort用法收藏
七种qsort排序方法
<本文中排序都是采用的从小到大排序>
一、对int类型数组排序
intnum[100];
Sample:
intcmp(constvoid *a ,constvoid *b )
{
return*(int*)a - *(int*)b;
}
qsort(num,100,sizeof(num[0]),cmp);
intother;
}s[100]
//按照data的值从小到大将结构体排序,关于结构体内的排序关键数据data的类型可以很多种，参考上面的例子写
intcmp(constvoid *a ,constvoid *b)
{
return(*(In *)a)->data > (*(In *)b)->data ?1 :-1;
return1;
elsereturn -1;
}
qsort()是c程序库stdlib.h中的一个函数，需要比较函数完成排序；
sort()是STL中的标准算法。
#include<stdlib.h>
intcmp(constvoid *a,constvoid *b)
{
return*((int*)b)-*((int*)a);
char *hi;指向要排序的子数组的最后一个元素的指针
size_twidth;数组中单个元素的大小
int(__cdecl*comp)(constvoid *,constvoid *);用来比较两个元素大