作者
Winter
一切復雜的排序操作，都可以通過STL方便實現(xiàn) !
0 前言: STL，為什么你必須掌握
對于程序員來說，數(shù)據(jù)結構是必修的一門課。從查找到排序，從鏈表到二叉樹，幾乎所有的算法和原理都需要理解，理解不了也要死記硬背下來。幸運的是這些理論都已經(jīng)比較成熟，算法也基本固定下來，不需要你再去花費心思去考慮其算法原理，也不用再去驗證其準確性。不過，等你開始應用計算機語言來工作的時候，你會發(fā)現(xiàn)，面對不同的需求你需要一次又一次去用代碼重復實現(xiàn)這些已經(jīng)成熟的算法，而且會一次又一次陷入一些由于自己疏忽而產(chǎn)生的bug中。這時，你想找一種工具，已經(jīng)幫你實現(xiàn)這些功能，你想怎么用就怎么用，同時不影響性能。你需要的就是STL, 標準模板庫！
西方有句諺語：不要重復發(fā)明輪子！
STL幾乎封裝了所有的數(shù)據(jù)結構中的算法，從鏈表到隊列，從向量到堆棧，對hash到二叉樹，從搜索到排序，從增加到刪除......可以說，如果你理解了STL，你會發(fā)現(xiàn)你已不用拘泥于算法本身，從而站在巨人的肩膀上去考慮更高級的應用。
排序是最廣泛的算法之一，本文詳細介紹了STL中不同排序算法的用法和區(qū)別。
1 STL提供的Sort 算法
C++之所以得到這么多人的喜歡，是因為它既具有面向對象的概念，又保持了C語言高效的特點。STL 排序算法同樣需要保持高效。因此，對于不同的需求，STL提供的不同的函數(shù)，不同的函數(shù)，實現(xiàn)的算法又不盡相同。
1.1 所有sort算法介紹
所有的sort算法的參數(shù)都需要輸入一個范圍，[begin, end)。這里使用的迭代器(iterator)都需是隨機迭代器(RadomAccessIterator), 也就是說可以隨機訪問的迭代器，如：it+n什么的。（partition 和stable_partition 除外）
如果你需要自己定義比較函數(shù)，你可以把你定義好的仿函數(shù)(functor)作為參數(shù)傳入。每種算法都支持傳入比較函數(shù)。以下是所有STL sort算法函數(shù)的名字列表:
| 函數(shù)名 |
功能描述 |
| sort |
對給定區(qū)間所有元素進行排序 |
| stable_sort |
對給定區(qū)間所有元素進行穩(wěn)定排序 |
| partial_sort |
對給定區(qū)間所有元素部分排序 |
| partial_sort_copy |
對給定區(qū)間復制并排序 |
| nth_element |
找出給定區(qū)間的某個位置對應的元素 |
| is_sorted |
判斷一個區(qū)間是否已經(jīng)排好序 |
| partition |
使得符合某個條件的元素放在前面 |
| stable_partition |
相對穩(wěn)定的使得符合某個條件的元素放在前面 |
其中nth_element 是最不易理解的，實際上，這個函數(shù)是用來找出第幾個。例如：找出包含7個元素的數(shù)組中排在中間那個數(shù)的值，此時，我可能不關心前面，也不關心后面，我只關心排在第四位的元素值是多少。
1.2 sort 中的比較函數(shù)
當你需要按照某種特定方式進行排序時，你需要給sort指定比較函數(shù)，否則程序會自動提供給你一個比較函數(shù)。
vector < int > vect;
//...
sort(vect.begin(), vect.end());
//此時相當于調用
sort(vect.begin(), vect.end(), less<int>() );
上述例子中系統(tǒng)自己為sort提供了less仿函數(shù)。在STL中還提供了其他仿函數(shù)，以下是仿函數(shù)列表:
| 名稱 |
功能描述 |
| equal_to |
相等 |
| not_equal_to |
不相等 |
| less |
小于 |
| greater |
大于 |
| less_equal |
小于等于 |
| greater_equal |
大于等于 |
需要注意的是，這些函數(shù)不是都能適用于你的sort算法，如何選擇，決定于你的應用。另外，不能直接寫入仿函數(shù)的名字，而是要寫其重載的()函數(shù)：
less<int>()
greater<int>()
當你的容器中元素時一些標準類型（int float char)或者string時，你可以直接使用這些函數(shù)模板。但如果你時自己定義的類型或者你需要按照其他方式排序，你可以有兩種方法來達到效果：一種是自己寫比較函數(shù)。另一種是重載類型的'<'操作賦。
#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 ;
}
知道其輸出結果是什么了吧：
(10,0)
(9,3)
(8,6)
(7,9)
(6,12)
(5,15)
(4,18)
(3,21)
(2,24)
(1,27)
after sorted by first:
(1,27)
(2,24)
(3,21)
(4,18)
(5,15)
(6,12)
(7,9)
(8,6)
(9,3)
(10,0)
after sorted by second:
(10,0)
(9,3)
(8,6)
(7,9)
(6,12)
(5,15)
(4,18)
(3,21)
(2,24)
(1,27)
1.3 sort 的穩(wěn)定性
你發(fā)現(xiàn)有sort和stable_sort，還有 partition 和stable_partition， 感到奇怪吧。其中的區(qū)別是，帶有stable的函數(shù)可保證相等元素的原本相對次序在排序后保持不變。或許你會問，既然相等，你還管他相對位置呢，也分不清楚誰是誰了？這里需要弄清楚一個問題，這里的相等，是指你提供的函數(shù)表示兩個元素相等，并不一定是一摸一樣的元素。
例如，如果你寫一個比較函數(shù):
bool less_len(const string &str1, const string &str2)
{
return str1.length() < str2.length();
}
此時，"apple" 和 "winter" 就是相等的，如果在"apple" 出現(xiàn)在"winter"前面，用帶stable的函數(shù)排序后，他們的次序一定不變，如果你使用的是不帶"stable"的函數(shù)排序，那么排序完后，"Winter"有可能在"apple"的前面。
1.4 全排序
全排序即把所給定范圍所有的元素按照大小關系順序排列。用于全排序的函數(shù)有
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都沒有指定比較函數(shù)，系統(tǒng)會默認使用operator< 對區(qū)間[first,last)內的所有元素進行排序, 因此，如果你使用的類型義軍已經(jīng)重載了operator<函數(shù)，那么你可以省心了。第2, 4種形式，你可以隨意指定比較函數(shù)，應用更為靈活一些。來看看實際應用：
班上有10個學生，我想知道他們的成績排名。
#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);
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<<"------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(),less<student>());
cout <<"-----after sort ...."<<endl;
for(int i = 0 ; i < vect.size(); i ++) cout<<vect[i].name<<":\t"<<vect[i].score<<endl;
return 0 ;
}
其輸出是：
------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
Lily: 76
Winter: 77
Jessy: 85
Maryia: 89
Mary: 92
sort采用的是成熟的"快速排序算法"(目前大部分STL版本已經(jīng)不是采用簡單的快速排序，而是結合內插排序算法)。
注1，可以保證很好的平均性能、復雜度為n*log(n)，由于單純的快速排序在理論上有最差的情況，性能很低，其算法復雜度為n*n，但目前大部分的STL版本都已經(jīng)在這方面做了優(yōu)化，因此你可以放心使用。stable_sort采用的是"歸并排序"，分派足夠內存是，其算法復雜度為n*log(n), 否則其復雜度為n*log(n)*log(n)，其優(yōu)點是會保持相等元素之間的相對位置在排序前后保持一致。
1.5 局部排序
局部排序其實是為了減少不必要的操作而提供的排序方式。其函數(shù)原型為：
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個學生，我想知道分數(shù)最低的5名是哪些人。如果沒有partial_sort，你就需要用sort把所有人排好序，然后再取前5個。現(xiàn)在你只需要對分數(shù)最低5名排序，把上面的程序做如下修改：
stable_sort(vect.begin(), vect.end(),less<student>());
替換為：
partial_sort(vect.begin(), vect.begin()+5, vect.end(),less<student>());
輸出結果為：
------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
這樣的好處知道了嗎？當數(shù)據(jù)量小的時候可能看不出優(yōu)勢，如果是100萬學生，我想找分數(shù)最少的5個人......
partial_sort采用的堆排序（heapsort），它在任何情況下的復雜度都是n*log(n). 如果你希望用partial_sort來實現(xiàn)全排序，你只要讓middle=last就可以了。
partial_sort_copy其實是copy和partial_sort的組合。被排序(被復制)的數(shù)量是[first, last)和[result_first, result_last)中區(qū)間較小的那個。如果[result_first, result_last)區(qū)間大于[first, last)區(qū)間，那么partial_sort相當于copy和sort的組合。
1.6 nth_element 指定元素排序
nth_element一個容易看懂但解釋比較麻煩的排序。用例子說會更方便：
班上有10個學生，我想知道分數(shù)排在倒數(shù)第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);
對于上述實例需求，你只需要按下面要求修改1.4中的程序：
stable_sort(vect.begin(), vect.end(),less<student>());
替換為：
nth_element(vect.begin(), vect.begin()+3, vect.end(),less<student>());
運行結果為：
------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 的提醒下，發(fā)現(xiàn)了這個問題。begin()是第一個，begin()+1是第二個，... begin()+3當然就是第四個了。
1.7 partition 和stable_partition
好像這兩個函數(shù)并不是用來排序的，'分類'算法，會更加貼切一些。partition就是把一個區(qū)間中的元素按照某個條件分成兩類。其函數(shù)原型為：
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分）的學生。你只需要按照下面格式替換1.4中的程序：
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
看見了嗎，Jimy，Jone, Bush(難怪說美國總統(tǒng)比較笨
)都沒有及格。而且使用的是stable_partition, 元素之間的相對次序是沒有變.
2 Sort 和容器
STL中標準容器主要vector, list, deque, string, set, multiset, map, multimay， 其中set, multiset, map, multimap都是以樹結構的方式存儲其元素詳細內容請參看：
學習STL map, STL set之數(shù)據(jù)結構基礎. 因此在這些容器中，元素一直是有序的。
這些容器的迭代器類型并不是隨機型迭代器，因此，上述的那些排序函數(shù)，對于這些容器是不可用的。上述sort函數(shù)對于下列容器是可用的：
如果你自己定義的容器也支持隨機型迭代器，那么使用排序算法是沒有任何問題的。
對于list容器，list自帶一個sort成員函數(shù)list::sort(). 它和算法函數(shù)中的sort差不多，但是list::sort是基于指針的方式排序，也就是說，所有的數(shù)據(jù)移動和比較都是此用指針的方式實現(xiàn)，因此排序后的迭代器一直保持有效（vector中sort后的迭代器會失效).
3 選擇合適的排序函數(shù)
為什么要選擇合適的排序函數(shù)？可能你并不關心效率(這里的效率指的是程序運行時間), 或者說你的數(shù)據(jù)量很小， 因此你覺得隨便用哪個函數(shù)都無關緊要。
其實不然，即使你不關心效率，如果你選擇合適的排序函數(shù)，你會讓你的代碼更容易讓人明白，你會讓你的代碼更有擴充性，逐漸養(yǎng)成一個良好的習慣，很重要吧 。
如果你以前有用過C語言中的qsort, 想知道qsort和他們的比較，那我告訴你，qsort和sort是一樣的，因為他們采用的都是快速排序。從效率上看，以下幾種sort算法的是一個排序，效率由高到低（耗時由小變大）：
- partion
- stable_partition
- nth_element
- partial_sort
- sort
- stable_sort
記得，以前翻譯過Effective STL的文章，其中對
如何選擇排序函數(shù)總結的很好：
- 若需對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的排序效果，你必須間接使用。正如上面介紹的有幾種方式可以選擇。
總之記住一句話：
如果你想節(jié)約時間，不要走彎路, 也不要走多余的路!
4 小結
討論技術就像個無底洞，經(jīng)常容易由一點可以引申另外無數(shù)個技術點。因此需要從全局的角度來觀察問題，就像觀察STL中的sort算法一樣。其實在STL還有make_heap, sort_heap等排序算法。本文章沒有提到。本文以實例的方式，解釋了STL中排序算法的特性，并總結了在實際情況下應如何選擇合適的算法。
5 參考文檔
條款31：如何選擇排序函數(shù) The Standard Librarian: Sorting in the Standard Library Effective STL中文版 Standard Template Library Programmer's Guide