qsort 排序方法总结

本文中排序都是采用的从小到大排序

1)对int类型数组排序

 

  
    

   
     int
   
      num[
   
     100
   
     ];

   
     int
   
      cmp ( 
   
     const
   
      
   
     void
   
      
   
     *
   
     a , 
   
     const
   
      
   
     void
   
      
   
     *
   
     b )
{
 
   
     return
   
      
   
     *
   
     (
   
     int
   
      
   
     *
   
     )a 
   
     -
   
      
   
     *
   
     (
   
     int
   
      
   
     *
   
     )b;
}
qsort(num,
   
     100
   
     ,
   
     sizeof
   
     (num[
   
     0
   
     ]),cmp);
  
    

 

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

 

 

  
    

   
     
   
     char
   
      word[
   
     100
   
     ];

   
     int
   
      cmp( 
   
     const
   
      
   
     void
   
      
   
     *
   
     a , 
   
     const
   
      
   
     void
   
      
   
     *
   
     b )
{
 
   
     return
   
      
   
     *
   
     (
   
     char
   
      
   
     *
   
     )a 
   
     -
   
      
   
     *
   
     (
   
     char
   
      
   
     *
   
     )b;
}
qsort(word,
   
     100
   
     ,
   
     sizeof
   
     (word[
   
     0
   
     ]),cmp);
  
    

 

3）对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)；
  
    

 

4）对结构体一级排序

 

 

  
    

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

 

5）对结构体二级排序

 

 

  
    

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

 

6）对字符串进行排序

 

 

  
    

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

 

7）计算几何中求凸包的cmp

 

  
    

   
     
   
     //
   
     重点cmp函数，把除了1点外的所有点，旋转角度排序
   
     

   
     int
   
      cmp(
   
     const
   
      
   
     void
   
      
   
     *
   
     a,
   
     const
   
      
   
     void
   
      
   
     *
   
     b)
{
 
   
     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
   
     ;
}
  
    

 

注意一点，在进行比较的时候使用 *(int *)a - *(int *)b是有bug的，当a达到int的最小值(-2^31),b达到int的最大值(2^31 - 1)，会溢出，结果就不对