STL算法部分主要由頭文件<algorithm>,<numeric>,<functional>組成.要使用 STL中的算法函數必須包含頭文件<algorithm>,對於數值算法須包含<numeric>,<functional>中則定義了一些模板類,用來聲明函數對象.
STL中算法大致分為四類:
1、非可變序列算法:指不直接修改其所操作的容器內容的算法.
2、可變序列算法:指可以修改它們所操作的容器內容的算法.
3、排序算法:包括對序列進行排序和合並的算法、搜索算法以及有序序列上的集合操作.
4、數值算法:對容器內容進行數值計算.
<一>查找算法(13個)：判斷容器中是否包含某個值
adjacent_find :在 iterator 對標志的元素范圍內,查找一對相鄰的重復元素,如果找到返回一個 ForwardIterator,指向這對元素的第一個元素.否則返回 last .重載版本使用輸入的二元操作符代替相等的判斷.
參數:first
:last
返回:forwardItr
template<class forwardItr>
forwardItr adjacent_find(forwardItr first, forwardItr last);
參數:first
:last
:op
返回:forwardItr
template<class forwardItr, class binaryPredicate>
forwardItr adjacent_find(forwardItr first, forwardItr last, binaryPredicate op);
#include "stdafx.h" #include <string> #include <iostream> #include <iterator> #include <vector> #include <algorithm> #include <numeric> #include <functional> //x,y為依次相鄰的兩個元素 bool isequal(int x, int y) { return x / 2 == y; } int main() { { std::vector<int> vec = { 12, 22, 11, 33, 33, 43 }; auto pos1 = adjacent_find(vec.begin(), vec.end()); std::cout << *pos1 << std::endl; //輸出:33 auto pos2 = adjacent_find(vec.begin(), vec.end(), isequal); std::cout << *pos2 << std::endl; //輸出:22 getchar(); return 0; } }
search :在一個序列中搜索與另一序列匹配的子序列,找到則返回第一次出現子序列的位置,否則返回last1.重載版本使用自定義的比較操作.
//search是在一個集合中搜索另一個子集，find只搜索單個元素
參數:first1
:last1
:first2
:last2
返回：forwardItr1
template <class forwardItr1, class forwardItr2>
forwardItr1 search(forwardItr1 first1, forwardItr1 last1,forwardItr2 first2,forwardItr2 last2);
參數:first1
:last1
:first2
:last2
:op
返回：forwardItr1
template <class forwardItr1, class forwardItr2,class binaryPredicate>
forwardItr1 search(forwardItr1 first1, forwardItr1 last1,forwardItr2 first2,forwardItr2 last2,binaryPredicate op);
search_n :在指定范圍內查找 value 出現 n 次的子序列.找到則返回第一次出現的位置，找不到則返回last,重載版本使用自定義的比較操作.
參數:first
:last
:count
:value
返回：forwardItr
template <class forwardItr, class size,class Type>
forwardItr search_n(forwardItr first, forwardItr last,size count,const Type& value);
參數:first
:last
:count
:value
:op
返回：forwardItr
template <class forwardItr, class size,class Type,class binaryPredicate>
forwardItr search_n(forwardItr first, forwardItr last,size count,const Type& value,binaryPredicate op);
binary_search :在有序序列中查找 value ,如果找到返回 true .重載的版本使用指定的比較函數對象或者函數指針來判斷相等.
參數:first
:last
:searchValue
返回：bool
template<class forwardItr,class Type>
bool binary_search(forwardItr first,forwardItr last,const Type& searchValue);
參數:first
:last
:searchValue
:op
返回：bool
template<class forwardItr,class Type,class compare>
bool binary_search(forwardItr first, forwardItr last, const Type& searchValue,compare op);
#include "stdafx.h" #include <string> #include <iostream> #include <iterator> #include <vector> #include <algorithm> #include <numeric> #include <functional> bool equal(std::string str1, std::string str2) { //將字符串轉換為大寫 transform(str1.begin(), str1.end(), str1.begin(), ::toupper); transform(str2.begin(), str2.end(), str2.begin(), ::toupper); return str1 == str2 ? true : false; } bool checkequal(int num1, int num2) { bool is = (num1 == num2) ? true : false; return is; } int main() { { std::vector<std::string> vec1 = { "123", "789", "789", "Abc", "abc" }; std::vector<std::string> vec2 = { "789", "Abc" }; auto result1 = search(vec1.begin(), vec1.end(), vec2.begin(), vec2.end()); if (result1 != vec1.end()) { std::cout << *result1 << std::endl; //輸出:789 } else { std::cout << "no found" << std::endl; } //調用自定義的equal函數將字符串轉換為大寫在比較 auto result2 = search(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), equal); if (result2 != vec1.end()) { std::cout << *result2 << std::endl; //輸出:789 } else { std::cout << "no found" << std::endl; } auto result3 = search_n(vec1.begin(), vec1.end(), 2, "789"); if (result3 != vec1.end()) { std::cout << *result3 << std::endl; //輸出:789 } else { std::cout << "no found" << std::endl; } auto result4 = search_n(vec1.begin(), vec1.end(), 2, "abc", equal); if (result4 != vec1.end()) { std::cout << *result4 << std::endl; //輸出:Abc } else { std::cout << "no found" << std::endl; } auto result5 = binary_search(vec1.begin(), vec1.end(), "432"); if (result5) { std::cout << "found" << std::endl; } else { std::cout << "no found" << std::endl; } std::vector<int> vec3 = { 12, 44, 45, 64, 66 }; //這個binary_search找不到也會返回true,是bug還是什么？ auto result6 = binary_search(vec3.begin(), vec3.end(), 43, checkequal); if (result6) { std::cout << "found" << std::endl; } else { std::cout << "no found" << std::endl; } getchar(); return 0; } }
find :find算法用於查找等於某值的元素.它在迭代器區間[first , last)上查找等於value值的元素,如果迭代器iter所指的元素滿足 *iter == value ,則返回迭代器iter,未找則返回last
參數:first
:last
:searchValue
返回:inputItr 如果迭代器iter所指的元素滿足 *iter == value ,則返回迭代器iter,未找則返回last
template <class inputItr,class size,class Type>
inputItr find(inputItr first, inputItr last, const Type& searchValue);
find_if :利用返回布爾值的謂詞判斷pred,檢查迭代器區間[first, last)上的每一個元素,如果迭代器iter滿足pred(*iter) == true,表示找到元素並返回迭代器值iter；未找到元素,則返回last
參數:first
:last
:op
返回:inputItr 迭代器iter滿足pred(*iter) == true,表示找到元素並返回迭代器值iter；未找到元素,則返回last
template <class inputItr, class unaryPredicate>
inputItr find_if(inputItr first, inputItr last, UnaryPredicate op);
find_end :在一個序列中搜索出最后一個與另一序列匹配的子序列.有如下兩個函數原型,在迭代器區間[first1, last1)中搜索出與迭代器區間[first2, last2)元素匹配的子序列,返回首元素的迭代器或last1
//[first2,last2)被看做一個原子,在first1中必須滿足元素數量和first2相同並且連續出現才表示找到，而search被搜索的元素在first1中可以不連續
參數:first1
:last1
:first2
:last2
返回:forwardItr1 在迭代器區間[first1, last1)中搜索出與迭代器區間[first2, last2)元素匹配的子序列,找到則返回首元素的迭代器未找到則返回last1
template <class forwardItr1,class forwardItr2>
forwardItr1 find_end(forwardItr1 first1, forwardItr1 last1,forwardItr2 first2,forwardItr2 last2);
參數:first1
:last1
:first2
:last2
:op
返回:forwardItr1 在迭代器區間[first1, last1)中搜索出與迭代器區間[first2, last2)元素匹配的子序列,返回首元素的迭代器或last1
template <class forwardItr1,class forwardItr2,class binaryPredicate>
forwardItr1 find_end(forwardItr1 first1, forwardItr1 last1,forwardItr2 first2,forwardItr2 last2,binaryPredicate op);
find_first_of :用於查找位於某個范圍之內的元素.它有兩個使用原型,均在迭代器區間[first1, last1)上查找元素*i,使得迭代器區間[first2, last2)有某個元素*j,滿足*i ==*j或滿足二元謂詞函數comp(*i, *j)==true的條件.元素找到則返回迭代器i,否則返回last1
//這里和find_end不一樣，[first2,last2)被看作可以拆開的集合，和search有點像
參數:first1
:last1
:first2
:last2
返回:forwardItr1 元素找到則返回迭代器i,否則返回last1
template <class forwardItr1,class forwardItr2>
forwardItr1 find_first_of(forwardItr1 first1, forwardItr1 last1,forwardItr2 first2,forwardItr2 last2);
參數:first1
:last1
:first2
:last2
:op
返回:forwardItr1 元素找到則返回迭代器i,否則返回last1
template <class forwardItr1,class forwardItr2,class binaryPredicate>
forwardItr1 find_first_of(forwardItr1 first1, forwardItr1 last1,forwardItr2 first2,forwardItr2 last2,binaryPredicate op);
#include <string> #include <iostream> #include <iterator> #include <vector> #include <algorithm> #include <numeric> #include <functional> int main() { { std::vector<int> vec1 = { 82, 32, 11, 33, 33, 43 }; std::vector<int> vec2 = { 32, 11 }; std::vector<int> vec3 = { 32, 33 }; auto result1 = find(vec1.begin(), vec1.end(), 33); std::cout << *result1 << " " << result1 - vec1.begin() << std::endl; auto resutl2 = find_if(vec1.begin(), vec1.end(), find_func); std::cout << *resutl2 << " " << resutl2 - vec1.begin() << std::endl; auto result3 = find_end(vec1.begin(), vec1.end(), vec2.begin(), vec2.end()); if (result3 != vec1.end()) { std::cout << *result3 << " " << result3 - vec1.begin() << std::endl; } auto result4 = find_first_of(vec1.begin(), vec1.end(), vec3.begin(), vec3.end()); if (result4 != vec1.end()) { std::cout << *result4 << " " << result4 - vec1.begin() << std::endl; } getchar(); return 0; } }
count :利用等於操作符,把[first,last)范圍內的元素與value進行比較,並返回相等元素的個數.
參數:first
:last
:value
返回:滿足條件元素的個數
template <class inputItr,class Type>
iterator_traits<inputItr>::difference_type count(inputItr first,inputItr last,const Type& value);
count_if :統計容器指定范圍[first,last)內滿足op條件元素的個數.
參數:first
:last
:op
返回:滿足條件元素的個數
template<class InputIterator, class Predicate>
typename iterator_traits<InputIterator>::difference_type count_if( InputIterator _First, InputIterator _Last, Predicate _Pred );
#include "stdafx.h" #include <vector> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> bool greater10(int num) { return num % 2 ? true : false; } int main() { { std::vector<int> arr = { 12, 43, 23, 65, 34, 23, 55, 56 ,3, 34 }; auto num1 = count(arr.begin(), arr.end(), 34); std::cout << num1 << std::endl; //2 std::cout << "arr.begin() + 8:" << *(arr.begin() + 8) << std::endl; //3 auto num2 = count_if(arr.begin(), arr.end(), greater10); std::cout << num2 << std::endl; //6 getchar(); return 0; } }
equal_range :equal_range是C++ STL中的一種二分查找的算法,試圖在已排序的[first,last)中尋找value,它返回一對迭代器i和j,其中i是在不破壞次序的前提下,value可插入的第一個位置(亦即lower_bound),j則是在不破壞次序的前提下,value可插入的最后一個位置(亦即upper_bound),因此,[i,j)內的每個元素都等同於value,而且[i,j)是[first,last)之中符合此一性質的最大子區間
參數:first
:last
:val
返回:返回一個pair的鍵值對,內容為：first:value可插入的第一個位置(亦即lower_bound)second:value可插入的最后一個位置(亦即upper_bound)
template<class ForwardIterator, class Type>
pair<ForwardIterator, ForwardIterator> equal_range(ForwardIterator first,ForwardIterator last, const Type& val);
參數:first
:last
:val
:comp
返回:返回一個pair的鍵值對,內容為：first:value可插入的第一個位置(亦即lower_bound)second:value可插入的最后一個位置(亦即upper_bound)
template<class ForwardIterator, class Type, class Predicate>
pair<ForwardIterator, ForwardIterator> equal_range(ForwardIterator first,ForwardIterator last, const Type& val, Predicate comp);
#include "stdafx.h" #include <string> #include <iostream> #include <iterator> #include <vector> #include <algorithm> #include <numeric> #include <functional> //x為value,y為元素 bool isGreater(int x, int y) { return x < y ? true : false; } int main() { { std::vector<int> vec = {6, 21, 32, 44, 54}; //返回的值要添加判斷，否則使用指向last的指針會引起程序中斷 //使用pair1.first - first.begin()即可獲得指向元素的索引 auto pair1 = equal_range(vec.begin(), vec.end(), 21); std::cout << *pair1.first << " " << pair1.first - vec.begin() << std::endl; //輸出:21 1 std::cout << *pair1.second << " " << pair1.second - vec.begin() << std::endl; //輸出:22 2 auto pair2 = equal_range(vec.begin(), vec.end(), 66, isGreater); if (pair2.first == vec.end() || pair2.second == vec.end()) { return 0; } std::cout << *pair2.first << std::endl; //輸出:21 std::cout << *pair2.second << std::endl; //輸出:22 getchar(); return 0; } }
一個序列中可能會有很多重復或相同的元素,使用下面兩個函數可以查找滿足條件的第一個或最后一個的位置,STL中的lower_bound,upper_bound算法使用了二分查找的方法
lower_bound :返回一個非遞減序列[first, last)中的第一個大於等於值val的位置.如果所有元素都小於val,則返回last的位置.重載函數使用了自定義的比較操作.
參數:first
:last
:val
返回:ForwardIterator 滿足條件的元素索引
ForwardIterator lower_bound( ForwardIterator first, ForwardIterator last, const Type& val );
upper_bound :返回一個非遞減序列[first, last)中最后一個大於等於val的位置.重載版本使用了輸入的比較操作.
參數:first
:last
:val
返回:ForwardIterator 滿足條件的元素索引
ForwardIter upper_bound(ForwardIter first, ForwardIter last, const _Tp& val)
#include "stdafx.h" #include <string> #include <iostream> #include <iterator> #include <vector> #include <algorithm> #include <numeric> #include <functional> int main() { { std::vector<int> vec = { 5, 21, 22, 23, 25 }; //lower的意義是對於給定的已經排好序的vec，key最早能插入的那個位置 auto result1 = lower_bound(vec.begin(), vec.end(), 22); std::cout << *result1 << std::endl; //輸出:22 //upper的意義是對於給定的已經排好序的vec，key最晚能插入的那個位置 auto result2 = upper_bound(vec.begin(), vec.end(), 22); std::cout << *result2 << std::endl; //輸出:23 getchar(); return 0; } }
<二>排序和通用算法(14個)：提供元素排序策略,會改變原始數據順序
random_shuffle :對指定范圍內的元素隨機調整次序.重載版本輸入一個隨機數產生操作.
參數:first
:last
返回：無
template <class randomAccessItr>
void random_shuffle(randomAccessItr first, randomAccessItr last);
參數:first
:last
:rand
返回：無
template <class randomAccessItr, class randomAccessGenerator>
void random_shuffle(randomAccessItr first,randomAccessItr last,randomAccessGenerator rand);
#include "stdafx.h" #include <random> #include <ctime> #include <string> #include <iostream> #include <iterator> #include <vector> #include <algorithm> #include <numeric> #include <functional> int myrandom(int i) { return std::rand() % i; } int main() { { std::vector<int> vec1 = { 2, 32, 11, 33, 33, 43 }; sort(vec1.begin(), vec1.end()); for (int i = 0; i < vec1.size(); i++) { std::cout << vec1[i] << " "; //輸出:2 11 32 33 33 43 } std::cout << std::endl; default_random_engine defaultEngine(time(0)); shuffle(vec1.begin(), vec1.end(), defaultEngine); for (int i = 0; i < vec1.size(); i++) { std::cout << vec1[i] << " "; //輸出:每次都不一樣 } std::cout << std::endl; random_shuffle(vec1.begin(), vec1.end()); for (int i = 0; i < vec1.size(); i++) { std::cout << vec1[i] << " "; //輸出:每次都一樣 } std::cout << std::endl; std::srand(unsigned(std::time(0))); random_shuffle(vec1.begin(), vec1.end(), myrandom); for (int i = 0; i < vec1.size(); i++) { std::cout << vec1[i] << " "; //輸出:每次都不一樣 } std::cout << std::endl; getchar(); return 0; } }
reverse :將范圍內元素重新按反序排列. 會改變原始數據在容器中的順序
參數:first
:last
返回：無
template <class biDirectionalItr>
void reverse(biDirectionalItr first, biDirectionalItr last);
reverse_copy :類似與 reverse ,不改變原始數據在容器中的順序，不過將內容倒置寫入另外一個容器.
參數:first
:last
:destFirst
返回：outputItr
template <class biDirectionalItr, class outputItr>
outputItr reverse_copy(biDirectionalItr first, biDirectionalItr last,outputItr destFirst);
#include "stdafx.h" #include <string> #include <iostream> #include <iterator> #include <vector> #include <algorithm> #include <numeric> #include <functional> int main() { { std::vector<int> vec1 = { 2, 32, 11, 33, 33, 43 }; reverse(vec1.begin(), vec1.end()); for (int i = 0; i < vec1.size(); i++) { std::cout << vec1[i] << " "; //輸出:43 33 33 11 32 2 } std::cout << std::endl; std::vector<int> vec2(vec1.size()); reverse_copy(vec1.begin(), vec1.end(), vec2.begin()); for (int i = 0; i < vec1.size(); i++) { std::cout << vec1[i] << " "; //輸出:43 33 33 11 32 2 } std::cout << std::endl; for (int i = 0; i < vec2.size(); i++) { std::cout << vec2[i] << " "; //輸出:2 32 11 33 33 43 } std::cout << std::endl; getchar(); return 0; } }
rotate :由newFirst指向的元素成為容器第一個元素,並且將first到newFirst之間的元素移到newFirst指向元素的后面填充，其他元素位置不變.
參數:first
:newFirst
:last
返回：無
template <class forwardItr>
void rotate(forwardItr first, forwardItr newFirst, forwardItr last);
rotate_copy :類似與 rotate ,不過將結果寫入另外一個容器.
參數:first
:middle
:last
:destFirst
返回：outputItr
template <class forwardItr, class outputItr>
outputItr rotate_copy(forwardItr first, forwardItr middle, forwardItr last,outputItr destFirst);
#include <string> #include <iostream> #include <iterator> #include <vector> #include <algorithm> #include <numeric> #include <functional> int main() { { std::vector<int> vec1 = { 2, 32, 11, 33, 33, 43 }; auto it1 = vec1.begin() + 3; rotate(vec1.begin(), it1, vec1.begin() + 4); for (int i = 0; i < vec1.size(); i++) { std::cout << vec1[i] << " "; //輸出:33 2 32 11 33 43 } std::cout << std::endl; std::vector<int> vec2(vec1.size()); auto it2 = vec1.begin() + 3; rotate_copy(vec1.begin(), it2, vec1.end(), vec2.begin()); for (int i = 0; i < vec2.size(); i++) { std::cout << vec2[i] << " "; //輸出:11 33 43 33 2 32 } std::cout << std::endl; getchar(); return 0; } }
merge :將兩個有序序列合並為一個有序序列,元素個數不變，並存放到另外一個序列中.重載版本使用自定義的比較.
參數:first1
:last1
:first2
:last2
:destFirst
返回:outputItr
template<class inputItr1,class inputItr2,class outputItr, class binaryPredicate>
outputItr merge(inputItr1 first1,inputItr1 last1, inputItr2 first2, inputItr2 last2,outputItr destFirst);
參數:first1
:last1
:first2
:last2
:destFirst
:op
返回:outputItr
template<class inputItr1,class inputItr2,class outputItr>
outputItr merge(inputItr1 first1,inputItr1 last1, inputItr2 first2, inputItr2 last2,outputItr destFirst, binaryPredicate op);
inplace_merge :合並兩個排過序的連續序列,結果序列覆蓋了兩端范圍,重載版本使用輸入的操作進行排序.
參數:first1
:middle
:last
返回:void
template <class BidirectionalIterator>
void inplace_merge ( BidirectionalIterator first, BidirectionalIterator middle,BidirectionalIterator last );
參數:first1
:middle
:last
:comp
返回:void
template <class BidirectionalIterator, class Compare>
void inplace_merge ( BidirectionalIterator first, BidirectionalIterator middle,BidirectionalIterator last, Compare comp );
#include "stdafx.h" #include <random> #include <ctime> #include <string> #include <iostream> #include <iterator> #include <vector> #include <algorithm> #include <numeric> #include <functional> int main() { { std::vector<int> vec1 = { 2, 11, 33, 33, 43 }; std::vector<int> vec2 = { 4, 14, 23, 33, 44 }; std::vector<int> vec3(vec1.size() + vec2.size()); auto result = merge(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), vec3.begin()); for (int i = 0; i < vec3.size(); i++) { std::cout << vec3[i] << " "; } std::cout << std::endl; std::vector<int> vec4 = { 4, 6, 8, 12, 20, 1, 5, 8, 10 , 15}; inplace_merge(vec4.begin(), vec4.begin() + 5, vec4.end()); for (int i = 0; i < vec4.size(); i++) { std::cout << vec4[i] << " "; } getchar(); return 0; } }
nth_element :將指定范圍內的序列重新排序,使第n大元素處於第n位置(從0開始,其位置是下標為 n的元素),並且比這個元素小的元素都排在這個元素之前，比這個元素大的元素都排在這個元素之后,但不能保證他們是有序的,重載版本使用了自定義的比較操作.
參數:_First
:_Nth
:_Last
返回:void
template<class _RanIt>
void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last);
參數:_First
:_Nth
:_Last
:_Pred
返回:void
template<class _RanIt, class _Pr>
void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred);
#include "stdafx.h" #include <random> #include <ctime> #include <string> #include <iostream> #include <iterator> #include <vector> #include <algorithm> #include <numeric> #include <functional> int main() { { std::vector<int> vec5 = { 7, 6, 3, 4, 1, 5, 8, 2, 5, 7 }; nth_element(vec5.begin(), vec5.begin() + 4, vec5.begin() + 8); for (int i = 0; i < vec5.size(); i++) { std::cout << vec5[i] << " "; //輸出:1 2 3 4 5 6 7 8 5 7 } std::cout << std::endl; getchar(); return 0; } }
sort :以升序重新排列范圍內的元素,重載版本使用了自定義的比較操作.
參數:first
:last
返回：void
template<class randomAccessItr>
void sort(randomAccessItr first,randomAccessItr last);
參數:first
:last
:op
返回：void
template<class randomAccessItr, class compare>
void sort(randomAccessItr first, randomAccessItr last, compare op);
is_sorted:檢查指定范圍內元素是否排序
參數:first
:last
返回：bool 已排序返回true,未排序返回false
template <class ForwardIterator>
bool is_sorted (ForwardIterator first, ForwardIterator last);
template <class ForwardIterator, class Compare>
bool is_sorted (ForwardIterator first, ForwardIterator last, Compare comp);
partion :對指定范圍內元素重新排序,根據自定義函數,把計算結果為 true 的元素放在結果為 false 的元素之前.
參數:first
:last
:pred
返回：ForwardIterator 排序后返回首個不滿足條件元素迭代器
template <class ForwardIterator, class Predicate>
ForwardIterator partition(ForwardIterator first, ForwardIterator last, Predicate pred);
partial_sort :對整個序列做部分排序,被排序元素的個數正好可以被放到范圍內.重載版本使用自定義的比較操作.
參數:first
:middle
:last
返回：void
template <class RandomAccessIterator>
void partial_sort ( RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last );
參數:first
:middle
:last
:comp
返回：void
template <class RandomAccessIterator, class Compare>
void partial_sort ( RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp );
partial_sort_copy :與 partial_sort 相同,除了將經過排序的序列復制到另外一個容器.
參數:first
:last
:result_first
:result_last
返回：RandomAccessIterator
template <class InputIterator, class RandomAccessIterator>
RandomAccessIterator partial_sort_copy ( InputIterator first,InputIterator last, RandomAccessIterator result_first, RandomAccessIterator result_last );
參數:first
:last
:result_first
:result_last
:comp
返回：RandomAccessIterator
template <class InputIterator, class RandomAccessIterator, class Compare>
RandomAccessIterator partial_sort_copy ( InputIterator first,InputIterator last, RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp );
所謂穩定排序，是指對一個序列進行排序之后，如果兩個元素的值相等，則原來亂序時在前面的元素現在（排好序之后）仍然排在前面
stable_sort :類似與 sort ,不過保留容器中相等元素之間的順序關系.
參數:first
:last
返回:void
template <class RandomAccessIterator>
void stable_sort ( RandomAccessIterator first, RandomAccessIterator last );
參數:first
:last
:comp
返回:void
template <class RandomAccessIterator, class Compare>
void stable_sort ( RandomAccessIterator first, RandomAccessIterator last, Compare comp );
stable_partition :與 partition 類似,不過保留容器中相等元素之間的相對順序.
參數:first
:last
:pred
返回:BidirectionalIterator
template <class BidirectionalIterator, class UnaryPredicate>
BidirectionalIterator stable_partition (BidirectionalIterator first, BidirectionalIterator last, UnaryPredicate pred);
#include "stdafx.h" #include <random> #include <ctime> #include <string> #include <iostream> #include <iterator> #include <vector> #include <algorithm> #include <numeric> #include <functional> int main() { { std::vector<int> vec1 = { 22, 11, 5, 33, 43 }; sort(vec1.begin(), vec1.end()); for (int i = 0; i < vec1.size(); i++) { std::cout << vec1[i] << " "; //輸出:5 11 22 33 43 } std::cout << std::endl; sort(vec1.begin(), vec1.end(), [](int x, int y)->bool { return x > y; }); for (int i = 0; i < vec1.size(); i++) { std::cout << vec1[i] << " "; //輸出:43 33 22 11 5 } std::cout << std::endl; std::vector<int> vec2 = { 22, 5, 33, 43, 10 }; auto result2 = partition(vec2.begin(), vec2.end(), [](int x)->bool { return x % 2 == 0 ? true : false; }); std::cout << *result2 << std::endl; //輸出:33 注意是33說明5和10是調換位置 for (int i = 0; i < vec2.size(); i++) { std::cout << vec2[i] << " "; //輸出:22 10 33 43 5 } std::cout << std::endl; std::vector<int> vec3 = { 7, 6, 9, 4, 1, 5, 8, 2, 3 }; partial_sort(vec3.begin(), vec3.begin() + 2, vec3.end()); for (int i = 0; i < vec3.size(); i++) { std::cout << vec3[i] << " "; //輸出:1 2 9 7 6 5 8 4 3 } std::cout << std::endl; std::vector<int> vec4(vec3.size()); partial_sort_copy(vec3.begin(), vec3.end(), vec4.begin(), vec4.end()); for (int i = 0; i < vec4.size(); i++) { std::cout << vec4[i] << " "; //輸出:1 2 3 4 5 6 7 8 9 } std::cout << std::endl; getchar(); return 0; } }
<三>刪除和替換算法(15個)
copy :用於容器之間元素的拷貝,即將迭代器區間[first,last)的元素復制到目標容器中
參數:_First 指出被復制的元素的區間范圍[ _First,_Last).
:_Last
:_DestBeg 指出復制到的目標區間起始位置
返回:OutputIterator 返回一個迭代器,指向目標容器中拷貝元素區間的下一個位置(因為是左必右開,也就是目標容器的_DestBeg位置)
template<class InputIterator, class OutputIterator>
OutputIterator copy(InputIterator _First, InputIterator _Last, OutputIterator _DestBeg);
copy_backward :其復制過程是從最后的元素開始復制,直到首元素復制出來.也就是說,復制操作是從last-1開始,直到first結束.這些元素也被從后向前復制到目標容器中
參數:_First
:_Last
:_Dest
返回:_BidIt2 返回一個迭代器,指出已被復制元素區間的起始位置
template<class _BidIt1, class _BidIt2> inline
_BidIt2 copy_backward(_BidIt1 _First, _BidIt1 _Last,_BidIt2 _Dest);
copy_if:將滿足條件的元素(對元素調用pred返回true的元素)復制到目標容器中
參數:_First
:_Last
:_Dest
:_Pred
返回:_BidIt2 返回一個迭代器,指向目標容器中最后一個拷貝元素的下一個位置
template<class InputIterator, class OutputIterator, class BinaryPredicate>
OutputIterator copy_if(InputIterator _First, InputIterator _Last,OutputIterator _Dest,Predicate _Pred);
copy_n:從first開始復制count個元素到result的容器中
參數:first
:count
:dest
返回:OutputIterator 返回一個迭代器,指向目標容器中最后一個拷貝元素的下一個位置
template<class InputIterator, class Size, class OutputIterator>
OutputIterator copy_n(InputIterator first, Size count, OutputIterator dest);
#include "stdafx.h" #include <vector> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> bool greater10(int num) { return num % 2 ? true : false; } int main() { { std::vector<int> arr = { 12, 43, 23, 65, 34, 23, 55, 56 ,3, 34 }; std::vector<int> arr1(10); std::vector<int> arr2(10); std::vector<int> arr3(10); std::vector<int> arr4(10); auto var1 = copy(arr.begin() + 3, arr.begin() + 5, arr1.begin()); for (int i = 0; i < arr1.size(); i++) { std::cout << arr1[i] << " "; } std::cout << std::endl; auto var2 = copy_backward(arr.begin(), arr.begin() + 5, arr2.end()); for (int i = 0; i < arr2.size(); i++) { std::cout << arr2[i] << " "; } std::cout << std::endl; auto var3 = copy_if(arr.begin(), arr.begin() + 5, arr3.begin(), greater10); for (int i = 0; i < arr3.size(); i++) { std::cout << arr3[i] << " "; } std::cout << std::endl; auto var4 = copy_n(arr.begin(), 5, arr4.begin()); for (int i = 0; i < arr4.size(); i++) { std::cout << arr4[i] << " "; } std::cout << std::endl; getchar(); return 0; } }
vector中的remove的作用是將等於value的元素放到vector的尾部，但並不減少vector的size(尾部為無效數據)
移除容器里面的元素應該使用容器自帶的remove,不應該使用remove算法
remove :刪除在范圍內的所有等於指定的元素,注意,該函數並不真正刪除元素.內置數組不適合使用 remove 和 remove_if 函數.
參數:first
:last
:value
返回：forwardItr 指向容器中第一個無效數據的迭代器
template <class forwardItr,class Type>
forwardItr remove(forwardItr first, forwardItr last, const Type& value);
remove_copy :將所有不匹配的元素都復制到一個指定容器,
參數:first1
:last1
:destFirst
:value
返回：outputItr 指向被拷貝最后元素的下一個位置的迭代器
template <class inputItr,class outputItr,class Type>
outputItr remove_copy(inputItr first1, inputItr last1, outputItr destFirst, const Type& value);
remove_if :刪除指定范圍內輸入操作結果為 true 的元素.
參數:first
:last
:destFirst
:op
返回：forwardItr
template <class forwardItr, class unaryPredicate>
forwardItr remove_if(forwardItr first, forwardItr last, unaryPredicate op);
remove_copy_if :將所有不匹配的元素拷貝到一個指定容器.
參數:first1
:last1
:destFirst
:op
返回：outputItr 指向被拷貝最后元素的下一個位置的迭代器
template <class inputItr,class outputItr, class unaryPredicate>
outputItr remove_copy_if(inputItr first1, inputItr last1, outputItr destFirst, unaryPredicate op)
#include "stdafx.h" #include <vector> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> bool remove_func(int x) { return x % 2 == 0 ? true : false; } int main() { { //如果為1234 remove 2 = 1344 3被復制到2的位置，4被復制到3的位置,后面的原來是什么就是什么 std::vector<int> vec1 = { 34, 43, 34, 65, 34, 23, 55, 56 ,2, 34 }; auto result1 = remove(vec1.begin(), vec1.end(), 34); std::cout << *result1 << std::endl; //輸出:55 指向首個無效數據的迭代器 for (int i = 0; i < vec1.size(); i++) { std::cout << vec1[i] << " "; //輸出:43 65 23 55 56 2 55 56 2 34 } std::cout << std::endl; std::vector<int> vec2 = { 34, 43, 34, 65, 34, 23, 55, 56 ,2, 34 }; std::vector<int> vec3(vec2.size()); auto result2 = remove_copy(vec2.begin(), vec2.end(), vec3.begin(), 34); std::cout << *result2 << std::endl; //輸出:0 指向最后一個拷貝元素下一個位置的迭代器 for (int i = 0; i < vec3.size(); i++) { std::cout << vec3[i] << " "; //輸出:43 65 23 55 56 2 0 0 0 0 } std::cout << std::endl; //同remove一樣，將不要刪除的元素往前移，后面的元素是無效數據 std::vector<int> vec4 = { 34, 43, 34, 65, 34, 23, 55, 56 ,2, 34 }; remove_if(vec4.begin(), vec4.end(), remove_func); for (int i = 0; i < vec4.size(); i++) { std::cout << vec4[i] << " "; //輸出:43 65 23 55 34 23 55 56 2 34 } std::cout << std::endl; std::vector<int> vec5 = { 34, 43, 34, 65, 34, 23, 55, 56 ,2, 34 }; std::vector<int> vec6(vec5.size()); auto result5 = remove_copy_if(vec5.begin(), vec5.end(), vec6.begin(), remove_func); std::cout << *result5 << std::endl; //輸出:0 指向最后一個拷貝元素下一個位置的迭代器 for (int i = 0; i < vec6.size(); i++) { std::cout << vec6[i] << " "; //輸出:43 65 23 55 0 0 0 0 0 0 } std::cout << std::endl; getchar(); return 0; } }
replace :將范圍內的所有等於 old_value 的元素都用 new_value 替代.
參數:first
:last
:oldValue
:newValue
返回：無
template <class forwardItr,class Type>
void replace(forwardItr first, forwardItr last,const Type& oldValue, const Type& newValue);
replace_copy :與 replace 類似,不過將結果寫入另外一個容器.
參數:first1
:last1
:destFirst
:oldValue
:newValue
返回：outputItr 指向dest最后拷貝元素的下一個位置
template <class inputItr,class outputItr,class Type>
outputItr replace_copy(inputItr first1, inputItr last1, outputItr destFirst,const Type& oldValue, const Type& newValue);
replace_if :將范圍內的所有操作結果為 true 的元素用新值替代.
參數:first
:last
:op
:newValue
返回：無
template <class forwardItr, class unaryPredicate,class Type>
void replace_if(forwardItr first, forwardItr last, unaryPredicate op,const Type& newValue);
replace_copy_if :類似與 replace_if ,不過將結果寫入另外一個容器.
參數:first1
:last1
:destFirst
:op
:newValue
返回：outputItr 指向dest拷貝最后元素的下一個位置的迭代器
template <class inputItr,class outputItr, class unaryPredicate>
outputItr replace_copy_if(inputItr first1, inputItr last1, outputItr destFirst, unaryPredicate op,const Type& newValue);
#include "stdafx.h" #include <vector> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> bool replace_func(int x) { return x % 2 == 0 ? true : false; } int main() { { std::vector<int> vec1 = { 12, 22, 11, 33, 11, 4 }; replace(vec1.begin(), vec1.end(), 11, 3); for (int i = 0; i < vec1.size(); i++) { std::cout << vec1[i] << " "; //輸出:12 22 3 33 3 4 } std::cout << std::endl; std::vector<int> vec2 = { 12, 22, 11, 33, 11, 4 }; std::vector<int> vec3(vec2.size()); auto result1 = replace_copy(vec2.begin(), vec2.end(), vec3.begin(), 11, 3); result1--; std::cout << *result1 << std::endl; //輸出:4 for (int i = 0; i < vec3.size(); i++) { std::cout << vec3[i] << " "; //輸出:12 22 3 33 3 4 } std::cout << std::endl; std::vector<int> vec4 = { 12, 22, 11, 33, 11, 4 }; replace_if(vec4.begin(), vec4.end(), replace_func, 7); for (int i = 0; i < vec4.size(); i++) { std::cout << vec4[i] << " "; //輸出:7 7 11 33 11 7 } std::cout << std::endl; std::vector<int> vec5 = { 12, 22, 11, 33, 11, 4 }; std::vector<int> vec6(vec5.size()); replace_copy_if(vec5.begin(), vec5.end(), vec6.begin(), replace_func, 5); for (int i = 0; i < vec6.size(); i++) { std::cout << vec6[i] << " "; //輸出:5 5 11 33 11 5 } std::cout << std::endl; getchar(); return 0; } }
swap :交換存儲在兩個對象中的值.
template<class Type>
void swap(Type& objcet1, Type& objec2);
swap_range :將在范圍內的元素與另外一個序列的元素值進行交換.
template<class forwardItr1, class forwardItr2>
forwardItr2 swap_ranges(forwardItr1 first,forwardItr1 last, forwardItr2 first2);
iter_swap :交換兩個 ForwardIterator 的值.
template<class forwardItr1,class forwardItr2>
void iter_swap(forwardItr1 first,forwardItr2 scecod);
#include "stdafx.h" #include <vector> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> int main() { { std::vector<int> vec1 = { 12, 22, 11, 33, 4 }; std::vector<int> vec2 = { 3, 4, 23, 11, 7 }; swap(vec1, vec2); for (int i = 0; i < vec1.size(); i++) { std::cout << vec1[i] << " "; //輸出:3 4 23 11 7 } std::cout << std::endl; for (int i = 0; i < vec2.size(); i++) { std::cout << vec2[i] << " "; //輸出:12 22 11 33 4 } std::cout << std::endl; std::vector<int> vec3 = { 12, 22, 11, 33, 4 }; std::vector<int> vec4 = { 3, 4, 23, 11, 7 }; swap_ranges(vec3.begin(), vec3.begin() + 3, vec4.begin() + 2); for (int i = 0; i < vec3.size(); i++) { std::cout << vec3[i] << " "; //輸出:23 11 7 33 4 } std::cout << std::endl; for (int i = 0; i < vec4.size(); i++) { std::cout << vec4[i] << " "; //輸出:3 4 12 22 11 } std::cout << std::endl; std::vector<int> vec5 = { 12, 22, 11, 33, 4 }; iter_swap(vec5.begin() + 1, vec5.begin() + 3); for (int i = 0; i < vec5.size(); i++) { std::cout << vec5[i] << " "; //輸出:12 33 11 22 4 } std::cout << std::endl; getchar(); return 0; } }
unique :unique的功能是去除相鄰的重復元素(只保留一個),其實它並不真正把重復的元素刪除,只是把重復的元素移到后面去了,然后依然保存到了原數組中,然后返回去重后最后一個元素的地址,因為unique去除的是相鄰的重復元素,所以一般用之前都會要排一下序.
注意,unique並不直接改變容器的大小,只改變容器元素的順序.調用unique“刪除”了相鄰的重復值.給“刪除”加上引號是因為unique實際上並沒有刪除任何元素,而是將無重復的元素復制到序列的前段,從而覆蓋相鄰的重復元素.unique返回的迭代器如果需要添加或刪除元素,則必須使用容器操作.原理與remove類似
參數:_First
:_Last
返回：ForwardIterator 指向超出無重復的元素范圍末端的下一個位置.
template<class ForwardIterator>
ForwardIterator unique(ForwardIterator _First, ForwardIterator _Last);
template<class ForwardIterator, class Predicate>
ForwardIterator unique(ForwardIterator _First, ForwardIterator _Last,Predicate _Comp);
unique_copy :類似與 unique ,不過它把結果輸出到另外一個容器.
template<class InputIterator, class OutputIterator>
OutputIterator unique_copy(InputIterator _First, InputIterator _Last, OutputIterator _Result);
template<class InputIterator, class OutputIterator, class BinaryPredicate>
OutputIterator unique_copy(InputIterator _First, InputIterator _Last, OutputIterator _Result,BinaryPredicate _Comp,);
#include "stdafx.h" #include <vector> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> int main() { { std::vector<int> vec1 = { 12, 22, 33, 33, 33, 44 }; auto result1 = unique(vec1.begin(), vec1.end()); std::cout << *result1 << std::endl; for (int i = 0; i < vec1.size(); i++) { std::cout << vec1[i] << " "; //輸出:12 22 33 44 33 44 } std::cout << std::endl; std::vector<int> vec2 = { 12, 22, 33, 33, 33, 44 }; std::vector<int> vec3(vec2.size()); auto result2 = unique_copy(vec2.begin(), vec2.end(), vec3.begin()); result2--; std::cout << *result2 << std::endl; for (int i = 0; i < vec3.size(); i++) { std::cout << vec3[i] << " "; //輸出:12 22 33 44 0 0 } std::cout << std::endl; getchar(); return 0; } }
<四>排列組合算法(2個)：提供計算給定集合按一定順序的所有可能排列組合
next_permutation :取出當前范圍內的排列,並將其重新排序為下一個排列.重載版本使用自定義的比較操作.
prev_permutation :取出范圍內的序列並將它重新排序為上一個序列.如果不存在上一個序列則返回 false .重載版本使用自定義的比較操作.
#include "stdafx.h" #include <stdio.h> #include <ctime> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> #include <numeric> int main() { { int myints[] = { 1,2,3 }; std::sort(myints, myints + 3); std::cout << "The 3! possible next_permutations with 3 elements:\n"; do { std::cout << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n'; } while (std::next_permutation(myints, myints + 3)); std::cout << "After loop: " << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n'; std::cout << "The 3! possible prev_permutations with 3 elements:\n"; do { std::cout << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n'; } while (std::prev_permutation(myints, myints + 3)); std::cout << "After loop: " << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n'; getchar(); return 0; } }
<五>算術算法(4個)
主要是對容器的數據元素進行數值計算,所在頭文件為：<numeric>
accumlate :函數將第三個實參用作累加的初始值(init),然后在此初值上累加輸入范圍內所有元素的值.accumulate算法返回累加的結果,其返回類型就是第三個實參的類型.容器內的元素類型必須與第三個實參的類型匹配,或者可轉換為第三個實參的類型.
參數:first
:last
:init 累加初始值
返回:Type
template <class inputItr, class Type>
Type accumulate(inputItr first, inputItr last, Type init);
參數:first
:last
:init
:op 函數第一個參數總為初始值(會變化),第二個參數依次為集合的每一元素
返回:Type
template <class inputItr, class Type, class binaryOperation>
Type accumulate(inputItr first, inputItr last, Type init,binaryOperation op);
template<class _InIt, class _Ty, class _Fn2>
inline _Ty _Accumulate_unchecked(_InIt _First, _InIt _Last, _Ty _Val, _Fn2& _Func) { // return sum of _Val and all in [_First, _Last), using _Func for (; _First != _Last; ++_First) _Val = _Func(_Val, *_First); return (_Val); }
#include <string> #include <iostream> #include <vector> #include <algorithm> #include <numeric> using namespace std; int multiply(int x, int y) { return x - y; } int main() { { //用accumulate統計vector<int>容器對象中的元素之和 std::vector<int> vec = {32, 11, 23, 4, 44}; int sum = accumulate(vec.begin(), vec.end(), 1000); std::cout << sum << std::endl; //可以使用accumulate把string型的vector容器中的元素連接起來 std::vector<std::string> vec2 = { "32", "11", "23", "4", "44" }; string str = accumulate(vec2.begin(), vec2.end(), string(" ")); std::cout << str << std::endl; int total = accumulate(vec.begin(), vec.end(), 1000, multiply); std::cout << total << std::endl; } getchar(); return EXIT_SUCCESS; }
adjacent_difference :創建一個新序列,該序列的每個新值都代表了當前元素與上一個元素的差.重載版本用指定的二元操作計算相鄰元素的差.
參數:first
:last
:destFirst 輸出集合
template<class inputItr, class outputItr, class binaryOperation>
outputItr adjacent_difference(inputItr first,inputItr last, outputItr destFirst);
參數:first
:last
:destFirst 輸出集合
:op
template<class inputItr, class outputItr>
outputItr adjacent_difference(inputItr first,inputItr last, outputItr destFirst,binaryOperation op);
#include <string> #include <iostream> #include <vector> #include <algorithm> #include <numeric> //x為當前元素，y為上一個元素 int sub(int x, int y) { return x + (x - y); } int main() { { std::vector<int> vec = { 12, 22, 11, 33, 33, 43 }; std::vector<int> vec2(6); auto it = adjacent_difference(vec.begin(), vec.end(), vec2.begin()); for (int i = 0; i < vec2.size(); i++) { std::cout << vec2[i] << " "; //輸出：12 10 -11 22 0 10 } auto it2 = adjacent_difference(vec.begin(), vec.end(), vec2.begin(), sub); for (int i = 0; i < vec2.size(); i++) { std::cout << vec2[i] << " "; //輸出：12 32 0 55 33 53 } getchar(); return 0; } }
inner_product :對兩個序列做內積 ( 對應的元素相乘,再求和 ) ,並將內積加到一個輸入的的初始值上.重載版本使用了用戶定義的操作.
參數:first1
:last1
:first2
:init
template<class inputItr1, class inputItr2,class Type>
Type inner_product(inputItr1 first1,inputItr1 last1,inputItr2 first2,Type init);
參數:first1
:last1
:first2
:last2
:init
:op1
:op2
template<class inputItr1, class inputItr2,class Type, class binaryOperation1, class binaryOperation2>
Type inner_product(inputItr1 first1,inputItr1 last1,inputItr2 first2,inputItr2 last2,Type init,binaryOperation1 op1,binaryOperation2 op2);
#include <string> #include <iostream> #include <vector> #include <algorithm> #include <numeric> using namespace std; int main() { { std::vector<int> vec = { 12, 22, 11, 33, 33, 43 }; std::vector<int> vec2 = { 10, 10, 10, 10, 10, 10 }; //vec[i]*vec2[i] + vec[i+1]*vec2[i+1] auto value = inner_product(vec.begin(), vec.end(), vec2.begin(), 0); std::cout << value << std::endl; auto value2 = inner_product(vec.begin(), vec.end(), vec2.begin(), 0, plus<int>(), minus<int>()); std::cout << value2 << std::endl; getchar(); return 0; } }
partial_sum :創建一個新的元素序列,其中每個元素的值代表了范圍內該位置之前所有元素之和.重載版本使用了自定義操作替代加法.
參數:first
:last
:destFirst
template<class inputItr, class outputItr>
outputItr partial_sum(inputItr first,inputItr last,outputItr destFirst);
參數:first
:last
:destFirst
:op
template<class inputItr, class outputItr, class binaryOperation>
outputItr partial_sum(inputItr first,inputItr last,outputItr destFirst,binaryOperation op);
#include <string> #include <iostream> #include <vector> #include <algorithm> #include <numeric> using namespace std; int sum(int x, int y) { return x + (y - 10); } int main() { { std::vector<int> vec = { 12, 22, 11, 33, 33, 43 }; std::vector<int> sum_vec(6); auto pos = partial_sum(vec.begin(), vec.end(), sum_vec.begin()); for (int i = 0; i < sum_vec.size(); i++) { std::cout << sum_vec[i] << " "; } auto pos2 = partial_sum(vec.begin(), vec.end(), sum_vec.begin(), sum); for (int i = 0; i < sum_vec.size(); i++) { std::cout << sum_vec[i] << " "; } getchar(); return 0; } }
<六>生成和異變算法(6個)
fill :將容器中指定位置[first, last)元素的值賦值為value.
參數:first
:last
:value
返回:無
template <class forwardItr, class Type>
void fill(forwardItr first, forwardItr last, const Type& value);
fill_n :將容器中指定位置[first, frist+n) 范圍內的元素賦值為value.
參數:first
:n
:value
返回:無
template <class forwardItr, class size, class Type>
void fill_n(forwardItr first, size n, const Type& value);
#include "stdafx.h" #include <vector> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> int main() { { std::vector<int> arr = { 12, 43, 23, 65, 34, 23, 55, 56 ,3, 34 }; fill(arr.begin(), arr.end(), 10); for (int i = 0; i < arr.size(); i++) { std::cout << arr[i] << " "; } std::cout << std::endl; fill_n(arr.begin(), 5, 3); for (int i = 0; i < arr.size(); i++) { std::cout << arr[i] << " "; } std::cout << std::endl; getchar(); return 0; } }
for_each :依次對范圍內的所有元素執行輸入的函數.
參數:first
:last
:func
返回:Function 返回f函數的首地址
template <class inputItr,class function>
Function for_each(InputIterator first, InputIterator last, Function f) {
for ( ; first != last; ++first) f(*first);
return f;
}
#include "stdafx.h" #include <vector> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> int main() { { std::vector<int> vec1 = { 12, 22, 33, 33, 33, 44 }; for_each(vec1.begin(), vec1.end(), [](int x)->void { std::cout << x << " "; }); //輸出:12 22 33 33 33 44 getchar(); return 0; } }
generate :用指定函數對象產生的值去給容器指定范圍內元素賦值
參數:first
:last
:gen
返回:無
template <class forwardItr, class function>
void generate(forwardItr first, forwardItr last, function gen);
generate_n :一個函數對象產生的值給一定的范圍內指定數目的容器元素賦值
參數:first
:n
:gen
返回:無
template <class forwardItr, class size, class function>
void generate_n(forwardItr first, size n, function gen);
#include "stdafx.h" #include <ctime> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> int generate_func() { return std::rand() % 10; } int main() { { std::vector<int> vec1(5); std::srand(unsigned(std::time(0))); generate(vec1.begin(), vec1.end(), generate_func); for_each(vec1.begin(), vec1.end(), [](int x)->void { std::cout << x << " "; }); //輸出:9 0 4 1 1 std::cout << std::endl; std::vector<int> vec2(5); generate_n(vec2.begin(), 3, generate_func); for_each(vec2.begin(), vec2.end(), [](int x)->void { std::cout << x << " "; }); //輸出:7 0 6 0 0 getchar(); return 0; } }
transform :將要執行的操作作用在指定范圍內的每個元素上,並產生一個新的序列.重載版本將操作作用在一對元素上,另外一個元素來自輸入的另外一個序列.結果輸出到指定的容器.
參數:first
:last
:destFirst
:op
返回：outputItr
template <class inputItr, class outputItr, class unaryOperation>
outputItr transform(inputItr first,inputItr last, outputItr destFirst,unaryOperation op);
參數:first1
:last1
:first2
:destFirst
:bop
返回：outputItr
template <class inputItr1, class inputItr2, class outputItr, class binaryOperation>
outputItr transform(inputItr1 first1, inputItr1 last, inputItr2 first2, outputItr destFirst,binaryOperation bop);
#include "stdafx.h" #include <ctime> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> int transfrom_func1(int x) { return x + 1; } int transfrom_func2(int x, int y) { return x + y; } int main() { { std::vector<int> vec1 = { 12, 4, 11, 5, 1, 8 }; std::vector<int> vec2(vec1.size()); /////將first容器的元素加1賦值給second容器 transform(vec1.begin(), vec1.end(), vec2.begin(), transfrom_func1); for_each(vec2.begin(), vec2.end(), [](int x)->void { std::cout << x << " "; }); //輸出:13 5 12 6 2 9 std::cout << std::endl; std::vector<int> vec3 = { 12, 4, 11, 5, 1, 8 }; std::vector<int> vec4 = { 3, 13, 44, 7, 12, 5 }; /////將first容器的元素與second容器的元素相加，並將得到的結果重新賦值給first transform(vec3.begin(), vec3.end(), vec4.begin(), vec3.begin(), transfrom_func2); for_each(vec3.begin(), vec3.end(), [](int x)->void { std::cout << x << " "; }); //輸出:15 17 55 12 13 13 getchar(); return 0; } }
<七>關系算法(8個)
max:判斷兩個數值中的較大值
參數:aVal
:bVal
返回:Type&
template <class Type>
const Type& max(const Type& aVal, const Type&bVal);
參數:aVal
:bVal
:comp
返回:Type&
template <class Type,class compare>
const Type& max(const Type& aVal,const Type& bVal,compare comp);
max_element:查找指定區間的最大元素
參數:first
:last
返回:forwardItr
template <class forwardItr>
forwardItr max_element(forwardItr first,forwardItr last);
參數:first
:last
:comp
返回:forwardItr
template <class forwardItr, class compare>
forwardItr max_element(forwardItr first,forwardItr last, compare comp);
min:判斷兩個數值中的較小值
參數:aVal
:bVal
返回:Type&
template <class Type>
const Type& min(const Type& aVal, const Type&bVal);
參數:aVal
:bVal
:comp
返回:Type&
template <class Type,class compare>
const Type& min(const Type& aVal,const Type& bVal,compare comp);
min_element:查找指定區間的最小元素
參數:first
:last
返回:forwardItr
template <class forwardItr>
forwardItr min_element(forwardItr first,forwardItr last);
參數:first
:last
:comp
返回:forwardItr
template <class forwardItr, class compare>
forwardItr min_element(forwardItr first,forwardItr last, compare comp);
minmax_element:查找指定區間的最大和最小元素
參數:first
:last
返回:pair<ForwardIterator,ForwardIterator> 返回指定范圍內的最大最小值的元素的迭代器組成的一個pair
template <class ForwardIterator>
pair<ForwardIterator,ForwardIterator> minmax_element (ForwardIterator first, ForwardIterator last);
參數:first
:last
:comp
返回:pair<ForwardIterator,ForwardIterator> 返回指定范圍內的最大最小值的元素的迭代器組成的一個pair
template <class ForwardIterator, class Compare>
pair<ForwardIterator,ForwardIterator> minmax_element (ForwardIterator first, ForwardIterator last, Compare comp);
mismatch :並行的比較兩個序列的指定范圍,指出第一個不匹配的位置.重載版本使用自定義的比較操作.
參數:_First1
:_Last1
:_First2
返回:pair<InputIterator1, InputIterator2> 它返回一對 iterator,first,second分別指向兩個集合不同元素的位置,如相同，則返回每個容器的last
template<class InputIterator1, class InputIterator2>
pair<InputIterator1, InputIterator2> mismatch(InputIterator1 _First1, InputIterator1 _Last1,InputIterator2 _First2);
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
pair<InputIterator1, InputIterator2> mismatch(InputIterator1 _First1, InputIterator1 _Last1,InputIterator2 _First2BinaryPredicate _Comp);
#include "stdafx.h" #include <stdio.h> #include <ctime> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> #include <numeric> int main() { { std::vector<int> vec1 = { 12, 4, 11, 22, 1, 8 }; auto result1 = std::max(vec1.begin() + 3, vec1.begin() + 2); std::cout << *result1 << std::endl; //輸出:22 auto result3 = std::min(vec1.begin() + 2, vec1.begin() + 1); std::cout << *result3 << std::endl; //輸出:4 auto result2 = max_element(vec1.begin(), vec1.end()); std::cout << *result2 << std::endl; //輸出:22 auto result4 = min_element(vec1.begin(), vec1.end()); std::cout << *result4 << std::endl; //輸出:1 std::vector<int> vec3 = { 12, 4, 11, 22, 1, 8 }; std::vector<int> vec4 = { 12, 15, 11, 4, 10, 8 }; auto result5 = mismatch(vec3.begin(), vec3.end(), vec4.begin(), vec4.end()); std::cout << *result5.first << " " << *result5.second << std::endl; //輸出:4 15 getchar(); return 0; } }
equal :如果兩個序列在指定范圍內的元素都相等,則 equal 返回 true .重載版本使用輸入的操作符代替了默認的等於操作符.
equal是兩個集合對應位置元素的比，includes是集合和子集包含關系
參數:First1
:Last1
:First2
返回:true 標識容器元素相等,false容器元素不相等
template<class InputIterator1, class InputIterator2>
bool equal(InputIterator1 First1, InputIterator1 Last1,InputIterator2 First2);
參數:First1
:Last1
:First2
:Comp 比較條件
返回:true 標識容器元素相等,false容器元素不相等
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
bool equal(InputIterator1 First1,InputIterator1 Last1,InputIterator2 First2,BinaryPredicate Comp);
參數:First1
:Last1
:First2
:Last2
返回:true 標識容器元素相等,false容器元素不相等
template<class InputIterator1, class InputIterator2>
bool equal(InputIterator1 First1, InputIterator1 Last1,InputIterator2 First2,InputIterator2 Last2);
參數:First1
:Last1
:First2
:Last2
:Comp 比較條件比如：判斷兩個容器中元素絕對值相等
返回:true 標識容器元素相等,false容器元素不相等
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
bool equal(InputIterator1 First1,InputIterator1 Last1,InputIterator2 First2,InputIterator2 Last2,BinaryPredicate Comp);
#include "stdafx.h" #include <stdio.h> #include <ctime> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> #include <numeric> int main() { { std::vector<int> vec1 = { 12, 4, 11, 22, 1, 8 }; std::vector<int> vec2 = { 4, 11 }; auto result1 = equal(vec1.begin(), vec1.begin(), vec2.begin(), vec2.end()); std::cout << result1 << std::endl; //輸出false 是一個元素對應一個元素的比，includes是集合和子集包含關系 auto result2 = equal(vec1.begin() + 1, vec1.begin() + 3, vec2.begin(), vec2.end()); std::cout << result2 << std::endl; //輸出true getchar(); return 0; } }
includes :判斷 [first1, last1) 的一個元素是否被包含在另外一個序列中.使用底層元素的 <= 操作符,重載版本使用用戶輸入的函數.
參數:first1
:last1
:first2
:last2
返回:bool
template <class inputItr1, class inputItr2>
bool includes(inputItr1 first1, inputItr1 last1, inputItr2 first2, inputItr2 last2);
參數:first1
:last1
:first2
:last2
:op
返回:bool
template <class inputItr1, class inputItr2, class binaryPredicate>
bool includes(inputItr1 first1, inputItr1 last1, inputItr2 first2, inputItr2 last2, binaryPredicate op);
#include "stdafx.h" #include <random> #include <ctime> #include <string> #include <iostream> #include <iterator> #include <vector> #include <algorithm> #include <numeric> #include <functional> int main() { { std::vector<int> vec1 = { 1, 3, 5, 7, 9 }; std::vector<int> vec2 = { 3, 7 }; bool result1 = includes(vec1.begin(), vec1.end(), vec2.begin(), vec2.end()); if (result1) { std::cout << "includes" << std::endl; } else { std::cout << "not includes" << std::endl; } getchar(); return 0; } }
lexicographical_compare :比較兩個序列.重載版本使用了用戶自定義的比較操作.
如果[first1, last1)按字典序列小於[first2, last2)，返回true，否則返回false,使用opeartor<或者是comp進行比較,可以使用opeartor<進行比較的對象都可以使用該函數
首先逐一比較集合中的元素，那個元素大，則那個集合大，集合中元素相同(個數，內容)，則比較集合長度，那個長度大則那個集合大
template <class InputIterator1, class InputIterator2>
bool lexicographical_compare (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
template <class InputIterator1, class InputIterator2, class Compare>
bool lexicographical_compare (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp);
#include "stdafx.h" #include <stdio.h> #include <ctime> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> #include <numeric> int main() { { std::vector<int> vec1 = { 4, 7, 13, 21, 26 }; std::vector<int> vec2 = { 4, 7, 13 }; bool result1 = lexicographical_compare(vec1.begin(), vec1.end(), vec2.begin(), vec2.end()); if (result1) { std::cout << "vec1 < vec2" << std::endl; } else { std::cout << "vec1 > vec2" << std::endl; } std::vector<int> vec3 = { 4, 7, 13, 21, 26 }; std::vector<int> vec4 = { 4, 7, 16 }; bool result2 = lexicographical_compare(vec3.begin(), vec3.end(), vec4.begin(), vec4.end()); if (result2) { std::cout << "vec3 < vec4" << std::endl; } else { std::cout << "vec3 > vec4" << std::endl; } std::vector<int> vec5 = { 4, 7, 13, 21, 26 }; std::vector<int> vec6 = { 4, 7, 13, 21, 26, 33 }; bool result3 = lexicographical_compare(vec5.begin(), vec5.end(), vec6.begin(), vec6.end()); if (result3) { std::cout << "vec5 < vec6" << std::endl; } else { std::cout << "vec5 > vec6" << std::endl; } getchar(); return 0; } }
<八>條件判斷算法(3個)
all_of:在指定范圍中判斷容器中是否所有元素滿足條件
template <class InputIterator, class UnaryPredicate>
bool any_of (InputIterator first, InputIterator last, UnaryPredicate pred);
any_of:在指定范圍中判斷容器中是否有元素滿足條件
template <class InputIterator, class UnaryPredicate>
bool any_of (InputIterator first, InputIterator last, UnaryPredicate pred);
none_of:在指定范圍中判斷容器中是否沒有任何元素滿足條件
template <class InputIterator, class UnaryPredicate>
bool any_of (InputIterator first, InputIterator last, UnaryPredicate pred);
#include "stdafx.h" #include <random> #include <ctime> #include <string> #include <iostream> #include <iterator> #include <vector> #include <algorithm> #include <numeric> #include <functional> int main() { { std::vector<int> vec1 = { 22, 11, 5, 33, 43 }; bool all1 = all_of(vec1.begin(), vec1.end(), [](int x)->bool { return x % 2 == 0 ? true : false; }); std::cout << "ele is all " << all1 << std::endl; //輸出:0 bool all2 = any_of(vec1.begin(), vec1.end(), [](int x)->bool { return x % 2 == 0 ? true : false; }); std::cout << "ele is any " << all2 << std::endl; //輸出:1 bool all3 = none_of(vec1.begin(), vec1.end(), [](int x)->bool { return x % 2 == 0 ? true : false; }); std::cout << "ele is none " << all3 << std::endl; //輸出:0 getchar(); return 0; } }
<九>集合算法(4個)
以下是STL algorithm的幾個函數，使用的條件是有序容器，所以 vector在被sort了之后是可以使用的，set也是可以使用的。
set_difference 這個是求得在第一個容器中有，第二個容器中沒有的。set_intersection 求兩個容器的交集， set_union 求兩個容器的並集，set_symmetric_difference 求兩個容器的差集。
set_difference :構造一個排過序的序列,其中的元素出現在第一個序列中,但是不包含在第二個序列中.重載版本使用自定義的比較操作.
set_intersection :構造一個排過序的序列,其中的元素在兩個序列中都存在.重載版本使用自定義的比較操作.
set_symmetric_difference :構造一個排過序的序列,其中的元素在第一個序列中出現,但是不出現在第二個序列中.重載版本使用自定義的比較操作.
set_union :構造一個排過序的序列,它包含兩個序列中的所有的不重復元素.重載版本使用自定義的比較操作.
#include "stdafx.h" #include <stdio.h> #include <ctime> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> #include <numeric> int main() { { std::vector<int> vec1 = { 4, 7, 11, 13, 21, 26 }; std::vector<int> vec2 = { 4, 11, 15, 19, 20, 21 }; std::vector<int> vec3(vec1.size() + vec2.size()); auto result1 = set_symmetric_difference(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), vec3.begin()); for_each(vec3.begin(), vec3.end(), [](int x)->void { std::cout << x << " "; }); //7 13 15 19 20 26 0 0 0 0 0 0 std::cout << std::endl; std::vector<int> vec33(vec1.size() + vec2.size()); auto result3 = set_difference(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), vec33.begin()); for_each(vec33.begin(), vec33.end(), [](int x)->void { std::cout << x << " "; });//7 13 26 0 0 0 0 0 0 0 0 0 std::cout << std::endl; std::vector<int> vec4(vec1.size() + vec2.size()); auto result4 = set_union(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), vec4.begin()); for_each(vec4.begin(), vec4.end(), [](int x)->void { std::cout << x << " "; }); //4 7 11 13 15 19 20 21 26 0 0 0 std::cout << std::endl; std::vector<int> vec5(vec1.size() + vec2.size()); auto result5 = set_intersection(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), vec5.begin()); for_each(vec5.begin(), vec5.end(), [](int x)->void { std::cout << x << " "; }); //4 11 21 0 0 0 0 0 0 0 0 0 getchar(); return 0; } }
<十>堆算法(4個)
下面介紹STL中與堆相關的4個函數,建立堆make_heap()，在堆中添加數據push_heap()，在堆中刪除數據pop_heap()和堆排序sort_heap()
make_heap :把范圍內的元素生成一個堆.重載版本使用自定義的比較操作.
pop_heap :並不是真正的把最大元素從堆中彈出,而是重新排序堆.它把 first 和 last-1 交換,然后重新做成一個堆.可以使用容器的 back 來訪問被“彈出“的元素或者使用 pop_back 來真正的刪除.重載版本使用自定義的比較操作.
push_heap :假設 first 到 last-1 是一個有效的堆,要被加入堆的元素在位置 last-1 ,重新生成堆.在指向該函數前,必須先把元素插入容器后.重載版本使用指定的比較.
sort_heap :對范圍內的序列重新排序,它假設該序列是個有序的堆.重載版本使用自定義的比較操作.
#include "stdafx.h" #include <stdio.h> #include <ctime> #include <iostream> #include <algorithm> #include <vector> #include <functional> #include <iterator> #include <ostream> #include <numeric> int main() { { int ia[9] = { 0,1,2,3,4,8,9,3,5 }; std::vector<int> ivec(ia, ia + 9); //底層我們使用vector來實現，可以動態添加元素。 make_heap(ivec.begin(), ivec.end()); for (int i = 0; i != ivec.size(); i++)std::cout << ivec[i] << " "; std::cout << std::endl; ivec.push_back(7); push_heap(ivec.begin(), ivec.end());//這里可以用make_heap替換。 for (int i = 0; i != ivec.size(); i++)std::cout << ivec[i] << " "; std::cout << std::endl; pop_heap(ivec.begin(), ivec.end()); std::cout << ivec.back() << std::endl; ivec.pop_back(); for (int i = 0; i != ivec.size(); i++)std::cout << ivec[i] << " "; std::cout << std::endl; sort_heap(ivec.begin(), ivec.end()); for (int i = 0; i != ivec.size(); i++)std::cout << ivec[i] << " "; std::cout << std::endl; getchar(); return 0; } }