qsort-sort 排序

sort函数的用法
头文件加上:
#include <algorithm>
using namespace std;
做ACM题的时候，排序是一种经常要用到的操作。如果每次都自己写个冒泡之类的O(n^2)
排序，不但程序容易超时，而且浪费宝贵的比赛时间，还很有可能写错。STL里面有个sort函数，可以直接对数组排序，复杂度为n*log2(n)。使用这个函数，需要包含头文件。
这个函数可以传两个参数或三个参数。第一个参数是要排序的区间首地址，第二个参数是区间尾地址的下一地址。也就是说，排序的区间是[a,b)。简单来说，有一个数组int a[100]
，要对从a[0]到a[99]的元素进行排序，只要写sort(a,a+100)就行了，默认的排序方式是升序。
拿我出的“AC的策略”这题来说，需要对数组t的第0到len-1的元素排序，就写sort(t,t+len);
对向量v排序也差不多，sort(v.begin(),v.end());(STL中的)
排序的数据类型不局限于整数，只要是定义了小于运算的类型都可以，比如字符串类string。
如果是没有定义小于运算的数据类型，或者想改变排序的顺序，就要用到第三参数——比较函数。比较函数是一个自己定义的函数，返回值是bool型，它规定了什么样的关系才是“小于”。想把刚才的整数数组按降序排列，可以先定义一个比较函数cmp
bool cmp(int a,int b)
{
return a<b;//升序排列
//return b>a;//降序排列
}
排序的时候就写sort(a,a+100,cmp);
假设自己定义了一个结构体node
struct node
{
int a;
int b;
double c;
}arr[100];
有一个node类型的数组node arr[100]，想对它进行排序：先按a值升序排列，如果a值相同，再按b值降序排列，如果b还相同，就按c降序排列。就可以写这样一个比较函数：
以下是代码片段：
bool cmp(node x,node y)//一元素
{
return x.a<y.a;
}
int cmp(node x,node y) //二元素
{
if(x.a != y.a) //升序排列
return x.a < y.a; //优先排的部分
return x.b < y.b; //被动排的部分
}
bool cmp(node x,node y)//三元素
{
if(x.a!=y.a) return x.a>y.a;
if(x.b!=y.b) return x.b>y.b;
if(x.c!=y.c) return x.c>y.c;
}
排序时写sort(arr,arr+100,cmp);








qsrot用法
头文件加上:
#include<stdlib.h>
qsort(s,n,sizeof(s[0]),cmp);
标注：
s:待排序数组首地址
n:数组中待排序元素数量
sizeof(s[0]):各元素的占用空间大小
cmp:指向函数的指针，用于确定排序的顺序

int cmp(const void *a,const void *b)
{
return *(int *)a-*(int *)b;
}
比较函数的作用就是给qsort指明元素的大小是怎么比较的。
像这样的比较函数int cmp(const void* a, const void* b) 都是有两个元素 作为参数，返回一个int 值， 如果 比较函数返回大于0，qsort就认为 a>b , 如果比较函数返回等于0 qsort就认为a 和b 这两个元素相等，返回小于零 qsort就认为 ab),你比较函数却返回一个 -1 （小于零的）那么qsort认为a<本文中排序都是采用的从小到大排序>
由于要适用于各种类型，qsort和比较函数的元素类型指针都定义为void * 使用时再转换成真实的类型，所以comp传入的类型为void *

比较的时候把void*先转为char*型，然后取值，这个就是*(char *)a

一、对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 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 ;
}
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);
七、计算几何中求凸包的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;
}
例题：

排名

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 15466 Accepted Submission(s): 5604



Problem Description
今天的上机考试虽然有实时的Ranklist，但上面的排名只是根据完成的题数排序，没有考虑

每题的分值，所以并不是最后的排名。给定录取分数线，请你写程序找出最后通过分数线的

考生，并将他们的成绩按降序打印。





Input
测试输入包含若干场考试的信息。每场考试信息的第1行给出考生人数N ( 0 < N

< 1000 )、考题数M ( 0 < M < = 10 )、分数线（正整数）G；第2行排序给出第1题至第M题的正整数分值；以下N行，每行给出一

名考生的准考证号（长度不超过20的字符串）、该生解决的题目总数m、以及这m道题的题号

（题目号由1到M）。

当读入的考生人数为0时，输入结束，该场考试不予处理。





Output
对每场考试，首先在第1行输出不低于分数线的考生人数n，随后n行按分数从高

到低输出上线考生的考号与分数，其间用1空格分隔。若有多名考生分数相同，则按他们考

号的升序输出。





Sample Input

4 5 25
10 10 12 13 15
CS004 3 5 1 3
CS003 5 2 4 1 3 5
CS002 2 1 2
CS001 3 2 3 5
1 2 40
10 30
CS001 1 2
2 3 20
10 10 10
CS000000000000000001 0
CS000000000000000002 2 1 2
0

Sample Output

3
CS003 60
CS001 37
CS004 37
0
1
CS000000000000000002 20
                                                       代码：

#include<stdio.h>

#include<string.h>

#include<algorithm> //sort头文件

using namespace std; //sort头文件

struct kaosheng

{

char kh[22]; //结构体

int sum;

};

int cmp(kaosheng a,kaosheng b)

{

if(a.sum!=b.sum)

return a.sum>b.sum; //如果符合条件，降序排列

else

return strcmp(a.kh,b.kh)<0; //如果符合条件，升序排列

}

kaosheng ks[1200];

int main()

{

int N,M,G,i,j,k,th,num,n;

int fenzhi[22];

while(~scanf("%d",&N),N!=0)

{

scanf("%d%d",&M,&G);

memset(ks,0,sizeof(ks));

memset(fenzhi,0,sizeof(fenzhi));

for(i=1;i<=M;i++)

scanf("%d",&fenzhi[i]);

k=0; //k要定义在循环的外边，这是我犯的错误

getchar();

for(i=0;i<N;i++)

{

scanf("%s %d",ks[i].kh,&n);//如果有时找不到错误，看一下变量是否定义

num=0;

for(j=0;j<n;j++)

{

scanf("%d",&th);

num+=fenzhi;

}

ks[i].sum=num;

if(ks[i].sum>=G)

k++;

}

sort(ks,ks+N,cmp);

printf("%d\n",k);

for(i=0;i<N;i++)

{

if(ks[i].sum>=G)

printf("%s %d\n",ks[i].kh,ks[i].sum);

}

}

return 0;

}

例题

hdu-1070

milk!

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

#include<algorithm>

using namespace std;

const int maxn=105;

struct node

{

int price;

int before,v;

double per;

char name[maxn];

int ok;

}a[maxn];

bool cmp(node a1,node a2)

{

if(a1.per!=a2.per)

return a1.per<a2.per;

else

return a1.before>a2.before;

}

int main()

{

int T,i,j,n;

scanf("%d",&T);

while(T--)

{

scanf("%d",&n);

for(i=0;i<n;i++)

{

scanf("%s%d%d",a[i].name,&a[i].price,&a[i].v);

if(a[i].v<200) a[i].ok=-1;

a[i].before=a[i].v;

a[i].v=a[i].v-a[i].v%200;

a[i].v=min(1000,a[i].v);

a[i].per=((1.0*a[i].price)/(1.0*a[i].v));

a[i].ok=1; 用着用着就觉得顺手了，今天终于把这道题给解决了，哈哈

}

sort(a,a+n,cmp);

for(i=0;i<n;i++)

{

if(a[i].ok==-1) continue;

printf("%s\n",a[i].name); break;

}

}

return 0;

}