///////////////////////////////////////////////////////////////////////////////////////////////////////
作者:unknow
聲明:本文遵循以下協議自由轉載-非商用-非衍生-保持署名|Creative Commons BY-NC-ND 3.0
轉載請註明:http://www.libing.net.cn/read.php?683
///////////////////////////////////////////////////////////////////////////////////////////////////////
STL中有多種排序算法,各有各的適用範圍,下面聽我一一道來:
I、完全排序
sort()
首先要隆重推出的當然是最最常用的sort了,sort有兩種形式,第一種形式有兩個迭代器參數,構成一個前開後閉的區間,按照元素的 less 關係排序;第二種形式多加一個指定排序準則的謂詞。sort基本是最通用的排序函數,它使用快速排序算法,並且在遞歸過程中,當元素數目小於一個閾值(一般是16,我的試驗是24)時,轉成直接插入排序。偉大的數學家Knuth已經證明,在平均意義上,快速排序是最快的了;當然,最壞複雜性比較差。sort要求隨機迭代器,因此對於很多編譯器來說,對於前向迭代器(如list)使用sort是一個編譯錯誤。(不過,在vc2005裏面,這個錯誤信息實在很糟糕)
sort的基本使用方式如下:
#include <vector>
#include <algorithm>
#include <functional>
#include <cstdlib>
using namespace std;
void func1()
{
vector<int> ar;
//向數組裏面插入一些隨機數
generate_n(back_inserter(ar), 100, rand);
//按從小到大排序
sort(ar.begin(), ar.end());
}
經常有人問如何從大到小逆排序,這個其實有很多中方式實現,如下面的例子:
void func2()
{
vector<int> ar;
//向數組裏面插入一些隨機數
generate_n(back_inserter(ar), 100, rand);
//方法1:使用函數作爲謂詞
sort(ar.begin(), ar.end(), GreateThan);
//方法2:使用仿函數作爲謂詞
//注意下面兩種方法都需要有個括號,實際上是要產生一個臨時對象
sort(ar.begin(), ar.end(), CompareInt());
//方法3:使用預定義的Adapter, 定義在 <functional> 中
sort(ar.begin(), ar.end(), greater<int>());
//方法4:正常排序,然後翻轉過來
sort(ar.begin(), ar.end());
reverse(ar.begin(), ar.end());
//方法5:使用逆迭代器
sort(ar.rbegin(), ar.rend());
}
最後一種方法是我比較欣賞的,可以不能直接對原生數組使用,也就是說,如果ar的定義是int ar[MAXN],上面其他的排序算法都可以簡單的改成sort(ar, ar+MAXN, …),但最後一個不行,要用另外一種比較醜陋的方式:
#include <iterator>
void func3(){
int ax[5]={1,3,4,5,2};
sort(reverse_iterator<int*>(ax+5), reverse_iterator<int*>(ax+0));
}
stable_sort
sort優點一大堆,一個缺點就是它不是一種穩定的排序。什麼是排序的穩定性,就是如果出現兩個元素相等時,要求排序之後他們之間保持原來的次序(比如我們先按學號排序,然後按成績排序,這時就希望成績相同的還是按照學號的次序排)。很可惜,快速排序算法就不是穩定的,要追求這個,只好用stable_sort了。
在各種排序算法中,合併排序是穩定的,但一般的合併排序需要額外的O(N)的存儲空間,而這個條件不是一定能夠滿足的(可能是比較奢侈的)。所以在stable_sort內部,首先判斷是否有足夠的額外空間(如vecotr中的cap-size()部分),有的話就使用普通合併函數,總的時間複雜性和快速排序一個數量級,都是O(N*logN)。如果沒有額外空間,使用了一個merge_without_buffer的關鍵函數進行就地合併(如何實現是比較有技巧的,完全可以專門談一談),這個合併過程不需要額外的存儲空間,但時間複雜度變成O(N*logN),這種情況下,總的stable_sort時間複雜度是O(N*logN*logN)。
總之,stable_sort稍微慢一點兒,但能夠保證穩定,使用方法和sort一樣。但很多時候可以不用這種方式和這個函數,比如上面的例子,完全可以在排序比較準則中寫入成績和學號兩個條件就OK了
class CStudent
{
public:
CStudent();
//注意這個比較函數中的const
bool operator<(const CStudent& rhs) const
{
if (m_score != rhs.m_score)
return (m_score <rhs.m_score);
return m_name <rhs.m_name;
}
protected:
std::string m_name;
int m_score;
};
void func4()
{
vector<CStudent> arStu;
sort(arStu.begin(), arStu.end());
}
sort_heap
堆排序也是一種快速的排序算法,複雜度也是O(N*logN)。STL中有一些和堆相關的函數,能夠構造堆,如果在構造好的堆上每次取出來根節點放在尾部,所有元素循環一遍,最後的結果也就有序了。這就是sort_heap了。它的使用要求區間前面已經構造成堆,如:
void func5()
{
vector<int> ar;
generate_n(back_inserter(ar), 100, rand);
make_heap(ar.begin(), ar.end());
sort_heap(ar.begin(), ar.end());
}
list.sort
對於list容器,是不能直接使用sort的(包括stable_sort),從技術的角度來說是由於sort要求隨機迭代器;從算法的角度來說,list這種鏈表結構就不適合用快速排序。因此,list容器內部實現了專門的sort算法,這個算法採用的是合併排序,應該是穩定的(不確定)。
其他
優先隊列(priority_queue)每次彈出的都是max值。實際上就是heap的一個容器方式的包裝。
關聯式容器自身就必須是有序的(針對key),對其迭代時,key是遞增的。
II、部分排序
這些部分排序功能能夠完成一段數據(而不是所有)的排序,在適當的適合使用可以節省計算量。不過用的人不多。
partial_sort(), partial_sort_copy()
這兩個函數能夠將整個區間中給定數目的元素進行排序,也就是說,結果中只有最小的M個元素是有序的。你當然也可以使用sort,區別就在於效率。如果M顯著地小於N,時間就比較短;當然M太小了也不好,那還不如挨個找最小值了。
partial_sort接受三個參數,分別是區間的頭,中間和結尾。執行後,將前面M(M=中間-頭)個元素有序地放在前面,後面的元素肯定是比前面的大,但他們內部的次序沒有保證。partial_sort_copy的區別在於把結果放到另外指定的迭代器區間中:
void func6()
{
int ar[12]={69,23,80,42,17,15,26,51,19,12,35,8};
//只排序前7個數據
partial_sort(ar, ar+7, ar+12);
//結果是 8 12 15 17 19 23 26 80 69 51 42 35,後5個數據不定
vector<int> res(7);
//前7項排序後放入res
partial_sort_copy(ar, ar+7, res.begin(), res.end(), greater<int>() );
}
這兩個函數的實現使用的是堆的方法,先將前M個元素構造成堆,然後挨個檢查後面的元素,看看是否小於堆的最大值,是的話就彼此交換,然後重排堆;最後將前面已經是最小的M個元素構成的堆作一次sort_heap就可以了。算法的複雜度差不多是O(N*logM)
nth_element
這個函數只真正排序出一個元素來,就是第n個。函數有三個迭代器的輸入(當然還可以加上一個謂詞),執行完畢後,中間位置指向的元素保證和完全排序後這個位置的元素一致,前面區間的元素都小於(精確地說,是不大於)後面區間的元素。
熟悉快速排序的馬上就能發現,這實際上是一個按位置劃分的算法。STL的規範中要求此函數的平均複雜度是線性的,和快速排序一樣,這種算法的最壞複雜度比較差。在一般的實現(如SGI)中,採用三種取1的方法尋找劃分元素,最壞複雜度是O(N^N)。雖然理論上有一些算法可以保證最壞線性複雜度,但算法過於複雜,STL一般也不採用。
III、排序輔助功能
partition, stable_partition
merge, inplace_merge
IV、有序區間操作
這個準備單獨寫一篇