sort

時間 2019-12-02

標籤 sort 简体版

原文原文鏈接

0 前言: STL，爲何你必須掌握

對於程序員來講，數據結構是必修的一門課。從查找到排序，從鏈表到二叉樹，幾乎全部的算法和原理都須要理解，理解不了也要死記硬背下來。幸運的是這些理論都已經比較成熟，算法也基本固定下來，不須要你再去花費心思去考慮其算法原理，也不用再去驗證其準確性。不過，等你開始應用計算機語言來工做的時候，你會發現，面對不一樣的需求你須要一次又一次去用代碼重複實現這些已經成熟的算法，並且會一次又一次陷入一些因爲本身疏忽而產生的bug中。這時，你想找一種工具，已經幫你實現這些功能，你想怎麼用就怎麼用，同時不影響性能。你須要的就是STL, 標準模板庫！php

西方有句諺語：不要重複發明輪子！html

STL幾乎封裝了全部的數據結構中的算法，從鏈表到隊列，從向量到堆棧，對hash到二叉樹，從搜索到排序，從增長到刪除......能夠說，若是你理解了STL，你會發現你已不用拘泥於算法自己，從而站在巨人的肩膀上去考慮更高級的應用。ios

排序是最普遍的算法之一，本文詳細介紹了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個元素的數組中排在中間那個數的值，此時，我可能不關心前面，也不關心後面，我只關心排在第四位的元素值是多少。app

1.2 sort 中的比較函數

當你須要按照某種特定方式進行排序時，你須要給sort指定比較函數，不然程序會自動提供給你一個比較函數。less

vector < int > vect;
//...
sort(vect.begin(), vect.end());
//此時至關於調用
sort(vect.begin(), vect.end(), less<int>() );

上述例子中系統本身爲sort提供了less仿函數。在STL中還提供了其餘仿函數，如下是仿函數列表:dom

名稱	功能描述
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 ;
}

知道其輸出結果是什麼了吧：

(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 的穩定性

你發現有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"的前面。

1.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種形式，你能夠隨意指定比較函數，應用更爲靈活一些。來看看實際應用：

班上有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版本已經不是採用簡單的快速排序，而是結合內插排序算法)。注1，能夠保證很好的平均性能、複雜度爲n*log(n)，因爲單純的快速排序在理論上有最差的狀況，性能很低，其算法複雜度爲n*n，但目前大部分的STL版本都已經在這方面作了優化，所以你能夠放心使用。stable_sort採用的是"歸併排序"，分派足夠內存是，其算法複雜度爲n*log(n), 不然其複雜度爲n*log(n)*log(n)，其優勢是會保持相等元素之間的相對位置在排序先後保持一致。

1.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>());

輸出結果爲：

------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 <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 的提醒下，發現了這個問題。begin()是第一個，begin()+1是第二個，... begin()+3固然就是第四個了。

1.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分）的學生。你只須要按照下面格式替換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(難怪說美國總統比較笨 )都沒有及格。並且使用的是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算法的是一個排序，效率由高到低（耗時由小變大）：

partion
stable_partition
nth_element
partial_sort
sort
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的排序效果，你必須間接使用。正如上面介紹的有幾種方式能夠選擇。

總之記住一句話： 若是你想節約時間，不要走彎路, 也不要走多餘的路!

4 小結

討論技術就像個無底洞，常常容易由一點能夠引伸另外無數個技術點。所以須要從全局的角度來觀察問題，就像觀察STL中的sort算法同樣。其實在STL還有make_heap, sort_heap等排序算法。本文章沒有提到。本文以實例的方式，解釋了STL中排序算法的特性，並總結了在實際狀況下應如何選擇合適的算法。

5 參考文檔

條款31：如何選擇排序函數
The Standard Librarian: Sorting in the Standard Library
Effective STL中文版
Standard Template Library Programmer's Guide vvvv

0 前言: STL，爲何你必須掌握

西方有句諺語：不要重複發明輪子！

STL幾乎封裝了全部的數據結構中的算法，從鏈表到隊列，從向量到堆棧，對hash到二叉樹，從搜索到排序，從增長到刪除......能夠說，若是你理解了STL，你會發現你已不用拘泥於算法自己，從而站在巨人的肩膀上去考慮更高級的應用。

排序是最普遍的算法之一，本文詳細介紹了STL中不一樣排序算法的用法和區別。

1 STL提供的Sort 算法

C++之因此獲得這麼多人的喜歡，是由於它既具備面向對象的概念，又保持了C語言高效的特色。STL 排序算法一樣須要保持高效。所以，對於不一樣的需求，STL提供的不一樣的函數，不一樣的函數，實現的算法又不盡相同。