详细解说 STL 排序.docx

详细解说 STL 排序.docx

《详细解说 STL 排序.docx》由会员分享，可在线阅读，更多相关《详细解说 STL 排序.docx（15页珍藏版）》请在冰豆网上搜索。

详细解说STL排序

详细解说STL排序（Sort）

作者Winter

ZT:

http:

//www.stlchina.org/twiki/bin/view.pl/Main/STLSortAlgorithms

∙详细解说STL排序（Sort）

o0前言:

STL，为什么你必须掌握

o1STL提供的Sort算法

▪1.1所有sort算法介绍

▪1.2sort中的比较函数

▪1.3sort的稳定性

▪1.4全排序

▪1.5局部排序

▪1.6nth_element指定元素排序

▪1.7partition和stable_partition

o2Sort和容器

o3选择合适的排序函数

o4小结

o5参考文档

一切复杂的排序操作，都可以通过STL方便实现!

0前言:

STL，为什么你必须掌握

对于程序员来说，数据结构是必修的一门课。

从查找到排序，从链表到二叉树，几乎所有的算法和原理都需要理解，理解不了也要死记硬背下来。

幸运的是这些理论都已经比较成熟，算法也基本固定下来，不需要你再去花费心思去考虑其算法原理，也不用再去验证其准确性。

不过，等你开始应用计算机语言来工作的时候，你会发现，面对不同的需求你需要一次又一次去用代码重复实现这些已经成熟的算法，而且会一次又一次陷入一些由于自己疏忽而产生的bug中。

这时，你想找一种工具，已经帮你实现这些功能，你想怎么用就怎么用，同时不影响性能。

你需要的就是STL,标准模板库！

西方有句谚语：

不要重复发明轮子！

STL几乎封装了所有的数据结构中的算法，从链表到队列，从向量到堆栈，对hash到二叉树，从搜索到排序，从增加到删除......可以说，如果你理解了STL，你会发现你已不用拘泥于算法本身，从而站在巨人的肩膀上去考虑更高级的应用。

排序是最广泛的算法之一，本文详细介绍了STL中不同排序算法的用法和区别。

1STL提供的Sort算法

C++之所以得到这么多人的喜欢，是因为它既具有面向对象的概念，又保持了C语言高效的特点。

STL排序算法同样需要保持高效。

因此，对于不同的需求，STL提供的不同的函数，不同的函数，实现的算法又不尽相同。

1.1所有sort算法介绍

所有的sort算法的参数都需要输入一个范围，[begin,end）。

这里使用的迭代器（iterator）都需是随机迭代器（RadomAccessIterator）,也就是说可以随机访问的迭代器，如：

it+n什么的。

（partition和stable_partition除外）

如果你需要自己定义比较函数，你可以把你定义好的仿函数（functor）作为参数传入。

每种算法都支持传入比较函数。

以下是所有STLsort算法函数的名字列表:

函数名

功能描述

sort

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

stable_sort

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

partial_sort

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

partial_sort_copy

对给定区间复制并排序

nth_element

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

is_sorted

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

partition

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

stable_partition

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

其中nth_element是最不易理解的，实际上，这个函数是用来找出第几个。

例如：

找出包含7个元素的数组中排在中间那个数的值，此时，我可能不关心前面，也不关心后面，我只关心排在第四位的元素值是多少。

1.2sort中的比较函数

当你需要按照某种特定方式进行排序时，你需要给sort指定比较函数，否则程序会自动提供给你一个比较函数。

vectorvect;

//...

sort（vect.begin（）,vect.end（））;

//此时相当于调用

sort（vect.begin（）,vect.end（）,less（））;

上述例子中系统自己为sort提供了less仿函数。

在STL中还提供了其他仿函数，以下是仿函数列表:

名称

功能描述

equal_to

相等

not_equal_to

不相等

less

小于

greater

大于

less_equal

小于等于

greater_equal

大于等于

需要注意的是，这些函数不是都能适用于你的sort算法，如何选择，决定于你的应用。

另外，不能直接写入仿函数的名字，而是要写其重载的（）函数：

less（）

greater（）

当你的容器中元素时一些标准类型（intfloatchar）或者string时，你可以直接使用这些函数模板。

但如果你时自己定义的类型或者你需要按照其他方式排序，你可以有两种方法来达到效果：

一种是自己写比较函数。

另一种是重载类型的'<'操作赋。

#include

#include

#include

#include

usingnamespacestd;

classmyclass{

public:

myclass（inta,intb）:

first（a）,second（b）{}

intfirst;

intsecond;

booloperator<（constmyclass&m）const{

returnfirst

}

};

boolless_second（constmyclass&m1,constmyclass&m2）{

returnm1.second

}

intmain（）{

vectorvect;

for（inti=0;i<10;i++）{

myclassmy（10-i,i*3）;

vect.push_back（my）;

}

for（inti=0;i

cout<<"（"<

sort（vect.begin（）,vect.end（））;

cout<<"aftersortedbyfirst:

"<

for（inti=0;i

cout<<"（"<

cout<<"aftersortedbysecond:

"<

sort（vect.begin（）,vect.end（）,less_second）;

for（inti=0;i

cout<<"（"<

return0;

}

知道其输出结果是什么了吧：

（10,0）

（9,3）

（8,6）

（7,9）

（6,12）

（5,15）

（4,18）

（3,21）

（2,24）

（1,27）

aftersortedbyfirst:

（1,27）

（2,24）

（3,21）

（4,18）

（5,15）

（6,12）

（7,9）

（8,6）

（9,3）

（10,0）

aftersortedbysecond:

（10,0）

（9,3）

（8,6）

（7,9）

（6,12）

（5,15）

（4,18）

（3,21）

（2,24）

（1,27）

1.3sort的稳定性

你发现有sort和stable_sort，还有partition和stable_partition，感到奇怪吧。

其中的区别是，带有stable的函数可保证相等元素的原本相对次序在排序后保持不变。

或许你会问，既然相等，你还管他相对位置呢，也分不清楚谁是谁了？

这里需要弄清楚一个问题，这里的相等，是指你提供的函数表示两个元素相等，并不一定是一摸一样的元素。

例如，如果你写一个比较函数:

boolless_len（conststring&str1,conststring&str2）

{

returnstr1.length（）

}

此时，"apple"和"winter"就是相等的，如果在"apple"出现在"winter"前面，用带stable的函数排序后，他们的次序一定不变，如果你使用的是不带"stable"的函数排序，那么排序完后，"Winter"有可能在"apple"的前面。

1.4全排序

全排序即把所给定范围所有的元素按照大小关系顺序排列。

用于全排序的函数有

template

voidsort（RandomAccessIteratorfirst,RandomAccessIteratorlast）;

template

voidsort（RandomAccessIteratorfirst,RandomAccessIteratorlast,

StrictWeakOrderingcomp）;

template

voidstable_sort（RandomAccessIteratorfirst,RandomAccessIteratorlast）;

template

voidstable_sort（RandomAccessIteratorfirst,RandomAccessIteratorlast,

StrictWeakOrderingcomp）;

在第1，3种形式中，sort和stable_sort都没有指定比较函数，系统会默认使用operator<对区间[first,last）内的所有元素进行排序,因此，如果你使用的类型义军已经重载了operator<函数，那么你可以省心了。

第2,4种形式，你可以随意指定比较函数，应用更为灵活一些。

来看看实际应用：

班上有10个学生，我想知道他们的成绩排名。

#include

#include

#include

#include

#include

usingnamespacestd;

classstudent{

public:

student（conststring&a,intb）:

name（a）,score（b）{}

stringname;

intscore;

booloperator<（conststudent&m）const{

returnscore

}

};

intmain（）{

vectorvect;

studentst1（"Tom",74）;

vect.push_back（st1）;

st1.name="Jimy";

st1.score=56;

vect.push_back（st1）;

st1.name="Mary";

st1.score=92;

vect.push_back（st1）;

st1.name="Jessy";

st1.score=85;

vect.push_back（st1）;

st1.name="Jone";

st1.score=56;

vect.push_back（st1）;

st1.name="Bush";

st1.score=52;

vect.push_back（st1）;

st1.name="Winter";

st1.score=77;

vect.push_back（st1）;

st1.name="Andyer";

st1.score=63;

vect.push_back（st1）;

st1.name="Lily";

st1.score=76;

vect.push_back（st1）;

st1.name="Maryia";

st1.score=89;

vect.push_back（st1）;

cout<<"------beforesort..."<

for（inti=0;i

\t"<

stable_sort（vect.begin（）,vect.end（）,less（））;

cout<<"-----aftersort...."<

for（inti=0;i

\t"<

return0;

}

其输出是：

------beforesort...

Tom:

74

Jimy:

56

Mary:

92

Jessy:

85

Jone:

56

Bush:

52

Winter:

77

Andyer:

63

Lily:

76

Maryia:

89

-----aftersort....

Bush:

52

Jimy:

56

Jone:

56

Andyer:

63

Tom:

74

Lily:

76

Winter:

77

Jessy:

85

Maryia:

89

Mary:

92

sort采用的是成熟的"快速排序算法"（目前大部分STL版本已经不是采用简单的快速排序，而是结合内插排序算法）。

注1，可以保证很好的平均性能、复杂度为n*log（n），由于单纯的快速排序在理论上有最差的情况，性能很低，其算法复杂度为n*n，但目前大部分的STL版本都已经在这方面做了优化，因此你可以放心使用。

stable_sort采用的是"归并排序"，分派足够内存是，其算法复杂度为n*log（n）,否则其复杂度为n*log（n）*log（n），其优点是会保持相等元素之间的相对位置在排序前后保持一致。

1.5局部排序

局部排序其实是为了减少不必要的操作而提供的排序方式。

其函数原型为：

template

voidpartial_sort（RandomAccessIteratorfirst,

RandomAccessIteratormiddle,

RandomAccessIteratorlast）;

template

voidpartial_sort（RandomAccessIteratorfirst,

RandomAccessIteratormiddle,

RandomAccessIteratorlast,

StrictWeakOrderingcomp）;

template

RandomAccessIteratorpartial_sort_copy（InputIteratorfirst,InputIteratorlast,

RandomAccessIteratorresult_first,

RandomAccessIteratorresult_last）;

template

classStrictWeakOrdering>

RandomAccessIteratorpartial_sort_copy（InputIteratorfirst,InputIteratorlast,

RandomAccessIteratorresult_first,

RandomAccessIteratorresult_last,Comparecomp）;

理解了sort和stable_sort后，再来理解partial_sort就比较容易了。

先看看其用途:

班上有10个学生，我想知道分数最低的5名是哪些人。

如果没有partial_sort，你就需要用sort把所有人排好序，然后再取前5个。

现在你只需要对分数最低5名排序，把上面的程序做如下修改：

stable_sort（vect.begin（）,vect.end（）,less（））;

替换为：

partial_sort（vect.begin（）,vect.begin（）+5,vect.end（）,less（））;

输出结果为：

------beforesort...

Tom:

74

Jimy:

56

Mary:

92

Jessy:

85

Jone:

56

Bush:

52

Winter:

77

Andyer:

63

Lily:

76

Maryia:

89

-----aftersort....

Bush:

52

Jimy:

56

Jone:

56

Andyer:

63

Tom:

74

Mary:

92

Jessy:

85

Winter:

77

Lily:

76

Maryia:

89

这样的好处知道了吗？

当数据量小的时候可能看不出优势，如果是100万学生，我想找分数最少的5个人......

partial_sort采用的堆排序（heapsort），它在任何情况下的复杂度都是n*log（n）.如果你希望用partial_sort来实现全排序，你只要让middle=last就可以了。

partial_sort_copy其实是copy和partial_sort的组合。

被排序（被复制）的数量是[first,last）和[result_first,result_last）中区间较小的那个。

如果[result_first,result_last）区间大于[first,last）区间，那么partial_sort相当于copy和sort的组合。

1.6nth_element指定元素排序

nth_element一个容易看懂但解释比较麻烦的排序。

用例子说会更方便：

班上有10个学生，我想知道分数排在倒数第4名的学生。

如果要满足上述需求，可以用sort排好序，然后取第4位（因为是由小到大排）,更聪明的朋友会用partial_sort,只排前4位，然后得到第4位。

其实这是你还是浪费，因为前两位你根本没有必要排序，此时，你就需要nth_element:

template

voidnth_element（RandomAccessIteratorfirst,RandomAccessIteratornth,

RandomAccessIteratorlast）;

template

voidnth_element（RandomAccessIteratorfirst,RandomAccessIteratornth,

RandomAccessIteratorlast,StrictWeakOrderingcomp）;

对于上述实例需求，你只需要按下面要求修改1.4中的程序：

stable_sort（vect.begin（）,vect.end（）,less（））;

替换为：

nth_element（vect.begin（）,vect.begin（）+3,vect.end（）,less（））;

运行结果为：

------beforesort...

Tom:

74

Jimy:

56

Mary:

92

Jessy:

85

Jone:

56

Bush:

52

Winter:

77

Andyer:

63

Lily:

76

Maryia:

89

-----aftersort....

Jone:

56

Bush:

52

Jimy:

56

Andyer:

63

Jessy:

85

Mary:

92

Winter:

77

Tom:

74

Lily:

76

Maryia:

89

第四个是谁？

Andyer，这个倒霉的家伙。

为什么是begin（）+3而不是+4?

我开始写这篇文章的时候也没有在意，后来在ilovevc的提醒下，发现了这个问题。

begin（）是第一个，begin（）+1是第二个，...begin（）+3当然就是第四个了。

1.7partition和stable_partition

好像这两个函数并不是用来排序的，'分类'算法，会更加贴切一些。

partition就是把一个区间中的元素按照某个条件分成两类。

其函数原型为：

template

ForwardIteratorpartition（ForwardIteratorfirst,

ForwardIteratorlast,Predicatepred）

template

ForwardIteratorstable_partition（ForwardIteratorfirst,ForwardIteratorlast,

Predicatepred）;

看看应用吧：

班上10个学生，计算所有没有及格（低于60分）的学生。

你只需要按照下面格式替换1.4中的程序：

stable_sort（vect.begin（）,vect.end（）,less（））;

替换为：

studentexam（"pass",60）;

stable_partition（vect.begin（）,vect.end（）,bind2nd（less（）,exam））;

其输出结果为：

------beforesort...

Tom:

74

Jimy: