STL排序算法

 

STL中有多種排序算法，各有各的適用范圍，下面聽我一一道來：

I、完全排序

1. sort()

首先要隆重推出的當然是最最常用的sort了，sort有兩種形式，第一種形式有兩個迭代器參數，構成一個前開后閉的區間，按照元素的 less 關系排序；第二種形式多加一個指定排序准則的謂詞。sort基本是最通用的排序函數，它使用快速排序算法，並且在遞歸過程中，當元素數目小於一個閾值（一般是16，我的試驗是24）時，轉成直接插入排序。偉大的數學家Knuth已經證明，在平均意義上，快速排序是最快的了；當然，最壞復雜性比較差。sort要求隨機迭代器，因此對於很多編譯器來說，對於前向迭代器（如list）使用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()); 
} 

/*
list<int> l1;
fill_n(back_inserter(l1), 200, 1000);
*/

如何從大到小逆排序，這個其實有很多種方式實現。

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()); 
} 

1.stable_sort

sort優點一大堆，一個缺點就是它不是一種穩定的排序。什么是排序的穩定性？就是如果出現兩個元素相等時，要求排序之后他們之間保持原來的次序（比如我們先按學號排序，然后按成績排序，這時就希望成績相同的還是按照學號的次序排）。很可惜，快速排序算法就不是穩定的，要追求這個，只好用stable_sort了。

在各種排序算法中，合並排序是穩定的，但一般的合並排序需要額外的O(N)的存儲空間，而這個條件不是一定能夠滿足的（可能是比較奢侈的）。所以在stable_sort內部，首先判斷是否有足夠的額外空間（如vector中的capcity()部分），有的話就使用普通合並函數，總的時間復雜性和快速排序一個數量級，都是O(N*logN)。如果沒有額外空間，使用了一個merge_without_buffer的關鍵函數進行就地合並（如何實現是比較有技巧的，完全可以專門談一談），這個合並過程不需要額外的存儲空間（遞歸的堆棧除外），但時間復雜度變成O(N*logN)，這種情況下，總的stable_sort時間復雜度是O(N*logN*logN)。

總之，stable_sort稍微慢一點兒，但能夠保證穩定，使用方法和sort一樣。但很多時候可以不用這種方式和這個函數，比如上面的例子，完全可以在排序比較准則中寫入成績和學號兩個條件就OK了。

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

3.list.sort

對於list容器，是不能直接使用sort的（包括stable_sort），從技術的角度來說，sort要求隨機迭代器；從算法的角度來說，list這種鏈表結構本身就不適合用快速排序。因此，list容器內部實現了專門的sort算法，這個算法采用的是合並排序，應該是穩定的（不確定）。如：

list<int> li; 
    li.sort(); 

 

4.其他

優先隊列（priority_queue）每次彈出的都是max值。實際上就是heap的一個容器方式的包裝。

關聯式容器自身就必須是有序的（針對key），對其迭代時，key是遞增的。

 

II、部分排序

這些部分排序功能能夠完成一段數據（而不是所有）的排序，在適當的適合使用可以節省計算量。用的人不多，可能了解的也比較少。

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

2. nth_element

　　這個函數只真正排序出一個元素來，就是第n個。函數有三個迭代器的輸入（當然還可以加上一個謂詞），執行完畢后，中間位置指向的元素保證和完全排序后這個位置的元素一致，前面區間的元素都小於（精確地說，是不大於）后面區間的元素。

熟悉快速排序的馬上就能發現，這實際上是一個按位置划分的算法。STL的規范中要求此函數的平均復雜度是線性的，和快速排序一樣，這種算法的最壞復雜度比較差。在一般的實現（如SGI）中，采用三種取1的方法尋找划分元素，最壞復雜度是O(N^N)。雖然理論上有一些算法可以保證最壞線性復雜度，但算法過於復雜，STL一般也不采用。

III、排序輔助功能

1. partition, stable_partition
2. merge, inplace_merge

IV、有序區間操作

這個准備單獨寫一篇