qsort快速排序的整理

小咪咪 2022-08-13 14:58 192阅读 0赞

最近用到了qsort,简单整理一下，方便以后的查找

qsort,包含在stdlib.h头文件里,函数一共四个参数,没返回值.一个典型的qsort的写法如下

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

其中第一个参数是参与排序的数组名(或者也可以理解成开始排序的地址,因为可以写&s\[i\]  
这样的表达式,这个问题下面有说明); 第二个参数是参与排序的元素个数; 第三个三数是  
单个元素的大小,推荐使用sizeof(s\[0\])这样的表达式,下面也有说明 :) ;第四个参数就是  
很多人觉得非常困惑的比较函数啦,关于这个函数,还要说的比较麻烦...

我们来讨论cmp这个比较函数(写成cmp是我的个人喜好,你可以随便写成什么,比如qcmp什么  
的).典型的cmp的定义是

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

返回值必须是int,两个参数的类型必须都是const void \*,那个a,b是我随便写的,个人喜好.  
假设是对int排序的话,如果是升序,那么就是如果a比b大返回一个正值,小则负值,相等返回  
0,其他的依次类推,后面有例子来说明对不同的类型如何进行排序.

在函数体内要对a,b进行强制类型转换后才能得到正确的返回值,不同的类型有不同的处理  
方法.具体情况请参考后面的例子.

\*\* 关于快排的一些小问题 \*\*

1.快排是不稳定的,这个不稳定一个表现在其使用的时间是不确定的,最好情况(O(n))和最  
坏情况(O(n^2))差距太大,我们一般说的O(nlog(n))都是指的是其平均时间.

2.快排是不稳定的,这个不稳定表现在如果相同的比较元素,可能顺序不一样,假设我们有  
这样一个序列,3,3,3,但是这三个3是有区别的,我们标记为3a,3b,3c,快排后的结果不一定  
就是3a,3b,3c这样的排列,所以在某些特定场合我们要用结构体来使其稳定(No.6的例子就  
是说明这个问题的)

3.快排的比较函数的两个参数必须都是const void \*的,这个要特别注意,写a和b只是我的  
个人喜好,写成cmp也只是我的个人喜好.推荐在cmp里面重新定义两个指针来强制类型转换,  
特别是在对结构体进行排序的时候

4.快排qsort的第三个参数,那个sizeof,推荐是使用sizeof(s\[0\])这样,特别是对结构体,  
往往自己定义2\*sizeof(int)这样的会出问题,用sizeof(s\[0)既方便又保险

5.如果要对数组进行部分排序,比如对一个s\[n\]的数组排列其从s\[i\]开始的m个元素,只需要  
在第一个和第二个参数上进行一些修改:qsort(&s\[i\],m,sizeof(s\[i\]),cmp);

\*\* 标程,举例说明 \*\*

No.1.手工实现QuickSort  
\#include <stdio.h>

int a\[100\],n,temp;

void QuickSort(int h,int t)  
\{  
     if(h>=t) return;  
     int mid=(h+t)/2,i=h,j=t,x;  
     x=a\[mid\];  
     while(1)  
     \{  
         while(a\[i\]<x) i++;  
         while(a\[j\]>x) j--;  
         if(i>=j) break;  
         temp=a\[i\];  
         a\[i\]=a\[j\];  
         a\[j\]=temp;  
     \}  
     a\[mid\]=a\[j\];  
     a\[j\]=x;  
     QuickSort(h,j-1);  
     QuickSort(j+1,t);  
     return;  
\}

int main()  
\{  
     int i;  
     scanf("%d",&n);  
     for(i=0;i<n;i++) scanf("%d",&a\[i\]);  
     QuickSort(0,n-1);  
     for(i=0;i<n;i++) printf("%d ",a\[i\]);

return(0);  
\}

No.2.最常见的,对int数组排序  
\#include <stdio.h>  
\#include <string.h>  
\#include <stdlib.h>

int s\[10000\],n,i;

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

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

No.3.对double型数组排序,原理同int

这里做个注释,本来是因为要判断如果a==b返回0的,但是严格来说,两个double数是不可能相  
等的,只能说fabs(a-b)<1e-20之类的这样来判断,所以这里只返回了1和-1  
\#include <stdio.h>  
\#include <stdlib.h>

double s\[1000\];  
int i,n;

int cmp(const void \* a, const void \* b)  
\{  
     return((\*(double\*)a-\*(double\*)b>0)?1:-1);  
\}

int main()  
\{  
     scanf("%d",&n);  
     for(i=0;i<n;i++) scanf("%lf",&s\[i\]);

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

for(i=0;i<n;i++) printf("%lf ",s\[i\]);

return(0);  
\}

No.4.对一个字符数组排序.原理同int  
\#include <stdio.h>  
\#include <string.h>  
\#include <stdlib.h>

char s\[10000\],i,n;

int cmp(const void \*a,const void \*b)  
\{  
     return(\*(char \*)a-\*(char \*)b);  
\}

int main()  
\{  
     scanf("%s",s);  
     n=strlen(s);  
     qsort(s,n,sizeof(s\[0\]),cmp);

printf("%s",s);  
     return(0);  
\}

No.5.对结构体排序

注释一下.很多时候我们都会对结构体排序,比如校赛预选赛的那个樱花,一般这个时候都在  
cmp函数里面先强制转换了类型,不要在return里面转,我也说不清为什么,但是这样程序会  
更清晰,并且绝对是没错的. 这里同样请注意double返回0的问题

\#include <stdio.h>  
\#include <stdlib.h>

struct node  
\{  
     double date1;  
     int no;  
\} s\[100\];

int i,n;

int cmp(const void \*a,const void \*b)  
\{  
     struct node \*aa=(node \*)a;  
     struct node \*bb=(node \*)b;  
     return(((aa->date1)>(bb->date1))?1:-1);  
\}

int main()  
\{  
     scanf("%d",&n);  
     for(i=0;i<n;i++)  
     \{  
         s\[i\].no=i+1;  
         scanf("%lf",&s\[i\].date1);  
     \}  
     qsort(s,n,sizeof(s\[0\]),cmp);

for(i=0;i<n;i++) printf("%d   %lf/n",s\[i\].no,s\[i\].date1);

return(0);  
\}

No.6.对结构体排序.加入no来使其稳定(即data值相等的情况下按原来的顺序排)

\#include <stdio.h>  
\#include <stdlib.h>

struct node  
\{  
     double date1;  
     int no;  
\} s\[100\];

int i,n;

int cmp(const void \*a,const void \*b)  
\{  
     struct node \*aa=(node \*)a;  
     struct node \*bb=(node \*)b;  
     if(aa->date1!=bb->date1)  
         return(((aa->date1)>(bb->date1))?1:-1);  
     else  
         return((aa->no)-(bb->no));  
\}

for(i=0;i<n;i++) printf("%d   %lf/n",s\[i\].no,s\[i\].date1);

return(0);  
\}

No.7.对字符串数组的排序(char s\[\]\[\]型)

\#include <stdio.h>  
\#include <string.h>  
\#include <stdlib.h>

char s\[100\]\[100\];  
int i,n;

int cmp(const void \*a,const void \*b)  
\{  
     return(strcmp((char\*)a,(char\*)b));  
\}

int main()  
\{  
     scanf("%d",&n);  
     for(i=0;i<n;i++) scanf("%s",s\[i\]);

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

for(i=0;i<n;i++) printf("%s/n",s\[i\]);

return(0);  
\}

No.8.对字符串数组排序(char \*s\[\]型)  
\#include <stdio.h>  
\#include <string.h>  
\#include <stdlib.h>

char \*s\[100\];  
int i,n;

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

\{  
     return(strcmp(\*(char\*\*)a,\*(char\*\*)b));  
\}

int main()  
\{  
     scanf("%d",&n);  
     for(i=0;i<n;i++)  
     \{  
         s\[i\]=(char\*)malloc(sizeof(char\*));  
         scanf("%s",s\[i\]);  
     \}

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

for(i=0;i<n;i++) printf("%s/n",s\[i\]);

return(0);  
\}

\#include<iostream>  
\#include <stdlib.h>  
using namespace std;

int Comp(const void \*p1,const void \*p2)  
\{  
return \*((int \*)p2) - \*((int \*)p1);  
\}

int main()  
\{  
int a\[50\],n,i;  
while(cin>>n)  
\{  
   for(i=0;i<n;i++)  
          cin>>a\[i\];  
   qsort(a,n,sizeof(a\[0\]),Comp);  
   for(i=0;i<n;i++)  
    cout<<a\[i\]<<" ";  
\}  
\}

/\*六类qsort排序方法

前一段时间做题觉得qsort函数很好用，但有时不太会用比如按结构体一级排序、二级排序、字符串排序等，故通过查资料将其整理一番。

以下是其具体分类及用法(若无具体说明是以降序排列)：

1、对一维数组排序：

（Element\_type是一位数组中存放的数据类型，可以是char, int, float, double, etc ）

int Comp(const void \*p1,const void \*p2 )

return \*((Element\_type \*)p2) > \*((Element\_type \*)p1)

int main()

\{  
Element\_type list\[MAX\];

initial(list);

qsort(list, sizeof(list),sizeof(Element\_type),Comp);

return 0;

2、对字符串排序：

int Comp(const void \*p1,const void \*p2)

return strcmp((char \*)p2,(char \*)p1);

int main()

char a\[MAX1\]\[MAX2\];

initial(a);

qsort(a,lenth,sizeof(a\[0\]),Comp);  
\}  
//lenth 为数组a的长度

3、按结构体中某个关键字排序（对结构体一级排序）：

struct Node

double data;

int other;

\}s\[100\];

int Comp(const void \*p1,const void \*p2)

return (\*(Node \*)p2)->data-(\*（Node \*）p1)->data;

qsort(s,100,sizeof(s\[0\]),Comp);

4、按结构体中多个关键字排序（对结构体多级排序）\[以二级为例\]：

struct Node

\{  
int   x;

int y;

\}s\[100\];

//按照x从小到大排序，当x相等时按y从大到小排序

int Comp(const void \*p1,const void \*p2)

struct Node   \*c = (Node \*)p1;

struct Node \*d = (Node \*)p2;

if(c->x != d->x) return c->x-d->x;

else return d->y - c->y;

5、对结构体中字符串进行排序：

struct Node

int data;

char str\[100\];

\}s\[100\];

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

int Comp(const void \*p1,const void \*p2)

return strcmp((\*(Node \*)p1)->str,(\*(Node \*)p2)->str);

qsort(s,100,sizeof(s\[0\],Comp);

6、计算几何中求凸包的Comp

//以下是俺从别人那儿抄来的，暂时还没用过

int Comp(const void \*p1,const void \*p2)

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

struct point   \*c=(point \*)p1;

struct point \*d=(point \*)p2;

if( cacl(\*c, \*d,p\[1\]) < 0) return 1;

else if(!cacl(\*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;

P.S.:qsort函数是ANSI   C标准中提供的，其声明在stdlib.h文件中，是根据二分发写的，其时间复杂度为n\*log(n),其结构为：

void qsort(void \*base,size\_t nelem,size\_t width,int (\*Comp)(const void \*,const void \*));

其中：

\*base 为要排序的数组

nelem 为要排序的数组的长度

width 为数组元素的大小（一字结为单位）

（\* Comp）(const void \*p1,const void \*p2) 为判断大小函数的指针，这个函数需要自己定义，如果p1>p2,函数返回-1；a<b,函数返回1；a==b函数返回0。

//  
又见qsort--------zju2727  
一道按给定关键字三级排序题，直接套入曾总结过的qsort模型就AC了。算是上次总结的一个补充实例吧。  
源代码：  
\#include <stdio.h>  
\#include <stdlib.h>  
\#include <string.h>

struct Node\{  
     char Name\[100\];  
     int Year,Price;  
\}Book\[100\];  
/\*----------------------------------------------------------------------------\*/  
/\*int CompY(const void \*p1,const void \*p2)//首先按year排序  
     \{  
         struct Node   \*c = (Node \*)p1;  
         struct Node \*d = (Node \*)p2;  
         if(c->Year != d->Year) return c->Year-d->Year;  
         else if(strcmp((\*(Node \*)p1).Name,(\*(Node \*)p2).Name))  
             return strcmp((\*(Node \*)p1).Name,(\*(Node \*)p2).Name);  
         else return c->Price-d->Price;  
     \}

int CompP(const void \*p1,const void \*p2)//首先按price排序  
     \{  
         struct Node   \*c = (Node \*)p1;  
         struct Node \*d = (Node \*)p2;  
         if(c->Price != d->Price) return c->Price-d->Price;  
         else if(strcmp((\*(Node \*)p1).Name,(\*(Node \*)p2).Name))  
             return strcmp((\*(Node \*)p1).Name,(\*(Node \*)p2).Name);  
         else return c->Year-d->Year;  
     \}  
      
int CompN(const void \*p1,const void \*p2)//首先按name排序  
     \{  
         struct Node   \*c = (Node \*)p1;  
         struct Node \*d = (Node \*)p2;  
         if(strcmp((\*(Node \*)p1).Name,(\*(Node \*)p2).Name))  
             return strcmp((\*(Node \*)p1).Name,(\*(Node \*)p2).Name);  
         else if(c->Year != d->Year) return c->Year-d->Year;  
         else return c->Price-d->Price;  
     \}      
/\*-------------------------------------------------------------------\*/          
/\*void outres(int n)  
\{  
     int i;  
     for(i=0;i<n;i++)  
         printf("%s %d %d/n",Book\[i\].Name,Book\[i\].Year,Book\[i\].Price);  
\}  
/\*-----------------------------------------------------------------\*/  
/\*int main()  
\{  
     int n;  
     char format\[15\];  
     //freopen("in.txt","r",stdin);  
     scanf("%d",&n);  
     while(n)  
     \{  
         for(int i=0;i<n;i++)  
             scanf("%s%d%d",Book\[i\].Name,&Book\[i\].Year,&Book\[i\].Price);  
         scanf("%s",format);  
         if(format\[0\]=='Y')  
         \{  
             qsort(Book, n, sizeof(Book\[0\]), CompY);  
         \}  
         else if(format\[0\]=='P')  
         \{  
             qsort(Book, n, sizeof(Book\[0\]), CompP);  
         \}  
         else  
         \{  
             qsort(Book, n, sizeof(Book\[0\]), CompN);  
         \}

outres(n);  
         scanf("%d",&n);  
         if(n)printf("/n");  
     \}  
     return 0;  
\}

\*/