qsort sort 结构体排序

qsort

函数原型：

voidqsort( void *base, size_t num, size_t width, int (__cdecl *compare )

int  compare (const void *elem1, const void *elem2 ) );

sort

函数原型：

void sort (RandomAccessIterator first, RandomAccessIterator last);

void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp)

Compare cmp(elemtype a,elemtype b)

qorst 排序总结

一：int 型 char型 double型（基本类型）

int  num[100];
int  cmp ( const void *a , const void *b )

{
   return *(int *)a - *(int *)b;  //升序排序
 //return*(int *)b - *(int *)a; //降序排序
/*可见：参数列表是两个空指针，现在他要去指向你的数组元素。所以转型为你当前的类型，然后取值
 实质：根据返回值判断前后顺序
*/
}
qsort(s,n,sizeof(s[0]),cmp);

验证程序:

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

int s[10000],n,i;

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

{

      return(*(int *)b-*(int *)a);  //实现的是升序排序

}

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);

}

char

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;

//返回值的问题，显然cmp返回的是一个整型，所以避免double返回小数而被丢失，用一个判断返回值。

}

qsort(in,100,sizeof(in[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);

二: 结构体排序

一级排序：

struct In

{

   double data;

    int index;

}s[100]

 

//按照data的值从小到大将结构体排序,关于结构体内的排序关键数据data的类型可以很多种，参考上面的例子写

 

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

{

    return (*(In *)a).data > (*(In *)b).data ? 1 : -1;

   //注意，这条语句在VC6.0环境下运行可能会出错，但是并不是语句错了，而是你要先 Build ，或者全部重建。总之语句是对的。

   /*

    或者你可以将这上面1条语句改成下面这3条语句

   struct In *aa = (In *)a;

   struct In *bb = (In *)b;

   return aa->data > bb->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);

 

sort

sort相对qosrt使用简单，下面一个例子，解决所有问题。

NYOJ 966 不相交子区间

#include<stdio.h>

#include<algorithm> //引入包含sort函数的头文件

using namespace std;//引入sort函数

typedef struct node

{

   int begin;

   int end;

}data[1001];

bool cmp(node a,node b)

{

    if(a.end==b.end) return a.begin>b.begin;

    return a.end<b.end;

}

data a;

int main()

{

    int n,i,count,k=1;

    node x;

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

    {

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

        {

            scanf("%d%d",&x.begin,&x.end);

            if(x.begin>x.end) swap(x.begin,x.end);

            a[i].begin=x.begin;

            a[i].end=x.end;

        }

        sort(a,a+n,cmp);

        count=1;

        int temp=a[0].end;

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

        {

            if(a[i].begin>temp)

            {

                count++;

                temp=a[i].end;

            }

        }

        printf("Case %d:\n",k++);

        printf("%d.\n",count);

    }

    return 0;

}