2. 程式人生 > >整理：STL sort排序演算法詳細介紹

整理：STL sort排序演算法詳細介紹

阿新 • • 發佈：2019-02-12
一切複雜的排序操作，都可以通過STL方便實現 !

0 前言: STL，為什麼你必須掌握

對於程式設計師來說，資料結構是必修的一門課。從查詢到排序，從連結串列到二叉樹，幾乎所有的演算法和原理都需要理解，理解不了也要死記硬背下來。幸運的是這些理論都已經比較成熟，演算法也基本固定下來，不需要你再去花費心思去考慮其演算法原理，也不用再去驗證其準確性。不過，等你開始應用計算機語言來工作的時候，你會發現，面對不同的需求你需要一次又一次去用程式碼重複實現這些已經成熟的演算法，而且會一次又一次陷入一些由於自己疏忽而產生的bug中。這時，你想找一種工具，已經幫你實現這些功能，你想怎麼用就怎麼用，同時不影響效能。你需要的就是STL, 標準模板庫！

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

STL幾乎封裝了所有的資料結構中的演算法，從連結串列到佇列，從向量到堆疊，對hash到二叉樹，從搜尋到排序，從增加到刪除......可以說，如果你理解了STL，你會發現你已不用拘泥於演算法本身，從而站在巨人的肩膀上去考慮更高階的應用。

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

1.2 sort 中的比較函式

當你需要按照某種特定方式進行排序時，你需要給sort指定比較函式，否則程式會自動提供給你一個比較函式。 
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 ;
}
知道其輸出結果是什麼了吧： 
(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(難怪說美國總統比較笨 smile )都沒有及格。而且使用的是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 選擇合適的排序函式

為什麼要選擇合適的排序函式？可能你並不關心效率(這裡的效率指的是程式執行時間), 或者說你的資料量很小， 因此你覺得隨便用哪個函式都無關緊要。

其實不然，即使你不關心效率，如果你選擇合適的排序函式，你會讓你的程式碼更容易讓人明白，你會讓你的程式碼更有擴充性，逐漸養成一個良好的習慣，很重要吧 smile 。

如果你以前有用過C語言中的qsort, 想知道qsort和他們的比較，那我告訴你，qsort和sort是一樣的，因為他們採用的都是快速排序。從效率上看，以下幾種sort演算法的是一個排序，效率由高到低（耗時由小變大）：

  1. partion
  2. stable_partition
  3. nth_element
  4. partial_sort
  5. sort
  6. 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 STL sort的危險之處

STL好用是好用, 不慎的話相當危險, 尤其是俺們這些伺服器程式.
迭代器失效就不說了, 發生了就是個當機回檔的事, 慎之!

最近工作中看到了stl::sort排序導致的一個core, 問題的根源就是, stl::sort要求被排序的物件必須是順序確定的, 比如你在過載<操作符的時候
class Test1 
{ 
    int a; 
    bool operator < (const Test1& rhs) { 
        return this->a < rhs.a; 
    } 
};
上面的程式碼就是沒問題的, 因為兩個給定的Test1物件, 呼叫<的時候的結果是一致的.但是如果是下面這樣 
class Test2 
{ 
    int a, b; 
    bool operator < (const Test1& rhs) { 
        return this->a < rhs.a || this->b < rhs.b; 
    } 
};
那麼, 對於obj1(a = 1, b = 4)和obj2(a = 2, b = 3)來說, obj1 < obj2的結果是真, 而obj2 < obj1的結果也是真, 這樣, stl::sort就會出錯。

又或者是:
class Test2 
{ 
    int a, b; 
    bool operator < (const Test1& rhs) { 
        bool ret = this->a < rhs.a;
        return  !ret;//降序排序
    } 
};

當排序的序列中，如果有兩個Test類的a一樣大，就會出錯。

主要的原因是在stl::sort的內部, 由於這種無法判斷兩個元素大小的問題, 導致迭代器失效. 這次不是因為使用者erase讓其失效的, 而是因為沒有遵守stl::sort的前置條件, 而導致的內部迭代器失效, 比平常發生的失效更加的隱藏.
可能看到這個錯誤會覺得怎麼可能寫出這種邏輯呢, 但是有時候在實現業務邏輯的時候, 就是很難發現這樣的和程式內建必要條件相矛盾的地方, 從而產生錯誤

6 參考文件

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

相關推薦

整理：STL sort排序演算法詳細介紹

一切複雜的排序操作，都可以通過STL方便實現 ! 0 前言: STL，為什麼你必須掌握 對於程式設計師來說，資料結構是必修的一門課。從查詢到排序，從連結串列到二叉樹，幾乎所有的演算法和原理都需要理解，理解不了也要死記硬背下來。幸運的是這些理論都已經比較成熟，演算法也基本

STL sort排序演算法詳細介紹

                C++之所以得到這麼多人的喜歡，是因為它既具有面向物件的概念，又保持了C語言高效的特點。STL 排序演算法同樣需要保持高效。因此，對於不同的需求，STL提供的不同的函式，不同的函式，實現的演算法又不盡相同。1.1 所有sort演算法介紹所有的sort演算法的引數都需要輸入一個範

自我整理：幾種排序演算法的理解

簡單來自己做個筆記，溫故一下排序方法。 1.直接排序 顧名思義，直接排，怎麼直接排，每次迴圈找出最下的扔到第一個，或者找到最大的扔到最後一個，剩下的數字，繼續迴圈找最小的往前扔，暴力排完。簡單粗暴，居家

STL中sort排序演算法原理

1、所有sort演算法介紹 所有的sort演算法的引數都需要輸入一個範圍，[begin,end)。這裡使用的迭代器(iterator)都需是隨機迭代器(RadomAccessIterator), 也就是說可以隨機訪問的迭代器，如：it+n什麼的。（partit

《Linux學習並不難》用戶管理（2）：/etc/passwd文件詳細介紹

Linux 用戶 passwd 9.2 《Linux學習並不難》用戶管理（2）：/etc/passwd文件詳細介紹/etc/passwd文件是Linux系統識別用戶的一個重要文件，Linux系統中所有的用戶都記錄在該文件中。假設用戶以賬戶zhangsan登錄系統時，系統首先會檢查/etc/pas

《Linux學習並不難》用戶管理（3）：/etc/shadow文件詳細介紹

Linux 用戶 shadow 9.3 《Linux學習並不難》用戶管理（3）：/etc/shadow文件詳細介紹/etc/shadow文件是/etc/passwd的影子文件，這兩個文件應該是對應互補的。/etc/shadow文件的內容包括用戶被加密的密碼以及其它/etc/passwd文件不能包

十大經典排序演算法詳細總結(含JAVA程式碼實現)

文章目錄 十大經典排序演算法詳細總結(含JAVA程式碼實現) 0、排序演算法說明 1、氣泡排序（Bubble Sort） 2、選擇排序（Selection Sort） 3、插入排序（Insertion Sort） 4、希爾

STL之排序演算法

1.merge() 以下是排序和通用演算法：提供元素排序策略 merge: 合併兩個有序序列，存放到另一個序列。 例如： vecIntA,vecIntB,vecIntC是用vector宣告的容器，vecIntA已包含1,3,5,7,9元素，vecIntB已包含2,4,6,8元素

《演算法》第四版algs4:sort排序演算法C++實現

具體程式碼： https://github.com/Nwpuer/algs4-in-cpp/blob/master/sort.h 這一章的實現，相比於書上我做了輕微的改變，主要目的是把程式碼寫的更加簡潔易懂，更加關注演算法是如何實現的，換言之，更關注演算法的本質，而不是如何去設計一個C+

知識點11：常見的排序演算法–歸併排序

相信看過常見的排序演算法——快速排序的朋友們都記得，我們在介紹它的時候便闡述了使用快排的兩種策略，分別是分治和遞迴。它的原理是：通過遞迴的方式，利用某個基底，不斷將數列劃分為更小的部分。直到小陣列不能再拆分的時候，便已經完成了排序。而今天要介紹的歸併排序，與它有很多相近的地方，不過也有很

排序演算法： 三大中級排序演算法，原理解析及用法

三大中級演算法 難度 ★★ 演算法複雜度O(nlogn) 一般情況下排序時間： 快速排序< 歸併排序 < 堆排序 快速排序： 缺點極端情況下效率低 堆排序： 缺點在快的排序演算法中相對慢 歸併排序： 缺點要有額外記憶體空間 快速

【轉帖】stl sort排序

前幾天阿里電話一面，被問到STL中sort函式的實現。以前沒有仔細探究過，聽人說是快速排序，於是回答說用快速排序實現的，但聽電話另一端面試官的聲音，感覺不對勁，知道自己回答錯了。這幾天特意看了一下，在此記錄。 函式宣告 #include <algorithm> templ

十大排序演算法詳細

常見的排序演算法有：插入排序、選擇排序、氣泡排序、快速排序、堆排序、歸併排序、希爾排序、二叉樹排序、計數排序、桶排序、基數排序。 分類：十大排序演算法可以分為兩類： 非線性時間比較類排序：通過比較來決定元素間的相對次序，由於其時間複雜度不能突破O(nlogn

STL is_sorted排序演算法

排序是要耗費時間的，尤其是在有大量元素時。測試元素段是否已經排好序可以避免不必要的排序操作。如果兩個迭代器引數所指定範圍內的元素是升序排列的，函式模板 is_sorted() 就會返回 true。 為了能夠順序處理元素，迭代器至少需要是正向迭代器。提醒一下，正向迭代器支援字首和字尾形式的自增

STL nth_element排序演算法

nth_element() 演算法和 partial_sort() 不同。應用的範圍由它的第一個和第三個引數指定。第二個引數是一個指向第 n 個元素的迭代器。如果這個範圍內的元素是完全有序的，nth_dement() 的執行會導致第 n 個元素被放置在適當的位置。這個範圍內，在第 n 個元素之前

STL partial_sort排序演算法

通過示例很容易理解什麼是部分排序。假設有一個容器，它儲存了 100 萬個數值，但我們只對其中最小的 100 個感興趣。可以對容器的全部內容排序，然後選擇前 100 個元素，但這可能有點消耗時間。這時候需要使用部分排序，只需要這些數中的前100個是有序放置的。 對於部分排序，有一個特殊的演算法

STL stable_sort排序演算法

sort() 演算法可能會改變相等元素的順序，有時候這不是我們想要的。假設有一個儲存某種事務的容器，或許是銀行賬戶。進一步假設，在處理它們之前，為了能夠有序更新這些賬戶，需要按照賬號對這些事務排序。如果出現相等事務的順序反映的是它們新增到容器的時間順序，就需要維持這個順序不變。如果允許對給定賬戶

STL is_permutation排序演算法

is_permutation() 演算法可以用來檢查一個序列是不是另一個序列的排列，如果是，會返回 true。下面是在這個演算法中使用 lambda 表示式的示例： std::vector<double> data1{ 44.5, 22.0, 15.6, 1.5 }; std::

排序演算法：希爾排序演算法實現及分析

希爾排序演算法介紹希爾排序是D.LShell 與1957年提出來的一種排序演算法，在這之前排序演算法的時間複雜度都是O(n^2),希爾排序演算法是突破這個時間複雜度的第一批演算法之一。我們知道直接插入排序演算法（不知道的請看：排序演算法：直接插入排序演算法實現及分析），在某些

紅黑樹 原理和演算法詳細介紹（Java）

R-B Tree簡介 R-B Tree，全稱是Red-Black Tree，又稱為“紅黑樹”，它一種特殊的二叉查詢樹。紅黑樹的每個節點上都有儲存位表示節點的顏色，可以是紅(Red)或黑(Black)。 紅黑樹的特性: （1）每個節點或者是黑色，或者是紅