qsort-随写

一 写在开头
1.1 本节内容
学习C语言中的qsort()函数。

二 qsort()
2.1 函数原型

复制代码
void qsort(
void *base,
size_t nmemb,
size_t size,
int (compar)(const void , const void *)
);
复制代码
函数功能：qsort()函数的功能是对数组进行排序，数组有nmemb个元素，每个元素大小为size。

参数base - base指向数组的起始地址，通常该位置传入的是一个数组名
参数nmemb - nmemb表示该数组的元素个数
参数size - size表示该数组中每个元素的大小（字节数）
参数(compar)(const void , const void *) - 此为指向比较函数的函数指针，决定了排序的顺序。

函数返回值：无

注意：如果两个元素的值是相同的，那么它们的前后顺序是不确定的。也就是说qsort()是一个不稳定的排序算法。

2.2 compar参数
compar参数指向一个比较两个元素的函数。比较函数的原型应该像下面这样。注意两个形参必须是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函数可以写成这样：

复制代码
1 int compareMyType (const void * a, const void * b)
2 {
3 if ( (MyType)a < (MyType)b ) return -1;
4 if ( (MyType)a == (MyType)b ) return 0;
5 if ( (MyType)a > (MyType)b ) return 1;
6 }
复制代码
注意：你要将MyType换成实际数组元素的类型。

2.3 一个使用qsort()函数的小例子

复制代码
c语言
`int values[] = { 40, 10, 100, 90, 20, 25 };

int compare (const void * a, const void * b)
{
return ( * (int* )a - * (int *)b );
}

int main ()
{
int n;
qsort (values, 6, sizeof(int), compare);
for (n=0; n<6; n++) printf (“%d “,values[n]);
return 0;
}`
复制代码

分析一下compar函数。如果a小于b，则返回值为负数（< 0），也即a会排在b的前面。同理，若a大于b，则a会排在b的后面。所以，这里的qsort()为从小到大即升序排序。因此，运行结果为：10 20 25 40 90 100

2.4 修改compar()，使qsort()为降序排序
很简单，只要将上面compare()中的

return ( * (int*)a - (int )b );
改为：

return ( * (int* )b - * (int*)a );
即可，想想为什么可以。

2.5 改写

可以将上面的小例子改写如下：

复制代码

int values[] = {40, 10, 100, 90, 20, 25};
const unsigned long VALUES_LEN = sizeof(values) / sizeof(values[0]);
const unsigned long VALUES_ITEM_SIZE = sizeof(values[0]);

int compare(const void * a, const void * b)
{
return ((int )a - (int )b);
}

int main()
{
int i;

qsort(values, VALUES_LEN, VALUES_ITEM_SIZE, compare);
for (i = 0; i < VALUES_LEN; i++)
{
    printf("%d ", values[i]);
}
putchar('\n');

return 0;

}
详细用法：
1：数字的qsort排序

a：从大到小排序
int cmp ( const void *a , const void *b ) //排序函数
{
return (int )b - (int )a;
}

   qsort(s,n,sizeof(s[0]),cmp);  //调用函数

b：从小到大
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;
}

qsort(num,100,sizeof(num[0]),cmp);

二、对char类型数组排序（同int类型）

char word[50];

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);
六、对结构体三级排序（都是从小到大）

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;
}
item ss[1200];
qsort(ss,n,sizeof(ss[0]),comp);
七、对字符串进行排序

struct In
{
int data;
char str[100];
}s[100];

//按照结构体中字符串str的字典顺序排序

int cmp ( const void *a , const void *b )
{
return strcmp( (* (In )a)->str , ( (In *)b)->str );
}

qsort(s,100,sizeof(s[0]),cmp);

七、计算几何中求凸包的cmp

int cmp(const void *a,const void *b) //重点cmp函数，把除了1点外的所有点，旋转角度排序
{
struct point c=(point )a;
struct point d=(point )b;
if( calc(*c, *d,p[1]) < 0) return 1;
else if( !calc( * c,*d,p[1]) && dis(c->x,c->y,p[1].x,p[1].y) < dis(d->x,d->y,p[1].x,p[1].y)) //如果在一条直线上，则把远的放在前面
return 1;
else return -1;
}