排序

3238

对n(1≤n≤100)个由大写字母组成的长度为1∽20的字符串，按字符串中不同字符个数从多到少的顺序进行排序。不同字符个数相同的字符串按字符串的字典序排序。

#include

#include

#include

typedef struct{

int v;//不同字符个数

char s[101];//源字符串

char s2[101];//统计不同字符个数后的字符串

int length;//长度

}Pair;

//求不同字符的个数

Pair p[101];

int f(char x[101],int len)//有多少个不同的字符

{

int cnt=0,i,j,k;

for(j=0;j

for (i=0;i

if (x[i]==x[j]&&i!=j&&x[i]!='\n')

x[i]='\n';

}

}

for(k=0;k

if(x[k]!='\n')

cnt++;

}

return cnt;

}

//比较函数

int cmp(const void *a,const void *b)

{

Pair *p1=(Pair*)a,*p2=(Pair*)b; int delta;

return (delta=p2->v-p1->v)?delta:strcmp(p1->s,p2->s);//从多到少，字母顺序

}

int main(){

int t,i,j,k,m;

scanf("%d",&t);

for(i=0;i

{

scanf("%d",&m);

for(j=0;j

scanf("%s",p[j].s);

p[j].length=strlen(p[j].s);

strcpy(p[j].s2,p[j].s);

p[j].v=f(p[j].s2,p[j].length);}

qsort(p,m,sizeof(p[0]),cmp);

printf("case #%d:\n",i);

for(k=0;k

printf("%s\n",p[k].s);}

}

return 0;

}

给定一组以一个空格分隔的只含大小写字母的字符串。与普通字典序不同，按照给定的字母顺序对这组字符串排序。设两个字符串的字母不会完全相同。

#include

#include

char str[2200];

char a[100][21];

int p[27];

char s[27];

int cmp(const void *a,const void *b)

{

char *s1,*s2;char ch1,ch2;

s1=(char *)a;s2=(char *)b;

while(*s1&&*s2)

{

ch1=(*s1)>='a'?*s1-32:*s1; //转换为大写字母

ch2=(*s2)>='a'?*s2-32:*s2; //转换为大写字母

if(p[ch1-'A']!=p[ch2-'A']) //按字母顺序表比较字母

return p[ch1-'A']-p[ch2-'A'];

else {s1++;s2++;}//如果第一个相同比较第二个，第二个相同比较打三个。。。

}

if(*s1==0) return -1;

else return 1;

}

int main()

{

int j,k,q;

while(scanf("%s",s)!=EOF)

{

for(k=0;k<26;k++)

p[s[k]-'A']=k;

getchar();

gets(str);

int count=0,i=0;

while(1)

{ j=0;

while(str[i]!=' '&&str[i]) a[count][j++]=str[i++];//按空格分隔字符串，用二维数组每个字符串中字符的位置

a[count][j]='\0';

count++;

if(!str[i]) break; else i++;}

qsort(a,count,sizeof(a[0]),cmp);

for(q=0;q

printf("%s ",a[q]);

printf("%s\n",a[count-1]);

}

return 0;

}

有 N 行数据，每行有若干数量不等的整数组成。现在要对这 N 行数据排序。排序原则为：首先比较行中的第一个数的值，将第一个数大的行排在前面；若第一个数相等的话，则按照第二个数的值排序（若某行没有第二个数，则该行排在后面）；若第二个数还是相等的话，则比较第三个数，依次类推。

#include

#include

int cmp(const void*a,const void*b)//依次比较

{

int *s1=(int*)a;

int *s2=(int*)b;

while(*s1!=-1&&*s2!=-1){

if(*s1==*s2){

s1++;

s2++;}

else

break;}

return *s2-*s1;

}

int main()

{

int t,i,j,k,n,m;

int data[1001][51];//二维数组存储

scanf("%d",&t);

for(m=0;m

{ scanf("%d",&n);

for(i=0;i

j=0;

while(scanf("%d",&data[i][j])&&data[i][j]!=-1)

j++;

}

qsort(data,n,sizeof(data[0]),cmp);

//printf("case #%d:\n",m);

for(k=0;k

{

for(j=0;data[k][j+1]!=-1;j++)

printf("%d ",data[k][j]);

printf("%d\n",data[k][j]);

}

}

return 0;

}

3036

现在有N 个整数，要求按照64 位二进制补码表示中 1 的位数从大到小进行排序。若两个数的二进制表示中1 的位数相同，则按照数本身值由小到大排序

#include

#include

typedef struct{

long long num;

int one;

}P;

P p[10001];

int cmp(const void*a,const void*b)

{

P* p1=(P*)a;

P* p2=(P*)b;

if(p1->one==p2->one){

if(p1->num>p2->num)

return 1;

if(p1->numnum)

return -1;

if(p1->num==p2->num)

return 0;}

else

return p2->one-p1->one;

}

int func(long long x)//十进制数转化为二进制中1的个数

{

int countx = 0;

while(x)

{

countx ++;

x = x&(x-1);

}

return countx;

}

int main()

{

int t,i,j,k,n;

scanf("%d",&t);

for(i=0;i

{

scanf("%d",&n);

scanf("%lld",&p[0].num);

p[0].one=func(p[0].num);

for(j=1;j

scanf(" %lld",&p[j].num);

p[j].one=func(p[j].num);}

qsort(p,n,sizeof(p[0]),cmp);

printf("case #%d:\n",i);

for(k=0;k

printf("%lld ",p[k].num);

printf("%lld\n",p[n-1].num);

}

return 0;

}

3055

现给定一个由26 个英文字母构成的字符串，请将字符串按照字母使用频率由大到小重排，使用频率大的字母排在前面，使用频率小的字母排在后面，如果使用频率相同则按照字母顺序表排列，小写字母排在大写字母前面，即a->A->b->B->c->C-d->D->……->z->Z。

#include

#include

#include

typedef struct{

char s1;

int plv;//在order中的位置

}alpha;

alpha c[101];

double order[27];

int cmp(const void *a,const void *b)

{

//ch1,ch2为待比较的字母

//p1,p2为ch1,ch2在字母顺序表中的序号

alpha* ch1=(alpha *)a;

alpha* ch2=(alpha *)b;

// if(ch1>='a'&&ch1<='z') p1=ch1-'a'; else p1=ch1-'A';

// if(ch2>='a'&&ch2<='z') p2=ch2-'a'; else p2=ch2-'A';

if(order[ch2->plv]>order[ch1->plv]) return 1; //按照字母使用频率由大到小重排

else if(order[ch2->plv]==order[ch1->plv]) //字母使用频率相同的情况

if(ch1->plv==ch2->plv) return ch2->s1-ch1->s1; //相同字母，小写在大写前面

else return ch1->plv-ch2->plv;

//不同字母，但使用频率相同，则按照字母表顺序排列

else return -1;

}

int find(char ch)//各个字母在order中的位置

{

if(ch>='A'&&ch<='Z')

return ch-'A';

if(ch>='a'&&ch<='z')

return ch-'a';

else

return 1001;

}

int main()

{

int t,i,j,length,k,q;

char s[101];

scanf("%d",&t);

getchar();

for(i=0;i

{

for(k=0;k<25;k++){

scanf("%lf ",&order[k]);}

scanf("%lf",&order[25]);

getchar();

gets(s);

length=strlen(s);

for(j=0;j

c[j].s1=s[j];

c[j].plv=find(c[j].s1);}

qsort(c,length,sizeof(c[0]),cmp);

printf("case #%d:\n",i);

for(q=0;q

printf("%c",c[q].s1);

printf("%c\n",c[length-1].s1);

}

return 0;

}

2844

有n个1到1000之间的整数(1≤n≤100)，对于其中重复的数字，只保留一个，把其余相同的数去掉。然后再按照指定的排序方式把这些数排序。

#include

#define max 1001

void delete(int a[],int j,int m)

{

int i;

for(i=j;i

a[i]=a[i+1];

}//删除某个字符

void paixu(int a[],int m,char c)

{

int i,j,k=0,t;

for(i=0;i

for(j=i+1;j

if(c=='A'){

if(a[i]>a[j])

{

t=a[i];

a[i]=a[j];

a[j]=t;

}}

if(c=='D')

{

if(a[i]

{

t=a[i];

a[i]=a[j];

a[j]=t;

}}

}

j=0;//去重

for(i=0;i

{

if(a[j]==a[j+1])

{

delete(a,j,m);

j--;

k++;

}

j++;

}

printf("%d",a[0]);

for(i=1;i

printf(" %d",a[i]);

printf("\n");

}

int main()

{int a[100],i=0,len=0,cnt;

char c;

char x;

scanf("%c",&x);

getchar();

while(c!='\n'&&c!=EOF){

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

len++;

c=getchar();

i++;

}

cnt=len;

paixu(a,cnt,x);

}

有N 个1 到1000 之间的整数（1≤N≤100），对于其中重复的数，只保留一个，把其余相同的数去掉。然后再按照个位数字进行升序排序，如果个位数字相同，则小的数排在前面。

#include

#include

typedef struct{

int score;

int g;//个位数字

}S;

S s[101];

int gewei(int a)

{

if(a<10)

return a;

else

return a%10;

int cmp(const void*a,const void*b)

{

S *s1=(S*)a;

S *s2=(S*)b;

int detla;

return (detla=s1->g-s2->g)?detla:(s1->score-s2->score);

}

void delete(S a[],int n)//去重

{

int i,j,m=0;

int x[101];

for(i=0;i

for(j=0;j

{

if(a[j].score==a[i].score&&j!=i)

a[j].score=1024;

a[j].g=1024;

}

}

for(j=0;j

if(a[j].score!=1024)

x[m++]=a[j].score;}

printf("%d",x[0]);

for(i=1;i

printf(" %d",x[i]);}

printf("\n");

}

int main()

{

int t,i,j,n;

scanf("%d",&t);

for(i=0;i

{

scanf("%d",&n);

getchar();

scanf("%d",&s[0].score);

s[0].g=gewei(s[0].score);

for(j=1;j

scanf(" %d",&s[j].score);

s[j].g=gewei(s[j].score);

}

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

printf("case #%d:\n",i);

delete(s,n);

}

return 0;

}

2994

给定一个长度为N 的整数数组，按如下规则排序并输出。首先，输出重复出现次数最多的元素；出现次数相同时，按元素值由小到大输出。例如对于数组1 2 3 3 4 2 3 1 5 7 排序后输出3 3 3 1 1 2 2 4 5 7。

#include

#include

typedef struct{

int num;

int p;

}S;

S s[2001];

void plv(S a[],int n)//各个字母出现的次数

{

int j;

int count[2001]={0};

for(j=0;j

{

count[a[j].num]++;

}

for(j=0;j

{

a[j].p=count[a[j].num];

}

}

int cmp(const void*a,const void*b)

{ int detla;

S* s1=(S*)a;

S* s2=(S*)b;

return (detla=s2->p-s1->p)?detla:(s1->num-s2->num);

}

int main()

{

int t,i,j,k,n;

scanf("%d",&t);

for(i=0;i

{scanf("%d",&n);

getchar();

scanf("%d",&s[0].num);

for(j=1;j

scanf(" %d",&s[j].num);}

plv(s,n);

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

printf("case #%d:\n",i);

for(k=0;k

printf("%d ",s[k].num);

printf("%d\n",s[n-1].num);

}

return 0;

}

3021

给定一个句子，要求将其字符重新排序输出，其中的英文字母按照字母表顺序输出，其他字符的顺序和位置不变，输出后的单词长度与原句子相同。

#include

#include

#include

#include

int main()

{

char str[10][200];//二维数组

int i,j;

int t;

int k,m,temp;

int index[200];//英文字母出现的位置

scanf("%d",&t);

gets(str[0]);

for(i=0;i

for(i=0;i

{

gets(str[i]);

for(j=k=0;j

if(str[i][j]>='A'&&str[i][j]<='Z')//保证是字符而不是数字

{

index[k]=j;//记录字符出现的位置

k++;

}

for(j=0;j

for(m=j+1;m

{

if(str[i][index[j]]>str[i][index[m]])

{

temp=str[i][index[m]];

str[i][index[m]]=str[i][index[j]];

str[i][index[j]]=temp;

}

}

printf("case #%d:\n%s\n",i,str[i]);

}

return 0;

}

3039

有N 个整数(-1018≤整数≤1018)，要求按照整数十进制表示的最高位的值从大到小进行排序。若两个数的最高位的值相同，则按照数本身值由小到大排序。

#include

#include

#include

typedef struct{

long long num1;

long long num2;

int h;

}P;

P p[10001];

int high(long long a)//求一个数最高位

{

int result,i;

result=log10(a);

if(result==0)

return a;

else{

long long m=1;

for(i=0;i

{

m=m*10;

}

return a/m;}

}

int cmp1(long long a,long long b)

{ if(a>0&&b>0&&a>b)

return 1;

if(a>0&&b<0)

return 1;

if(a<0&&b<0&&a>b)

return 1;

if(a==b)

return 0;

else

return -1;

}

int cmp(const void*a,const void*b)

{ int detla;

P*p1=(P*)a;

P*p2=(P*)b;

return (detla=p2->h-p1->h)?detla:cmp1(p1->num1,p2->num1); }

int main()

{

int t,i,n,j,k;

scanf("%d",&t);

for(i=0;i

{scanf("%d",&n);

for(j=0;j

{scanf("%lld",&p[j].num1);

if(p[j].num1>0)

p[j].num2=p[j].num1;

else

p[j].num2=-p[j].num1;

p[j].h=high(p[j].num2);

}

qsort(p,n,sizeof(p[0]),cmp);

printf("case #%d:\n",i);

for(k=0;k

printf("%lld ",p[k].num1);

printf("%lld\n",p[n-1].num1);

}

return 0;

}

2031

给你 n(n<=100) 个数，要求你把这 n 个数按照绝对值从小到大排序。多 Case，处理直到文件结束。

#include

#include

typedef struct{

int num1;

int num2;

}P;

P p[10001];

int cmp(const void*a,const void*b)

{

P*p1=(P*)a;

P*p2=(P*)b;

return p1->num2-p2->num2;

}

int main()

{

int t,i,n,j,k;

char c;

while(scanf("%d",&n)!=EOF){

for(j=0;j

{scanf("%d",&p[j].num1);

if(p[j].num1>0)

p[j].num2=p[j].num1;

else

p[j].num2=-p[j].num1;

}

qsort(p,n,sizeof(p[0]),cmp);

for(k=0;k

printf("%d ",p[k].num1);

printf("%d\n",p[n-1].num1);

}

return 0;

}