一 : sort()函数与qsort()函数及其头文件

【转】sort()函数与qsort()函数及其头文件

(2011-07-08 14:00:26)转载▼

标签：杂谈

sort()函数与qsort()函数及其头文件

(2010-02-05 19:38:37)

标签：杂谈

分类：计算机基础知识

今天在看程序时，遇见了sort()这个函数，我在网页上搜了一些资料，整合一下

sort()函数是C++中的排序函数其头文件为：#include<algorithm>头文件；qsort()是C中的排序函数，其头文件为：#include<stdlib.h>

先说一下qsort()吧，搜索到的资料容易懂一些。

六类qsort排序方法

qsort函数很好用，但有时不太会用比如按结构体一级排序、二级排序、字符串排序等。

函数原型：void qsort(void *base,size_t nelem,size_t width,int (*fcmp)(const void*,const void *))

输入参数：

base 待排序的数组，nelem 数组元数的个数（长度），width 每一个元素所占存储空间的大小，fcmp 用于对数组元素进行比较的函数的指针（该函数是要自己写的），返回值为1或-1（p1>p2则返回-1，p1<p2则返回1，p1==p2则返回0），size_t是int

输出参数：base 以升序排列

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

1、对一维数组排序：

（Element_type 是一位数组中存放的数据类型，可以是char,int,float,double,ect）

int comp(const void *p1,const void *p2)

{

return*((Element_type*)p2)>*((Element_type*)p1)?1:-1;

}

int main()

{

Element_type list[MAX];

initial(list);//这是对数组list[max]初始化

qsort(list, sizeof(list),sizeof(Element_type),Comp);//调用函数qsort

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 ? 1 : -1;

}

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

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

struct Node

{

int x;

int y;

}s[100];

//按照x从小到大排序，当x相等时按y从大到小排序（这是3跟4的区别）

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;

}

sort()函数说起来有一点模糊（没有比较系统的总结）

函数Sort()用于对参数整数数组array的元素进行由小到大的选择排序，其中参数n表示array数组中存储的数组元素数。例如，假设数组array中有10个元素，选择排序就是：先将10个数中的最小数与a[0]对换；再将a[1]到a[9]中的最小数与a[1]对换，….，直到排序完成。

这是我在百度上找到的1011题的答案，我觉得用它来说明sort()函数最具有代表性

#include <iostream>

#include <algorithm>

#include <cstdio>

#include <functional>

using namespace std;

int stick[100], n;

bool used[100];

//unused:没有使用的棍子的数目

//left:剩下的长度

//len:当前认为的计算的长度

bool dfs(int unused, int left, int len)

{

// 所有的棍子已经用了，且没有剩余的长度,符合搜索条件

if (unused == 0 && left == 0)

return true;

int i;

//没有剩下的.则新开一条棍子

if (left == 0)

left = len;

//寻找没有使用过的棍子

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

{

//找到没有用过的,而且长度比left值要小(能够填进去)

if (!used && stick<=left)

{

//使用当前棍子

used = true;

//若在当前情况下能够扩展出正确答案,则返回

if (dfs(unused-1, left-stick, len))

//成功搜索,返回

return true;

//否则不使用当前的棍子

used = false;

//若使用stick不能扩展出正确结果,那么如果stick与left等长,则证明len不可能是正确答案

//若left与len等长,就是没有办法扩展

if (stick == left || left == len)

break;

}

}

//经过一轮搜索仍得不到正确答案,则返回false

return false;

}

int main()

{

int i, sum;

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

{

sum = 0;

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

{

scanf("%d", &stick);

used = false;

sum += stick;

}

//先进行从大到小排序

sort(stick, stick+n, greater<int>());

//根据题目条件，从小向大寻找

for (i=stick[0]; i<=sum; ++i)

{

//棍子总长被i整除才进行搜索,否则没用

if (sum % i == 0)

{

if (dfs(n, 0, i))

{

printf("%dn", i);

break;

}

}

}

}

return 0;

}

#include<algorithm>头文件

非修改性序列操作（12个）

循环对序列中的每个元素执行某操作for_each()

查找在序列中找出某个值的第一次出现的位置find()

在序列中找出符合某谓词的第一个元素find_if()

在序列中找出一子序列的最后一次出现的位置find_end()

在序列中找出第一次出现指定值集中之值的位置find_first_of()

在序列中找出相邻的一对值adjacent_find()

计数在序列中统计某个值出现的次数count()

在序列中统计与某谓词匹配的次数count_if()

比较找出两个序列相异的第一个元素

mismatch()两个序列中的对应元素都相同时为真equal()

搜索在序列中找出一子序列的第一次出现的位置search()

在序列中找出一值的连续n次出现的位置search_n()

修改性序列操作（27个）

复制从序列的第一个元素起进行复制copy()

从序列的最后一个元素起进行复制copy_backward()

交换交换两个元素swap()交换指定范围的元素swap_ranges()

交换由迭代器所指的两个元素iter_swap()

变换将某操作应用于指定范围的每个元素transform()

替换用一个给定值替换一些值replace()

替换满足谓词的一些元素replace_if()

复制序列时用一给定值替换元素replace_copy()

复制序列时替换满足谓词的元素replace_copy_if()

填充用一给定值取代所有元素fill()

用一给定值取代前n个元素fill_n()

生成用一操作的结果取代所有元素generate()

用一操作的结果取代前n个元素generate_n()

删除删除具有给定值的元素remove()

删除满足谓词的元素remove_if()

复制序列时删除具有给定值的元素remove_copy()

复制序列时删除满足谓词的元素remove_copy_if()

唯一删除相邻的重复元素unique()

复制序列时删除相邻的重复元素unique_copy()

反转反转元素的次序reverse()

复制序列时反转元素的次序reverse_copy()

环移循环移动元素rotate()

复制序列时循环移动元素rotate_copy()

随机采用均匀分布来随机移动元素random_shuffle()

划分将满足某谓词的元素都放到前面partition()

将满足某谓词的元素都放到前面并维持原顺序stable_partition()

序列排序及相关操作（27个）

排序以很好的平均效率排序sort()

排序，并维持相同元素的原有顺序stable_sort()

将序列的前一部分排好序partial_sort()

复制的同时将序列的前一部分排好序partial_sort_copy()

第n个元素将第n各元素放到它的正确位置nth_element()

二分检索找到大于等于某值的第一次出现lower_bound()

找到大于某值的第一次出现upper_bound()

找到（在不破坏顺序的前提下）可插入给定值的最大范围equal_range()

在有序序列中确定给定元素是否存在binary_search()

归并归并两个有序序列merge()

归并两个接续的有序序列inplace_merge()

有序结构上的集合操作一序列为另一序列的子序列时为真includes()

构造两个集合的有序并集set_union()

构造两个集合的有序交集set_intersection()

构造两个集合的有序差集set_difference()

构造两个集合的有序对称差集（并-交）set_symmetric_difference()

堆操作向堆中加入元素push_heap()

从堆中弹出元素pop_heap()

从序列构造堆make_heap()

给堆排序sort_heap()

最大和最小两个值中较小的min()

两个值中较大的max()

序列中的最小元素min_element()

序列中的最大元素max_element()

词典比较两个序列按字典序的第一个在前lexicographical_compare()

排列生成器按字典序的下一个排列next_permutation()

按字典序的前一个排列prev_permutation()

二 : sort()函数与qsort()函数及其头文件

sort()函数是C++中的排序函数其头文件为：#include<algorithm>头文件；

qsort()是C中的排序函数，其头文件为：#include<stdlib.h>

1、qsort()----六类qsort排序方法

qsort函数很好用，但有时不太会用比如按结构体一级排序、二级排序、字符串排序等。（www.61k.com］ 函数原型：

void qsort(void *base, size_t nelem, size_t width, int (*fcmp)(const void*,const void *)) 输入参数：

Base：待排序的数组

nelem：数组元数的个数（长度）

width：每一个元素所占存储空间的大小

fcmp：用于对数组元素进行比较的函数的指针（该函数是要自己写的），返回值为1或-1（p1>p2则返回-1，p1<p2则返回1，p1==p2则返回0），size_t是int

输出参数：base 以升序排列

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

（1）对一维数组排序：

（Element_type 是一位数组中存放的数据类型，可以是char,int,float,double,ect） int comp(const void *p1,const void *p2)

{

return *((Element_type*)p2)>*((Element_type*)p1)?1:-1;

}

int main()

{

Element_type list[MAX];

initial(list);//这是对数组list[max]初始化

qsort(list, sizeof(list),sizeof(Element_type),Comp);//调用函数qsort

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;

sort函数 sort()函数与qsort()函数及其头文件

int other;

}s[100];

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

{

return (*(Node *)p2)->data > (*（Node *）p1)->data ? 1 : -1;

}

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

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

struct Node

{

int x;

int y;

}s[100];

//按照x从小到大排序，当x相等时按y从大到小排序（这是3跟4的区别）

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]) &&

sort函数 sort()函数与qsort()函数及其头文件

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;

}

2、sort()

sort 对给定区间所有元素进行排序

stable_sort 对给定区间所有元素进行稳定排序

partial_sort 对给定区间所有元素部分排序

partial_sort_copy 对给定区间复制并排序

nth_element 找出给定区间的某个位置对应的元素

is_sorted 判断一个区间是否已经排好序

partition 使得符合某个条件的元素放在前面

stable_partition 相对稳定的使得符合某个条件的元素放在前面

语法描述为：

（1）sort(begin,end)，表示一个范围，例如：

int _tmain(int argc, _TCHAR* argv[])

{

int a[20]={2,4,1,23,5,76,0,43,24,65},i;

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

cout<<a[i]<<endl;

sort(a,a+20);

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

cout<<a[i]<<endl;

return 0;

}

输出结果将是把数组a按升序排序，说到这里可能就有人会问怎么样用它降序排列呢？这就是下一个讨论的内容。［www.61k.com]

（2）sort(begin,end,compare)

一种是自己编写一个比较函数来实现，接着调用三个参数的sort：sort(begin,end,compare)就成了。对于list容器，这个方法也适用，把compare作为sort的参数就可以了，即：sort(compare)。

1）自己编写compare函数：

bool compare(int a,int b)

{

return a<b; //升序排列，如果改为return a>b，则为降序

}

int _tmain(int argc, _TCHAR* argv[])

{

int a[20]={2,4,1,23,5,76,0,43,24,65},i;

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

cout<<a[i]<<endl;

sort(a,a+20,compare);

sort函数 sort()函数与qsort()函数及其头文件

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

cout<<a[i]<<endl;

return 0;

}

2）更进一步，让这种操作更加能适应变化。[www.61k.com)也就是说，能给比较函数一个参数，用来指示是按升序还是按降序排,这回轮到函数对象出场了。

为了描述方便，我先定义一个枚举类型EnumComp用来表示升序和降序。很简单： enum Enumcomp{ASC,DESC};

然后开始用一个类来描述这个函数对象。它会根据它的参数来决定是采用“<”还是“>”。 class compare

{

private:

Enumcomp comp;

public:

compare(Enumcomp c):comp(c) {};

bool operator () (int num1,int num2)

{

switch(comp)

{

case ASC:

return num1<num2;

case DESC:

return num1>num2;

}

}

};

接下来使用 sort(begin,end,compare(ASC))实现升序，sort(begin,end,compare(DESC))实现降序。

主函数为：

int main()

{

int a[20]={2,4,1,23,5,76,0,43,24,65},i;

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

cout<<a[i]<<endl;

sort(a,a+20,compare(DESC));

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

cout<<a[i]<<endl;

return 0;

}

3)其实对于这么简单的任务（类型支持“<”、“>”等比较运算符），完全没必要自己写一个类出来。标准库里已经有现成的了，就在functional里，include进来就行了。functional提供了一堆基于模板的比较函数对象。它们是（看名字就知道意思了）：equal_to<Type>、not_equal_to<Type>、greater<Type>、greater_equal<Type>、less<Type>、less_equal<Type>。

sort函数 sort()函数与qsort()函数及其头文件

对于这个问题来说，greater和less就足够了，直接拿过来用：

升序：sort(begin,end,less<data-type>());

降序：sort(begin,end,greater<data-type>()).

int _tmain(int argc, _TCHAR* argv[])

{

int a[20]={2,4,1,23,5,76,0,43,24,65},i;

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

cout<<a[i]<<endl;

sort(a,a+20,greater<int>());

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

cout<<a[i]<<endl;

return 0;

}

4)既然有迭代器，如果是string 就可以使用反向迭代器来完成逆序排列，程序如下： int main()

{

string str("cvicses");

string s(str.rbegin(),str.rend());

cout << s <<endl;

return 0;

}

这是我在百度上找到的1011题的答案，我觉得用它来说明sort()函数最具有代表性

#include <iostream>

#include <algorithm>

#include <cstdio>

#include <functional>

using namespace std;

int stick[100], n;

bool used[100];

//unused:没有使用的棍子的数目

//left:剩下的长度

//len:当前认为的计算的长度

bool dfs(int unused, int left, int len)

{

// 所有的棍子已经用了，且没有剩余的长度,符合搜索条件

if (unused == 0 && left == 0)

return true;

int i;

//没有剩下的.则新开一条棍子

sort函数 sort()函数与qsort()函数及其头文件

if (left == 0)

left = len;

//寻找没有使用过的棍子

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

{

//找到没有用过的,而且长度比left值要小(能够填进去)

if (!used && stick<=left)

{

//使用当前棍子

used = true;

//若在当前情况下能够扩展出正确答案,则返回

if (dfs(unused-1, left-stick, len))

//成功搜索,返回

return true;

//否则不使用当前的棍子

used = false;

//若使用stick不能扩展出正确结果,那么如果stick与left等长,则证明len不可能是正确答案

//若left与len等长,就是没有办法扩展

if (stick == left || left == len)

break;

}

}

//经过一轮搜索仍得不到正确答案,则返回false

return false;

}

int main()

{

int i, sum;

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

{

sum = 0;

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

{

scanf("%d", &stick);

used = false;

sum += stick;

}

//先进行从大到小排序

sort(stick, stick+n, greater<int>());

//根据题目条件，从小向大寻找

for (i=stick[0]; i<=sum; ++i)

{

//棍子总长被i整除才进行搜索,否则没用

sort函数 sort()函数与qsort()函数及其头文件

if (sum % i == 0)

{

if (dfs(n, 0, i))

{

printf("%d\n", i); break; }

}

}

}

return 0;

}

三 : qsort：qsort-qsort函数简介，qsort-c函数qsort()和bsearch()的用法

qsort的功能是使用快速排序例程进行排序。

qsort_qsort -qsort函数简单介绍

功 能: 使用快速排序例程进行排序
用 法: void qsort(void *base, int nelem, int width, int (*fcmp)(const void *,const void *));
参数：1 待排序数组首地址 2 数组中待排序元素数量 3 各元素的占用空间大小 4 指向函数的指针，用于确定排序的顺序

qsort_qsort -c函数qsort()和bsearch()的用法

使用qsort()排序 并 用 bsearch（）搜索是1个比较常用的组合，使用方便快捷。
qsort 的函数原型是void __cdecl qsort ( void *base,size_tnum, size_t width, int (__cdecl *comp)(const void *, const void* ) )
其中base是排序的1个集合数组，num是这个数组元素的个数，width是1个元素的大小，comp是1个比较函数。
比如：对1个长为1000的数组进行排序时，int a[1000]; 那么base应为a，num应为 1000，width应为 sizeof(int)，comp函数随自己的命名。
qsort(a,1000,sizeof(int ),comp);
其中comp函数应写为:
int comp(const void *a,const void *b)
{
return *(int *)a-*(int *)b;
}
上面是由小到大排序，return *(int *)b-*(int *)a; 为由大到小排序。
是对1个二维数组的进行排序：
int a[1000][2]; 其中按照a[0]的大小进行1个整体的排序，其中a[1]必须和a[0]一起移动交换。
qsort(a,1000,sizeof(int)*2,comp);
int comp(const void *a,const void *b)
{
return ((int *)a)[0]-((int *)b)[0];
}

qsort_qsort -举例

举例1：对结构体排序

char a[1000][20];
qsort(a,1000,sizeof(char)*20,comp);
int comp(const void *a,const void *b )
{
return strcmp((char *)a,(char *)b);
}
对1个结构体进行排序：
typedef struct str
{
char str1[11];
char str2[11];
}str,*stri;
str strin[100001]=;
int compare(const void *a,const void *b)
{
return strcmp( ((str*)a)->str2 , ((str*)b)->str2 );
}
qsort(strin,total,sizeof(str),compare);
#include
using namespace std;
#include <stdlib.h>
#include
int compare( const void *a, const void *b);
char * list[5]= {"cat","car","cab","cap","can"};
int main()

举例2：(C/C++例程)

按字符串长度对字符串进行排序：
#include
#include
#include
#define N 8
using namespace std;
int compare(const void *a,const void *b);
int main(void)
{
int i;
char s[8][10]={"January","February","March","April","May","June","July","September"};
qsort(s,8,sizeof(char)*10,compare);
for(i=0;i<8;i++)
cout<<
return 0;
}
int compare(const void *a,const void *b)
{
if(strlen((char *)a)!=strlen((char *)b))
return strlen((char *)a)-strlen((char*)b);
return (strcmp((char *)a,(char *)b));
}
下面这个例程在VS2008中运行通过，比较具有代表性：
#include
#include
#include
int compare(const void *arg1,const void *arg2);
int main(int argc,char **argv)
{
int i;
argv++;
argc--;
qsort((void *)argv,(size_t)argc,sizeof(char *),compare);
for(i=0;i
printf("%sn",argv);
return 0;
}
int compare(const void *arg1,const void *arg2)
{
return _stricmp(*(char **)arg1,*(char **)arg2);
}
在运行输入cmd,在qsort.exe 参数1 参数2将会排序。

举例3:pascal 例程

program quicksort;
const
max = 100000;
max = 1000;
type
tlist = array[1..max] of longint;
var
data : tlist;
i : longint;
procedure qsort(var a : tlist);
procedure sort(l,r: longint);
var i,j,x,y: longint;
begin
i:=l; j:=r;
x:=a[(l+r) div 2];
repeat
while a[i]
while x
if i<=j then
begin
y:=a[i];a[i]:=a[j];a[j]:=y;
inc(i);dec(j);
end;
until i>j;
if l
if i
end;
begin
sort(1,max);
end;
begin
write('Creating ',Max,' random numbers between 1 and 500000');
randomize;
for i:=1 to max do
data:=random(500000);
writeln;
writeln('Sorting...');
qsort(data);
writeln;
for i:=1 to max do
begin
write(data:7);
if (i mod 10)=0 then
writeln;
end;
end.
下面讲解下Pascal的快排代码
program kuaipai;
var
save:array[-1..10000000]of longint;//保存数字的数组
n,i:longint;
procedure qsort(x,y:longint);
var
a,b,c,em,d,mid,e,i,j,k,l:longint;
begin
i:=x;//i代表第1个数字的数组坐标,下面叫“左指针”
j:=y;//j代表第二个数字的数组坐标 叫"右指针"
mid:=save[(x+y)div 2];//取，这两个数字中间的数组坐标（二分）
repeat
while save[i]
while save[j]>mid do dec(j);//在中间数右边，找比中间数小的数字
if i<=j//如果左指针在右指针左边
then begin
em:=save[i];//交换两个数字的值，这个你会冒泡排序，或者选择排序任意1个，应该明白
save[i]:=save[j];
save[j]:=em;
inc(i);
dec(j);
end;
until i>j;//左指针跑到右指针右边了。。。
if i
if j>x then qsort(x,j);//如果右指针没跑到，左界限，那么从右指针到左界限排序
end;
begin
randomize;//优化程序用的，暂时你不用会
readln(n);//读入，表示有N个数字
for i:=1 to n do//读入这N个数字
read(save[i]);
qsort(1,n);//从第1个数字，到最后1个数字排序
for i:=1 to n do//输出
write(save[i],' ');
end.

举例4:对整型和Double型排序

1个典型的qsort的写法如下qsort(s,n,sizeof(s[0]),cmp);
其中第1个参数是参与排序的数组名(或者也可以理解成开始排序的地址,因为可以写&s[i]这样的表达式);
第二个参数是参与排序的元素个数;
第3个参数是单个元素的大小,推荐使用sizeof(s[0])这样的表达式;
第4个参数就是让很多人觉得非常困惑的比较函数啦,关于这个函数,还要说的比较麻烦...
我们来讨论cmp这个比较函数(写成cmp是我的个人喜好,你可以随便写成什么,比如qcmp什么的).典型的cmp的定义是int cmp(const void *a,const void *b);
返回值必须是int,2个参数的类型必须都是const void *,那个a,b是我随便写的,个人喜好.
假设是对int排序的话,如果是升序,那么就是如果a比b大返回1个正值,小则负值,相等返回
0,其他的依次类推,后面有例子来说明对不同的类型如何进行排序.
下面举例:
No.2.最常见的,对int数组排序
#include
#include
#include
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
scanf("%d",&s[i]);
qsort(s,n,sizeof(s[0]),cmp);
for(i=0;i
printf("%d ",s[i]);
return(0);
}
No.3.对double型数组排序,原理同int这里做个注释,本来是因为要判断如果a==b返回0的,但是严格来说,2个double数是不可能相等的,只能说fabs(a-b)<1e-20之类的这样来判断,所以这里只返回了1和-1
#include
#include
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
scanf("%lf",&s[i]);
qsort(s,n,sizeof(s[0]),cmp);
for(i=0;i
printf("%lf ",s[i]);
return(0);
}

qsort_qsort -qsort图

四 : Qsort函数

http://blog.csdn.net/zhc6211026/archive/2007/12/28/1999062.aspx



关于qsort的使用：qsort对于排序有更好的兼容性，可以对任何数据类型，采取个人需要的排序关键字和排序方法进行升序排序，在stdlib.h中，它的函数原型是

void qsort(void *base, //所要排序的数组第一个元素的地址

size_t nelem, //要排序的元素的个数

size_t width, //要排序的元素的宽度

int cmp(const void *, const void *));//用于比较元素大小的函数名字

这四个参数很烦人，但是写个例子就容易懂了：

int a[10];

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

意思是说将a数组的前n个数排序，sizeof(a[0])说明数据宽度是和a[0]一样的整型数据类型的宽度。第一个参数a也可以写 成&a[0]，因为数组和指针的互换性，他们都是指的a数组的第一个数据的地址。cmp是用来比较大小的函数，比如说你在这里可以设计成升序，降 序，按绝对值比较大小，按struct里的某一个参数比较，或者进行二级排序，qsort以cmp函数返回的值+,0,-认定进行比较的前一个数与后一个 数的关系是>,=,还是<。

const void*使得我们可以对任意数据类型的数组进行排序。使用前要先把这个const void*指针与某个类型的指针关联。例如对整数进行升序排序，就可以这样写cmp函数：

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

return *(int *)a-*(int *)b;

}

当然，要降序排序只需要写成*(int *)b-*(int *)a即可。要对struct进行以其中某一个参数为关键字排序，可以这样写

struct manu{

int b,s,c;

};

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

return ((manu *)a)->b-((manu *)b)->b;

}

Bjarne：有了qsort()为何还要sort()

对于初学者来说，

qsort(array,asize,sizeof(elem),elem_compare);

看上去太古怪了，而且比这个更难理解：

sort(vec.begin(),vec.end());

对于专家来说，在元素与比较方式（comparison criteria）都相同的情况下，sort()比qsort()更快，这是很重要的。而且，qsort()是通用的，所以它可以用于不同容器类型、元素类型、比较方式的任意有意义的组合。举例来说：

struct Record {

string name;

// ...

};

struct name_compare { // 使用"name"作为键比较Record

bool operator()(const Record& a, const Record& b) const

{ return a.name<b.name; }

};

void f(vector<Record>& vs)

{

sort(vs.begin(), vs.end(), name_compare());

// ...

}

而且，很多人欣赏sort()是因为它是类型安全的，使用它不需要进行造型（cast），没有人必须去为基本类型写一个compare()函数。

更多的细节，参见我的文章《将标准C++作为一种新的语言来学习》（Learning C++ as a New language），可以从我的文章列表中找到。

sort()胜过qsort()的主要原因是，比较操作在内联（inlines）上做得更好 本文标题：qsort函数-sort()函数与qsort()函数及其头文件
本文地址： http://www.61k.com/1121670.html