C++程序员应了解的那些事（89）C++ STL中sort()排序

<1>所有sort算法介绍（只支持随机访问迭代器!）

        所有的sort算法的参数都需要输入一个范围，[begin, end)。这里使用的迭代器(iterator)都需是随机迭代器(RadomAccessIterator), 也就是说可以随机访问的迭代器!
如果你需要自己定义比较函数，你可以把你定义好的仿函数(functor)作为参数传入。每种算法都支持传入比较函数。
        以下是所有STL sort算法函数的名字列表：

函数名	功能描述
sort	对给定区间所有元素进行排序
stable_sort	对给定区间所有元素进行稳定排序
partial_sort	对给定区间所有元素部分排序
partial_sort_copy	对给定区间复制并排序
nth_element	找出给定区间的某个位置对应的元素
is_sorted	判断一个区间是否已经排好序
partition	使得符合某个条件的元素放在前面
stable_partition	相对稳定的使得符合某个条件的元素放在前面

<2>sort 中的比较函数      

       当你需要按照某种特定方式进行排序时，你需要给sort指定比较函数，否则程序会自动提供给你一个比较函数。默认使用operator< 对区间[first,last)内的所有元素进行排序。

vector < int > vect;

sort(vect.begin(), vect.end());
//此时相当于调用
sort(vect.begin(), vect.end(), less<int>() );

        上述例子中系统自己为sort提供了less仿函数。在STL中还提供了其他仿函数，以下是仿函数列表:

名称	功能描述
equal_to	相等
not_equal_to	不相等
less	小于
greater	大于
less_equal	小于等于
greater_equal	大于等于

 

        需要注意的是，这些函数不是都能适用于你的sort算法，如何选择，决定于你的应用。另外，不能直接写入仿函数的名字，而是要写其重载的函数,如下：

less<int>()
greater<int>()

        当你的容器中元素时一些标准类型（int float char)或者string时，你可以直接使用这些函数模板。但如果你时自己定义的类型或者你需要按照其他方式排序，你可以有两种方法来达到效果：

• 一种是自己写比较函数
• 一种是重载类型的'<'操作赋

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
using namespace std;

class myclass {
    public:
        myclass(int a, int b):first(a), second(b){}
        int first;
        int second;
        bool operator < (const myclass &m)const {
                return first < m.first;
        }
};
bool less_second(const myclass & m1, const myclass & m2) {
        return m1.second < m2.second;
}

int main() {   
        vector<myclass> vect;
        for(int i = 0; i < 10; i ++){
                myclass my(10-i, i*3);
                vect.push_back(my);
        }
        for(int i = 0 ; i < vect.size(); i ++)
             cout<<"("<<vect[i].first<<","<<vect[i].second<<")\n";

        sort(vect.begin(), vect.end());
        cout<<"after sorted by first:"<<endl;
        for(int i = 0 ; i < vect.size(); i ++)
             cout<<"("<<vect[i].first<<","<<vect[i].second<<")\n";

        cout<<"after sorted by second:"<<endl;
        sort(vect.begin(), vect.end(), less_second);
        for(int i = 0 ; i < vect.size(); i ++)
             cout<<"("<<vect[i].first<<","<<vect[i].second<<")\n";       
        return 0 ;
}

<3>sort 的稳定性  

         sort和stable_sort，还有 partition 和stable_partition，其中的区别是，带有stable的函数可保证相等元素的原本相对次序在排序后保持不变。或许你会问，既然相等，你还管他相对位置呢，也分不清楚谁是谁了？这里需要弄清楚一个问题，这里的相等，是指你提供的函数表示两个元素相等，并不一定是一模一样的元素。

bool less_len(const string &str1, const string &str2)
{
        return str1.length() < str2.length();
}

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

<4>全排序    

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

template <class RandomAccessIterator>
void sort(RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class StrictWeakOrdering>
void sort(RandomAccessIterator first, RandomAccessIterator last,StrictWeakOrdering comp);

template <class RandomAccessIterator>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class StrictWeakOrdering>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last,StrictWeakOrdering comp);

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

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <string>
using namespace std;

class student{
        public:
        student(const string &a, int b):name(a), score(b){}
        string name;
        int score;
        bool operator < (const student &m)const {
                return score< m.score;
        }
};

int main() {
        vector< student> 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);

        cout<<"------before sort..."<<endl;
        for(int i = 0 ; i < vect.size(); i ++) cout<<vect[i].name<<":\t"<<vect[i].score<<endl;
        stable_sort(vect.begin(), vect.end());//以重载operator <为基础,与注释代码一致
        //stable_sort(vect.begin(), vect.end(), less<student>()); //以重载operator <为基础
        cout <<"-----after sort ...."<<endl;
        for(int i = 0 ; i < vect.size(); i ++) cout<<vect[i].name<<":\t"<<vect[i].score<<endl;
        return 0 ;
}

        sort采用的是成熟的"快速排序算法"(目前大部分STL版本已经不是采用简单的快速排序，而是结合内插排序算法)。注1，可以保证很好的平均性能、复杂度为n*log(n)，由于单纯的快速排序在理论上有最差的情况，性能很低，其算法复杂度为n*n，但目前大部分的STL版本都已经在这方面做了优化，因此你可以放心使用。  stable_sort采用的是"归并排序"，分派足够内存，其算法复杂度为n*log(n), 否则其复杂度为n*log(n)*log(n)，其优点是会保持相等元素之间的相对位置在排序前后保持一致。

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

template <class RandomAccessIterator>
void partial_sort(RandomAccessIterator first,RandomAccessIterator middle,RandomAccessIterator last);

template <class RandomAccessIterator, class StrictWeakOrdering>
void partial_sort(RandomAccessIterator first,RandomAccessIterator middle,RandomAccessIterator last,StrictWeakOrdering comp);

template <class InputIterator, class RandomAccessIterator>
RandomAccessIterator partial_sort_copy(InputIterator first, InputIterator last, RandomAccessIterator result_first,RandomAccessIterator result_last);

template <class InputIterator, class RandomAccessIterator,class StrictWeakOrdering>
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<student>());
替换为：
partial_sort(vect.begin(), vect.begin()+5, vect.end(),less<student>());

①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的组合。

<6>nth_element 指定元素排序      

      班上有10个学生，我想知道分数排在倒数第4名的学生。如果要满足上述需求，可以用sort排好序，然后取第4位（因为是由小到大排), 更聪明的朋友会用partial_sort, 只排前4位，然后得到第4位。其实这是你还是浪费，因为前三位你根本没有必要排序，此时，你就需要nth_element:

template <class RandomAccessIterator>
void nth_element(RandomAccessIterator first, RandomAccessIterator nth,RandomAccessIterator last);

template <class RandomAccessIterator, class StrictWeakOrdering>
void nth_element(RandomAccessIterator first, RandomAccessIterator nth,RandomAccessIterator last, StrictWeakOrdering comp);

stable_sort(vect.begin(), vect.end(),less<student>());
替换为：
nth_element(vect.begin(), vect.begin()+3, vect.end(),less<student>());

-----after sort ....
Jone:  56
Bush:  52
Jimy:  56
Andyer: 63
Jessy:  85
Mary:  92
Winter: 77
Tom:    74
Lily:  76
Maryia: 89

<7>partition 和stable_partition   

        这两个函数并不是用来排序的，'分类'算法，会更加贴切一些。partition就是把一个区间中的元素按照某个条件分成两类。

template <class ForwardIterator, class Predicate>
ForwardIterator partition(ForwardIterator first,ForwardIterator last, Predicate pred)

template <class ForwardIterator, class Predicate>
ForwardIterator stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred);

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

stable_sort(vect.begin(), vect.end(),less<student>());
替换为：
student exam("pass", 60);
stable_partition(vect.begin(), vect.end(), bind2nd(less<student>(), 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

<8>Sort 和容器       

        STL中标准容器主要vector, list, deque, string, set, multiset, map, multimay， 其中set, multiset, map, multimap都是以树结构的方式存储. 因此在这些容器中，元素一直是有序的。这些容器的迭代器类型并不是随机型迭代器，因此上述的那些排序函数，对于这些容器是不可用的。

        上述sort函数对于下列容器是可用的：vector string deque

        如果你自己定义的容器也支持随机型迭代器，那么使用排序算法是没有任何问题的。
        ※  对于list容器，list自带一个sort成员函数list::sort(). 它和算法函数中的sort差不多，但是 list::sort是基于指针的方式排序。也就是说，所有的数据移动和比较都是用此指针的方式实现，因此排序后的迭代器一直保持有效（vector中sort后的迭代器会失效)~！！！

<9>选择合适的排序函数

         以下几种sort算法的是一个排序，效率由高到低（耗时由小变大）：

partion
stable_partition
nth_element
partial_sort
sort
stable_sort

• 若需对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的排序效果，你必须间接使用。