STL 排序(Sort)

djkpengjun

* 详细解说 STL 排序(Sort)
          o 0 前言: STL，为什么你必须掌握
          o 1 STL提供的Sort 算法
                + 1.1 所有sort算法介绍
                + 1.2 sort 中的比较函数
                + 1.3 sort 的稳定性
                + 1.4 全排序
                + 1.5 局部排序
                + 1.6 nth_element 指定元素排序
                + 1.7 partition 和stable_partition
          o 2 Sort 和容器
          o 3 选择合适的排序函数
          o 4 小结
          o 5 参考文档
一切复杂的排序操作，都可以通过STL方便实现 !
0 前言: STL，为什么你必须掌握
对于程序员来说，数据结构是必修的一门课。从查找到排序，从链表到二叉树，几乎所有的算法和原理都需要理解，理解不了也要死记硬背下来。幸运的是这些理论
都已经比较成熟，算法也基本固定下来，不需要你再去花费心思去考虑其算法原理，也不用再去验证其准确性。不过，等你开始应用计算机语言来工作的时候，你会
发现，面对不同的需求你需要一次又一次去用代码重复实现这些已经成熟的算法，而且会一次又一次陷入一些由于自己疏忽而产生的bug中。这时，你想找一种工
具，已经帮你实现这些功能，你想怎么用就怎么用，同时不影响性能。你需要的就是STL, 标准模板库！
西方有句谚语：不要重复发明轮子！
STL几乎封装了所有的数据结构中的算法，从链表到队列，从向量到堆栈，对hash到二叉树，从搜索到排序，从增加到删除......可以说，如果你理解了STL，你会发现你已不用拘泥于算法本身，从而站在巨人的肩膀上去考虑更高级的应用。
排序是最广泛的算法之一，本文详细介绍了STL中不同排序算法的用法和区别。
1 STL提供的Sort 算法
C++之所以得到这么多人的喜欢，是因为它既具有面向对象的概念，又保持了C语言高效的特点。STL 排序算法同样需要保持高效。因此，对于不同的需求，STL提供的不同的函数，不同的函数，实现的算法又不尽相同。
1.1 所有sort算法介绍
所有的sort算法的参数都需要输入一个范围，[begin, end)。这里使用的迭代器(iterator)都需是随机迭代器
(RadomAccessIterator), 也就是说可以随机访问的迭代器，如：it+n什么的。（partition 和
stable_partition 除外）
如果你需要自己定义比较函数，你可以把你定义好的仿函数(functor)作为参数传入。每种算法都支持传入比较函数。以下是所有STL sort算法函数的名字列表:
函数名         功能描述
sort         对给定区间所有元素进行排序
stable_sort         对给定区间所有元素进行稳定排序
partial_sort         对给定区间所有元素部分排序
partial_sort_copy         对给定区间复制并排序
nth_element         找出给定区间的某个位置对应的元素
is_sorted         判断一个区间是否已经排好序
partition         使得符合某个条件的元素放在前面
stable_partition         相对稳定的使得符合某个条件的元素放在前面
其中nth_element 是最不易理解的，实际上，这个函数是用来找出第几个。例如：找出包含7个元素的数组中排在中间那个数的值，此时，我可能不关心前面，也不关心后面，我只关心排在第四位的元素值是多少。
1.2 sort 中的比较函数
当你需要按照某种特定方式进行排序时，你需要给sort指定比较函数，否则程序会自动提供给你一个比较函数。
vector  vect;
//...
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()
当你的容器中元素时一些标准类型（int float char)或者string时，你可以直接使用这些函数模板。但如果你时自己定义的类型或者你需要按照其他方式排序，你可以有两种方法来达到效果：一种是自己写比较函数。另一种是重载类型的'
＃i nclude
＃i nclude
＃i nclude
using namespace std;
class myclass {
        public:
        myclass(int a, int b):first(a), second(b){}
        int first;
        int second;
        bool operator  vect;
        for(int i = 0 ; i
void sort(RandomAccessIterator first, RandomAccessIterator last);
template
void sort(RandomAccessIterator first, RandomAccessIterator last,
StrictWeakOrdering comp);
template
void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
template
void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
StrictWeakOrdering comp);
在第1，3种形式中，sort 和 stable_sort都没有指定比较函数，系统会默认使用operator
＃i nclude
＃i nclude
＃i nclude
＃i nclude
using namespace std;
class student{
        public:
        student(const string &a, int b):name(a), score(b){}
        string name;
        int score;
        bool operator  vect;
        student st1("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());
        cout
void partial_sort(RandomAccessIterator first,
RandomAccessIterator middle,
RandomAccessIterator last);
template
void partial_sort(RandomAccessIterator first,
RandomAccessIterator middle,
RandomAccessIterator last,
StrictWeakOrdering comp);
template
RandomAccessIterator partial_sort_copy(InputIterator first, InputIterator last,
RandomAccessIterator result_first,
RandomAccessIterator result_last);
template
RandomAccessIterator partial_sort_copy(InputIterator first, InputIterator last,
RandomAccessIterator result_first,
RandomAccessIterator result_last, Compare comp);
理解了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());
输出结果为：
------before sort...
Tom:    74
Jimy:   56
Mary:   92
Jessy:  85
Jone:   56
Bush:   52
Winter: 77
Andyer: 63
Lily:   76
Maryia: 89
-----after sort ....
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.6 nth_element 指定元素排序
nth_element一个容易看懂但解释比较麻烦的排序。用例子说会更方便：
班上有10个学生，我想知道分数排在倒数第4名的学生。
如果要满足上述需求，可以用sort排好序，然后取第4位（因为是由小到大排), 更聪明的朋友会用partial_sort, 只排前4位，然后得到第4位。其实这是你还是浪费，因为前两位你根本没有必要排序，此时，你就需要nth_element:
template
void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
RandomAccessIterator last);
template
void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
RandomAccessIterator last, StrictWeakOrdering comp);
对于上述实例需求，你只需要按下面要求修改1.4中的程序：
stable_sort(vect.begin(), vect.end(),less());
替换为：
nth_element(vect.begin(), vect.begin()+3, vect.end(),less());
运行结果为：
------before sort...
Tom:    74
Jimy:   56
Mary:   92
Jessy:  85
Jone:   56
Bush:   52
Winter: 77
Andyer: 63
Lily:   76
Maryia: 89
-----after sort ....
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.7 partition 和stable_partition
好像这两个函数并不是用来排序的，'分类'算法，会更加贴切一些。partition就是把一个区间中的元素按照某个条件分成两类。其函数原型为：
template
ForwardIterator partition(ForwardIterator first,
ForwardIterator last, Predicate pred)
template
ForwardIterator stable_partition(ForwardIterator first, ForwardIterator last,
Predicate pred);
看看应用吧：班上10个学生，计算所有没有及格（低于60分）的学生。你只需要按照下面格式替换1.4中的程序：
stable_sort(vect.begin(), vect.end(),less());
替换为：
student exam("pass", 60);
stable_partition(vect.begin(), vect.end(), bind2nd(less(), exam));
其输出结果为：
------before sort...
Tom:    74
Jimy:   56
Mary:   92
Jessy:  85
Jone:   56
Bush:   52
Winter: 77
Andyer: 63
Lily:   76
Maryia: 89
-----after sort ....
Jimy:   56
Jone:   56
Bush:   52
Tom:    74
Mary:   92
Jessy:  85
Winter: 77
Andyer: 63
Lily:   76
Maryia: 89
看见了吗，Jimy，Jone, Bush(难怪说美国总统比较笨 )都没有及格。而且使用的是stable_partition, 元素之间的相对次序是没有变.
2 Sort 和容器
STL中标准容器主要vector, list, deque, string, set, multiset, map, multimay， 其中
set, multiset, map, multimap都是以树结构的方式存储其元素详细内容请参看：学习STL map, STL set之数据结
构基础. 因此在这些容器中，元素一直是有序的。
这些容器的迭代器类型并不是随机型迭代器，因此，上述的那些排序函数，对于这些容器是不可用的。上述sort函数对于下列容器是可用的：
    * vector
    * string
    * deque
如果你自己定义的容器也支持随机型迭代器，那么使用排序算法是没有任何问题的。
对于list容器，list自带一个sort成员函数list::sort(). 它和算法函数中的sort差不多，但是list::sort是基于指针
的方式排序，也就是说，所有的数据移动和比较都是此用指针的方式实现，因此排序后的迭代器一直保持有效（vector中sort后的迭代器会失效).
3 选择合适的排序函数
为什么要选择合适的排序函数？可能你并不关心效率(这里的效率指的是程序运行时间), 或者说你的数据量很小， 因此你觉得随便用哪个函数都无关紧要。
其实不然，即使你不关心效率，如果你选择合适的排序函数，你会让你的代码更容易让人明白，你会让你的代码更有扩充性，逐渐养成一个良好的习惯，很重要吧 。
如果你以前有用过C语言中的qsort, 想知道qsort和他们的比较，那我告诉你，qsort和sort是一样的，因为他们采用的都是快速排序。从效率上看，以下几种sort算法的是一个排序，效率由高到低（耗时由小变大）：
   1. partion
   2. stable_partition
   3. nth_element
   4. partial_sort
   5. sort
   6. stable_sort
记得，以前翻译过Effective STL的文章，其中对如何选择排序函数总结的很好：
    * 若需对vector, string, deque, 或 array容器进行全排序，你可选择sort或stable_sort；
    * 若只需对vector, string, deque, 或 array容器中取得top n的元素，部分排序partial_sort是首选.
    * 若对于vector, string, deque, 或array容器，你需要找到第n个位置的元素或者你需要得到top n且不关系top n中的内部顺序，nth_element是最理想的；
    * 若你需要从标准序列容器或者array中把满足某个条件或者不满足某个条件的元素分开，你最好使用partition或stable_partition；
    * 若使用的list容器，你可以直接使用partition和stable_partition算法，你可以使用list::sort代替
sort和stable_sort排序。若你需要得到partial_sort或nth_element的排序效果，你必须间接使用。正如上面介绍的有几
种方式可以选择。
总之记住一句话： 如果你想节约时间，不要走弯路, 也不要走多余的路!
               
               
               
               

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u3/104733/showart_2105703.html