qsort排序
qsort快速排序的整理

qsort快速排序的整理最近⽤到了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);elsereturn((aa->no)-(bb->no));}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.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函数很好⽤,但有时不太会⽤⽐如按结构体⼀级排序、⼆级排序、字符串排序等,故通过查资料将其整理⼀番。
qsort函数在c语言中的含义

一、概述qsort函数是C语言标准库中的一个用于排序数组的函数。
它可以根据用户自定义的比较函数对数组进行排序,是C语言中非常常用的排序函数之一。
二、函数原型qsort函数的函数原型如下:void qsort(void *base, size_t nmemb, size_t size, int (par)(const void *, const void *));其中,参数说明如下:1. base:指向要排序的数组的指针。
2. nmemb:数组中元素的数量。
3. size:数组中每个元素的大小。
4.par:比较函数的指针,用于指定排序时的比较规则。
三、比较函数qsort函数的核心在于比较函数,比较函数的定义如下:intpar(const void* a, const void* b);比较函数接受两个参数a和b,分别指向待比较的数组元素。
比较函数需要根据实际需求编写,它应该按照排序的规则来比较a和b,并返回结果。
比较函数返回值的含义为:- 若a应排在b之前,则返回负值;- 若a应排在b之后,则返回正值;- 若a与b相等,则返回0。
四、函数用法使用qsort函数进行排序的一般步骤如下:1. 定义比较函par,根据排序需求编写比较规则。
2. 调用qsort函数进行排序,示例代码如下:```cintpare(const void* a, const void* b) {return *(int*)a - *(int*)b;}int m本人n() {int arr[] = {4, 2, 8, 5, 1};int len = sizeof(arr) / sizeof(arr[0]);qsort(arr, len, sizeof(int),pare);return 0;}```这段示例代码演示了如何使用qsort函数对整型数组进行升序排序。
五、注意事项在使用qsort函数时,需要注意以下几点:1. 比较函数的正确性和效率会直接影响排序结果和性能,因此需要仔细编写和测试比较函数。
qsort,sort排序

C语言标准库函数qsort详解qsort包含在<stdlib.h>头文件中,此函数根据你给的比较条件进行快速排序,通过指针移动实现排序。
排序之后的结果仍然放在原数组中。
使用qsort函数必须自己写一个比较函数。
函数原型:void qsort ( void * base, size_t num, size_t size, int ( * comparator ) ( const void *, const void * ) );指向任意数据类型的指针都可以转换为void*类型用法以及参数说明:Sorts the num elements of the array pointed by base, each element size bytes long, using the comparator function to determine the order.The sorting algorithm used by this function compares pairs of values by calling the specified comparator function with two pointers to elements of the array.The function does not return any value, but modifies the content of the array pointed by base reordering its elements to the newly sorted order.base Pointer to the first element of the array to be sorted.(数组起始地址)num Number of elements in the array pointed by base.(数组元素个数)size Size in bytes of each element in the array.(每一个元素的大小)comparator Function that compares two elements.(函数指针,指向比较函数)1、The function must accept two parameters that are pointers to elements, type-casted as void*. These parameters should be cast back to some data type and be compared.2、The return value of this function should represent whether elem1 is considered less than, equal to, or greater than elem2 by returning, respectively, a negative value, zero or a positive value. Return Value none (无返回值)给你们的C++帮助文档上面的语法及定义是:语法:对buf指向的数据(包含num项,每项的大小为size)进行快速排序。
qsort的用法

qsort的用法
qsort是C语言中的一个函数,用于对数组元素进行排序。
它的用法可以参考下面的示例代码:
```c
#include <stdio.h>
#include <stdlib.h>
int compare(const void *a, const void *b) {
return *(int*)a - *(int*)b;
}
int main() {
int arr[] = { 4, 2, 8, 0, 5, 7, 1, 3, 9, 6 };
int n = sizeof(arr) / sizeof(arr[0]);
qsort(arr, n, sizeof(int), compare);
for (int i = 0; i < n; i++) {
printf('%d ', arr[i]);
}
return 0;
}
```
在该代码中,我们定义了一个整数数组arr,它包含10个随机值。
然后我们调用qsort来对数组进行排序。
qsort需要四个参数:要排序的数组的起始地址,数组中元素的数量,每个元素的字节数,
以及一个比较函数。
比较函数是用来比较数组元素的大小的,它需要接受两个指向数组元素的指针,并返回一个整数值,表示它们的相对大小。
在上面的示例中,我们定义了一个名为compare的比较函数,它将两个整数指针转换为整数,并返回它们的差值。
这个函数用在qsort函数中,以决定数组元素的顺序。
最后,我们使用for 循环打印排好序的数组。
qsort排序原理

qsort排序原理
qsort是一种快速排序算法,它的原理是通过递归将待排序的数组分成两个子数组,一个子数组的所有元素都小于另一个子数组的所有元素。
然后对两个子数组分别进行排序,最终将两个子数组合并起来得到有序的数组。
具体的原理如下:
1. 选择一个基准元素(通常是数组的第一个元素)。
2. 将所有小于基准元素的元素放在基准元素的左边,将所有大于基准元素的元素放在基准元素的右边,形成两个子数组。
3. 对两个子数组递归地重复步骤1和步骤2,直到子数组的长度为1或0。
4. 将两个子数组合并起来,得到最终排序的数组。
快速排序的关键在于如何选择基准元素和如何将元素重新排列。
一种常用的选择基准元素的方法是取数组的第一个元素,然后通过比较将小于它的元素放到它的左边,将大于它的元素放到它的右边。
这样,基准元素就被放置在了它最终的位置上。
然后对左右两个子数组分别重复这个过程,直到子数组的长度为1或0。
快速排序的时间复杂度为O(nlogn),其中n是待排序的数组长度。
这是因为每次递归将数组划分成两个大小大致相等的子数组,而对这两个子数组的排序都可以通过递归实现。
所以,每次递归的时间复杂度是O(n),一共需要递归logn次,
所以总的时间复杂度是O(nlogn)。
qsort排序函数

qsort排序函数qsort函数是C语言标准库中的一个函数,用于对数组进行快速排序。
它的原型为:void qsort(void base, size_t num, size_t size, int (compar)(const void , const void ));参数解释:void base,指向要排序的数组的指针。
size_t num,数组中的元素个数。
size_t size,数组中每个元素的大小(以字节为单位)。
int (compar)(const void , const void ),指向比较函数的指针。
比较函数的原型为:int compar(const void a, const void b);qsort函数使用快速排序算法对数组进行排序。
快速排序是一种高效的排序算法,它通过递归地将数组分成较小的子数组,然后对子数组进行排序以实现整体的排序。
在实际使用中,可以根据具体的需求编写比较函数,以指定排序的规则。
使用qsort函数时需要注意以下几点:1. 确保比较函数的正确性,比较函数需要满足传递性、反对称性和传递性的要求,否则排序结果可能不正确。
2. 确保数组指针和元素大小的正确性,传递给qsort函数的数组指针和元素大小需要正确,否则可能导致未定义的行为。
3. 注意内存管理,在使用qsort函数时,需要注意数组内存的分配和释放,以避免内存泄漏和越界访问等问题。
总之,qsort函数是C语言中用于对数组进行快速排序的标准库函数,通过合理编写比较函数和正确传递参数,可以实现对数组的高效排序。
在实际应用中,需要注意算法的稳定性、性能和内存管理等方面的问题,以确保排序的正确性和效率。
c qsort函数

c qsort函数C语言是一种习惯使用数组的编程语言,在操作数组时,排序无疑是一个非常重要的操作。
在C语言中,有一个非常方便的函数可以用来实现排序的操作,那就是qsort函数。
本文将围绕qsort函数,为大家详细讲解它的原理以及具体用法。
一、qsort函数的原理qsort函数的原理很简单,就是使用快速排序算法来对数组进行排序,快排这种算法最大的优点就是速度非常快,并且在实际操作中对于大多数数据集都能得到很好的效果。
二、qsort函数的具体用法qsort函数的具体用法如下:void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));参数说明:1.base:要排序的数组的第一个元素的指针。
2.nmemb:要排序的数组的元素个数。
3.size:数组中每个元素的大小,即每个元素占用的字节数。
par:指向两个元素比较函数的指针。
其中,第四个参数是一个指向两个元素比较函数的指针。
这个函数的作用就是对两个元素进行比较,如果第一个元素应该排在第二个元素之前,则返回一个负数;如果两个元素相等,则返回0;如果第一个元素应该排在第二个元素之后,则返回一个正数。
下面是一个比较简单的例子:#include<stdio.h>#include<stdlib.h>int compare(const void *a, const void *b){return (*(int*)a - *(int*)b);}int main(){int arr[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };int n = sizeof(arr) / sizeof(arr[0]);qsort(arr, n, sizeof(int), compare);printf("Sorted array: ");for (int i = 0; i < n; i++)printf("%d ", arr[i]);return 0;}这个例子中,首先定义了一个整型数组,然后定义了一个compare函数,用来比较两个元素的大小。
qsort的七种排序方法

//按照x从小到大排序,当x相等时按照y从大到小排序 Sample: 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的字典顺序排序 Sample: int cmp ( const void *a , const void *b ) { return strcmp( ((In *)a)->str , ((In *)b)->str ); } qsort(s,100,sizeof(s[0]),cmp); 七、计算几何中求凸包的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; } PS: 其中的qsort函数包含在<stdlib.h>的头文件里,strcmp包含在<string.h>的头文件里.
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
发信人: snoopy (阿排/好好玩ICPC~), 信区: ACM_ICPC标题: 快排qsort的用法详解发信站: 珞珈山水BBS站(Sat Apr 29 21:02:35 2006), 转信很多人问这个东西.我以前也看了好久,今天翻到以前学快排的时候写的练习code,基本上能覆盖绝大部分用法了.里面有很多地方没判断相等的情况,按道理来说相等情况下应该返回0的,这个请看代码的时候注意.我尽量保证代码不出错了.下面的这些说明和问题都是个人原创,没查什么资料,所以不保证其完全正确性,在此表示个人不对出现的问题负任何责任,大家WA了或者干吗的不要怪我,不过至少目前来说我用起来是没问题的:)/*----------------------------------------------------------------------------*/ ** 关于快排函数的一些说明**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]);}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]);}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);}void main(){scanf("%s",s);n=strlen(s);qsort(s,n,sizeof(s[0]),cmp);printf("%s\n",s);}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);elsereturn((aa->no)-(bb->no));}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.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);}。