C++ STL中常見的算法使用方式
什么是STL？
STL（Standard Template Library），即標準模板庫，是一個具有工業(yè)強度的，高效的C++程序庫。它被容納于C++標準程序庫（C++ Standard Library）中，是ANSI/ISO C++標準中最新的也是極具革命性的一部分。該庫包含了諸多在計算機科學(xué)領(lǐng)域里所常用的基本數(shù)據(jù)結(jié)構(gòu)和基本算法。為廣大C++程序員們提供了一個可擴展的應(yīng)用框架，高度體現(xiàn)了軟件的可復(fù)用性。
STL的一個重要特點是數(shù)據(jù)結(jié)構(gòu)和算法的分離。盡管這是個簡單的概念，但這種分離確實使得STL變得非常通用。例如，由于STL的sort()函數(shù)是完全通用的，你可以用它來操作幾乎任何數(shù)據(jù)集合，包括鏈表，容器和數(shù)組；
STL另一個重要特性是它不是面向?qū)ο蟮?。為了具有足夠通用性，STL主要依賴于模板而不是封裝，繼承和虛函數(shù)（多態(tài)性）——OOP的三個要素。你在STL中找不到任何明顯的類繼承關(guān)系。這好像是一種倒退，但這正好是使得STL的組件具有廣泛通用性的底層特征。另外，由于STL是基于模板，內(nèi)聯(lián)函數(shù)的使用使得生成的代碼短小高效；
從邏輯層次來看，在STL中體現(xiàn)了泛型化程序設(shè)計的思想，引入了諸多新的名詞，比如像需求（requirements），概念（concept），模型（model），容器（container），算法（algorithmn），迭代子（iterator）等。與OOP（object-oriented programming）中的多態(tài)（polymorphism）一樣，泛型也是一種軟件的復(fù)用技術(shù)；
從實現(xiàn)層次看，整個STL是以一種類型參數(shù)化的方式實現(xiàn)的，這種方式基于一個在早先C++標準中沒有出現(xiàn)的語言特性--模板（template）。
0. < algorithm> 是什么：
< algorithm> 頭文件定義了一組專門用于操作元素范圍的函數(shù)（designed to be used on ranges of elements）。
所謂“元素范圍”指的是可以通過 迭代器 或 指針 進行訪問的對象序列，例如數(shù)組或某些SLT容器。注意，< algorithm>中的算法通過迭代器直接對值進行操作，不會以任何形式影響任何容器的結(jié)構(gòu)（它永遠不會影響容器的大小或存儲分配）。
一句話概括：
< algorithm> 中定義的STL算法通過 “迭代器” 來操作STL容器中的元素，且不會影響容器的結(jié)構(gòu)。
需要注意的事：
< algorithm> 中的算法的參數(shù)迭代器范圍一般都是 [first, last)，即“前閉后開”區(qū)間，last類似于end尾迭代器，指向容器最后一個元素后面的位置。
1. Non-modifying sequence operations：
不會修改容器中元素的順序的操作：
1.1 find：（Find value in range）
函數(shù)原型：
template<class InputIterator, class T>
InputIterator find(InputIterator first, InputIterator last, const T& val)
{
while(first != last) {
if(*first == val) return first;
++first;
}
return last;
}
find()函數(shù)在給定的迭代器區(qū)間[first, last) 中查找值 val。
如果val存在，則返回區(qū)間內(nèi)的指向第一個元素的迭代器；
如果val不存在，則返回 last迭代器。
使用舉例：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int myints[] = { 10, 20, 30, 40 };
vector<int> myvector(myints, myints + 4);
vector<int>::const_iterator it;
it = find(myvector.cbegin(), myvector.cend(), 30);
if(it != myvector.cend()) {
cout << "Element found in myvector: " << *it << '\n';
}
else {
cout << "Element not found in myvector\n";
}
return 0;
}
------
Element found in myvector: 30
注意：find()函數(shù)不會修改容器中元素的值，所以可以使用 const_iterator 迭代器，但需要注意返回值、入?yún)⒌念愋捅仨毝际莄onst類型的，否則編譯時會因類型匹配報錯（報錯原因：it = find() 中的 “=” 沒有重載）。
時間復(fù)雜度：
因為要從first到last的區(qū)間遍歷，所以時間復(fù)雜度是 O(n)。
1.2 count：（Count appearances of value in range）
函數(shù)原型：
template <class InputIterator, class T>
typename iterator_traits<InputIterator>::difference_type
count(InputIterator first, InputIterator last, const T& val)
{
typename iterator_traits<InputIterator>::differenct_type ret = 0;
while(first != last) {
if(*first == val) ++ret;
++first;
}
return ret;
}
count() 函數(shù)在給定的迭代器區(qū)間 [first, last) 中統(tǒng)計參數(shù) val出現(xiàn)的次數(shù)，返回統(tǒng)計到的個數(shù)。
使用舉例：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int myints[] = { 10,20,30,30,20,10,10,20 };
vector<int> myvector(myints, myints + sizeof(myints)/sizeof(int));
int mycount = count(myvector.cbegin(), myvector.cend(), 10);
cout << "10 appears times: " << mycount << '\n';
return 0;
}
------
10 appears times: 3
時間復(fù)雜度：
count()函數(shù)同樣需要遍歷整個容器，所以時間復(fù)雜度是 O(n)。
1.3 equal：（Test whether the elements in two ranges are equal）
函數(shù)原型：
template <class InputIterator1, class InputIterator2>
bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
{
while(first1 != last1) {
if(*first1 != *first2) return false;
++first1;
++first2;
}
return true;
}
//使用自定義的比較函數(shù)的equal()版本：
bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator first2, bool func) {}
比較兩個容器中指定范圍的值是否相等，返回bool值。
equal()函數(shù)有兩種重載形式，接收三個參數(shù)的版本使用 operator= 對兩個容器中的元素進行比較；接受四個參數(shù)的版本可使用自定義的比較函數(shù)。
使用舉例：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
bool mypredicate(int i, int j) {
return (i == j);
}
int main() {
int myints[] = { 20,40,60,80,100 };
vector<int> myvector(myints, myints + sizeof(myints)/sizeof(int));
//接受三個參數(shù)的equal版本，使用 operator= 進行比較：
if( equal(myvector.cbegin(), myvector.cend(), myints) ) {
cout << "The contents of both sequences are equal.\n";
}
else {
cout << "The contents of both sequences differ.\n";
}
//接受四個參數(shù)的equal版本，使用自定義的比較函數(shù)：
if( equal(myvector.cbegin(), myvector.cend(), myints, mypredicate) ) {
cout << "The contents of both sequences are equal.\n";
}
else {
cout << "The contents of both sequences differ.\n";
}
return 0;
}
------
The contents of both sequences are equal.
The contents of both sequences are equal.
時間復(fù)雜度：
同樣需要遍歷迭代器范圍的容器內(nèi)容，所以時間復(fù)雜度是 O(n)。
1.4 search：（Search range for subsequence）
函數(shù)原型：
//equality (1)
template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2);
//predicate (2)
template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2,
BinaryPredicate pred);
find()函數(shù)是用于在一個范圍內(nèi)查找某一個元素是否存在，search()函數(shù)是用于一個范圍內(nèi)查找一個一連串的元素是否存在。
find()函數(shù)同樣存在兩個版本：使用 operator=進行比較的版本 及 使用自定義方法進行比較的版本。
返回值：如果找到，則返回指向找到的范圍內(nèi)的第一元素的迭代器；如果未找到，則返回last1。
使用舉例：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
bool mypredicate(int i, int j) {
return (i == j);
}
int main() {
vector<int> haystack;
for(int i = 1; i < 10; i++) {
haystack.push_back(i * 10); //haystack: 10,20,30,40,50,60,70,80,90
}
int needle[] = { 40,50,60,70 };
vector<int>::const_iterator it;
it = search(haystack.cbegin(), haystack.cend(), needle, needle + sizeof(needle)/sizeof(int));
if(it != haystack.cend()) {
cout << "needle found at position: " << (it - haystack.cbegin()) << '\n';
}
else {
cout << "needle not found\n";
}
//方式二，使用自定義的比較函數(shù)：
it = search(haystack.cbegin(), haystack.cend(), needle, needle + sizeof(needle)/sizeof(int), mypredicate);
if(it != haystack.cend()) {
cout << "needle found at position: " << (it - haystack.cbegin()) << '\n';
}
else {
cout << "needle not found\n";
}
return 0;
}
------
needle found at position: 3
needle found at position: 3
時間復(fù)雜度：
O(n2).
2. Modifying sequence operations：
會修改容器中元素順序的操作：
2.1 copy：（Copy range of elements）
函數(shù)原型：
template <class InputIterator, class OutputIterator> OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result);
作用相當于：
template<class InputIterator, class OutputIterator>
OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result)
{
while (first != last) {
*result = *first;
++result; ++first;
}
return result;
}
將 [first, last) 范圍到的源數(shù)據(jù) 拷貝到 result 指定的目標位置，返回值是目標位置的末尾迭代器（An iterator to the end of the destination range where elements have been copied）。
使用舉例：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int myints[] = { 10, 20, 30, 40, 50, 60, 70 };
vector<int> myvector(7);
copy(myints, myints + 7, myvector.begin());
cout << "myvector contains: ";
for(vector<int>::const_iterator it = myvector.cbegin(); it != myvector.cend(); ++it) {
cout << *it << ' ';
}
cout << '\n';
return 0;
}
------
myvector contains: 10 20 30 40 50 60 70
時間復(fù)雜度：
O(n).
2.2 move：（move range of elements）
函數(shù)原型：
template <class InputIterator, class OutputIterator> OutputIterator move (InputIterator first, InputIterator last, OutputIterator result);
作用相當于：
template<class InputIterator, class OutputIterator>
OutputIterator move (InputIterator first, InputIterator last, OutputIterator result)
{
while (first != last) {
*result = std::move(*first);
++result; ++first;
}
return result;
}
move()函數(shù)的作用是將 [first, last) 區(qū)間內(nèi)的元素 “移動” 到 result 指定的目標位置。
移動后，源位置 [first, last) 的狀態(tài)是“未指定但有效的狀態(tài)”（in an unspecified but valid state），這個作用類似于 移動構(gòu)造函數(shù)中使用的 std::move 函數(shù)的效果，事實上 STL中的move函數(shù)中也確實調(diào)用了 單個參數(shù)的 std::move 函數(shù)版本。
“未指定但有效的狀態(tài)” 可以理解為空間上的元素因為被移走已經(jīng)為空，但對其求 sizeof 大小仍在。
使用舉例：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
string array[] = { "air", "water", "fire", "earth" };
vector<string> foo(array, array + 4);
vector<string> bar(4);
move(foo.begin(), foo.end(), bar.begin());
cout << "foo.size(): " << foo.size() << "; " << "bar.size(): " << bar.size() << ".\n";
cout << "foo content: ";
for(auto &r : foo)
cout << r << ' ';
cout << '\n';
cout << "bar content: ";
for(auto &r : bar)
cout << r << ' ';
cout << '\n';
return 0;
}
------
foo.size(): 4; bar.size(): 4.
foo content:
bar content: air water fire earth
時間復(fù)雜度：
O(n).
2.3 fill：（Fill range with value）
函數(shù)原型：
template <class ForwardIterator, class T> void fill (ForwardIterator first, ForwardIterator last, const T& val);
fill()函數(shù)的作用是將 [first, last) 范圍內(nèi)容器的值全部填寫為 val。
fill()函數(shù)的返回值是none（void函數(shù)）。
使用舉例：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
vector<int> myvector(8);
fill(myvector.begin(), myvector.end(), 5);
cout << "after fill myvector content: ";
for(vector<int>::const_iterator it = myvector.begin(); it != myvector.end(); ++it) {
cout << *it << ' ';
}
cout << '\n';
return 0;
}
------
after fill myvector content: 5 5 5 5 5 5 5 5```
**時間復(fù)雜度：**
O(n).
## 2.6 remove：（Remove value from range）
## 2.7 reverse：（Reverse range）
**函數(shù)原型：**
```cpp
template <class BidirectionalIterator>
void reverse (BidirectionalIterator first, BidirectionalIterator last);
reverse()函數(shù)的作用是將區(qū)間 [first, last) 內(nèi)的元素在容器內(nèi)的順序進行反轉(zhuǎn)。
reverse()函數(shù)的返回值是 none（void函數(shù)）。
使用舉例：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
vector<int> myvector(array, array + sizeof(array)/sizeof(int));
reverse(myvector.begin(), myvector.end());
cout << "after reverse myvector content: ";
for(vector<int>::const_iterator it = myvector.cbegin(); it != myvector.cend(); ++it) {
cout << *it << ' ';
}
cout << '\n';
return 0;
}
3. Partitions：
分區(qū)：
3.1 partition：（Partition range in two）
函數(shù)原型：
template <class ForwardIterator, class UnaryPredicate> ForwardIterator partition (ForwardIterator first, ForwardIterator last, UnaryPredicate pred);
partition() 函數(shù)的作用是將 [first, last) 范圍內(nèi)的容器元素 按照自定義的方法 pred 進行分區(qū)（分成 兩個部分），返回值是指向第二部分分區(qū)的首元素的迭代器。
使用舉例：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
bool IsOdd(int i) {
return ( (i%2) ==1 );
}
int main() {
int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
vector<int> myvector(array, array + sizeof(array)/sizeof(int));
vector<int>::iterator bound;
bound = partition(myvector.begin(), myvector.end(), IsOdd);
cout << "after partition myvector content: ";
for(vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it) {
cout << *it << ' ';
}
cout << '\n';
cout << "the second partition content: ";
for(vector<int>::iterator it = bound; it != myvector.end(); ++it) {
cout << *it << ' ';
}
cout << '\n';
return 0;
}
------
1 9 3 7 5 6 4 8 2
6 4 8 2
4. Sorting：
排序：
4.1 sort：（Sort elements in range）
函數(shù)原型：
//default (1) template <class RandomAccessIterator> void sort (RandomAccessIterator first, RandomAccessIterator last); //custom (2) template <class RandomAccessIterator, class Compare> void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
sort() 函數(shù)的作用是將 [first, last) 范圍內(nèi)的元素進行排序，默認的排序方式為 operator<（即“從小到大”排序），也可以接受自定義的排序方式 comp。
使用舉例：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
bool myfunction(int i, int j) {
return ( i > j );
}
int main() {
int array[] = { 32, 71, 12, 45, 26, 80, 53, 33 };
vector<int> myvector(array, array + sizeof(array)/sizeof(int));
sort(myvector.begin(), myvector.end());
cout << "after sort myvector content: ";
for(auto &r : myvector)
cout << r << ' ';
cout << '\n';
sort(myvector.begin(), myvector.end(), myfunction);
cout << "after another sort myvector content: ";
for(auto &r : myvector)
cout << r << ' ';
cout << '\n';
return 0;
}
------
after sort myvector content: 12 26 32 33 45 53 71 80
after another sort myvector content: 80 71 53 45 33 32 26 12
5. Binary Search（operating on partitioned/sorted ranges）：
二分查找：
5.1 binary_search：
函數(shù)原型：
//default (1)
template <class ForwardIterator, class T>
bool binary_search (ForwardIterator first, ForwardIterator last,
const T& val);
//custom (2)
template <class ForwardIterator, class T, class Compare>
bool binary_search (ForwardIterator first, ForwardIterator last,
const T& val, Compare comp);
6. Merge（operating on sorted ranges）：
合并：
6.1 merge：
函數(shù)原型：
//default (1)
template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator merge (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
OutputIterator result);
//custom (2)
template <class InputIterator1, class InputIterator2,
class OutputIterator, class Compare>
OutputIterator merge (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
OutputIterator result, Compare comp);
merge() 函數(shù)的作用是將 [first1, last1)區(qū)間 及 [first2, last2) 區(qū)間的容器元素合并到一起，合并后的結(jié)果存儲到 result指定的位置上。 merge() 默認的合并順序為 operator< （從小到大），也可接受用戶自定義的排序方式 comp。
merge() 函數(shù)必須在 sort() 的基礎(chǔ)上進行合并，否則合并的結(jié)果會出現(xiàn)亂序。且sort()與merge() 的排序算法必須保持一致，即都使用 operator< 或相同的 comp函數(shù)。
merge()函數(shù)返回值是合并后的容器的尾迭代器（容器最后一個元素的后面的位置）。
使用舉例：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int first[] = { 5, 10, 15, 20, 25 };
int second[] = { 50, 1, 2, 3, 4 };
vector<int> result(10);
sort(first, first + 5);
sort(second, second + 5);
vector<int>::iterator it = merge(first, first + 5, second, second + 5, result.begin());
for(vector<int>::iterator iter = result.begin(); iter != it; iter++) {
cout << *iter << ' ';
}
cout << '\n';
return 0;
}
------
1 2 3 4 5 10 15 20 25 50
7. Heap：
堆操作：
8. Min/max：
求最大/最小值，可接受用戶指定的比較方法
到此這篇關(guān)于C++ STL中常見的算法使用方式的文章就介紹到這了,更多相關(guān)C++ STL算法內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章主要為大家詳細介紹了如何通過Qt實現(xiàn)發(fā)送HTTP請求,文中的示例代碼講解詳細,具有一定的借鑒價值,感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下2025-03-03
這篇文章主要介紹了如何利用Qt實現(xiàn)字符串生成二維碼功能，文中的實現(xiàn)過程講解詳細，對我們學(xué)習(xí)Qt有一定的幫助，需要的可以參考一下2022-01-01
C++?超詳細分析數(shù)據(jù)結(jié)構(gòu)中的時間復(fù)雜度
時間復(fù)雜度一般指時間復(fù)雜性。?在計算機科學(xué)中，時間復(fù)雜性，又稱時間復(fù)雜度，算法的時間復(fù)雜度是一個函數(shù)，它定性描述該算法的運行時間2022-03-03
C++ 虛函數(shù)與純虛函數(shù)的使用與區(qū)別
本文主要介紹了C++ 虛函數(shù)與純虛函數(shù)的使用與區(qū)別，文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-08-08
如何實現(xiàn)socket網(wǎng)絡(luò)編程的多線程
首先，學(xué)好計算機網(wǎng)絡(luò)知識真的很重要。雖然，學(xué)不好不會影響理解下面這個關(guān)于宏觀講解，但是，學(xué)好了可以自己打漁吃，學(xué)不好就只能知道眼前有魚吃卻打不到漁。在Java中網(wǎng)絡(luò)程序有2種協(xié)議：TCP和UDP,下面可以和小編一起學(xué)習(xí)下2019-05-05
C++實現(xiàn)LeetCode(92.倒置鏈表之二)
這篇文章主要介紹了C++實現(xiàn)LeetCode(倒置鏈表之二),本篇文章通過簡要的案例,講解了該項技術(shù)的了解與使用,以下就是詳細內(nèi)容,需要的朋友可以參考下2021-07-07
這篇文章主要為大家詳細介紹了C語言實現(xiàn)五子棋人人對戰(zhàn)，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2020-12-12
C語言實現(xiàn)大學(xué)生考勤管理系統(tǒng)
這篇文章主要為大家詳細介紹了C語言實現(xiàn)大學(xué)生考勤管理系統(tǒng)，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2020-12-12
這篇文章主要介紹了使用boost讀取XML文件詳細介紹的相關(guān)資料,需要的朋友可以參考下2016-11-11
這篇文章主要介紹了C++11原子類型與原子操作的相關(guān)資料，幫助大家更好的理解和學(xué)習(xí)c++,感興趣的朋友可以了解下2020-08-08