什么是STL :

容器（Container）：
是一種數(shù)據(jù)結(jié)構(gòu)，如list，vector，和deques ，以模板類的方法提供。為了訪問容器中的數(shù)據(jù)，可以使用由容器類輸出的迭代器；
迭代器（Iterator）：
提供了訪問容器中對(duì)象的方法。例如，可以使用一對(duì)迭代器指定list或vector中的一定范圍的對(duì)象。迭代器就如同一個(gè)指針。事實(shí)上，C++的指針也是一種迭代器。但是，迭代器也可以是那些定了operator*()以及其他類似于指針的操作符地方法的類對(duì)象；
算法（Algorithm）：
是用來操作容器中的數(shù)據(jù)的模板函數(shù)。例如，STL用sort()來對(duì)一個(gè)vector中的數(shù)據(jù)進(jìn)行排序，用find()來搜索一個(gè)list中的對(duì)象，函數(shù)本身與他們操作的數(shù)據(jù)的結(jié)構(gòu)和類型無關(guān)，因此他們可以在從簡(jiǎn)單數(shù)組到高度復(fù)雜容器的任何數(shù)據(jù)結(jié)構(gòu)上使用；
仿函數(shù)（Functor）
適配器（Adaptor）
分配器（allocator）
仿函數(shù)、適配器、與分配器用的比較少，甚至沒用過！在這里不做說明，有興趣可以自己學(xué)習(xí)一下，那個(gè)東西C++軟件工程可能用的比較多。

一、迭代器（Iterator）

背景：指針可以用來遍歷存儲(chǔ)空間連續(xù)的數(shù)據(jù)結(jié)構(gòu)，但是對(duì)于存儲(chǔ)空間費(fèi)連續(xù)的，就需要尋找一個(gè)行為類似指針的類，來對(duì)非數(shù)組的數(shù)據(jù)結(jié)構(gòu)進(jìn)行遍歷。
定義：迭代器是一種檢查容器內(nèi)元素并遍歷元素的數(shù)據(jù)類型。
迭代器提供對(duì)一個(gè)容器中的對(duì)象的訪問方法，并且定義了容器中對(duì)象的范圍。
迭代器（Iterator）是指針（pointer）的泛化，它允許程序員用相同的方式處理不同的數(shù)據(jù)結(jié)構(gòu)（容器）。
（1）迭代器類似于C語言里面的指針類型，它提供了對(duì)對(duì)象的間接訪問。
（2）指針是C語言中的知識(shí)點(diǎn)，迭代器是C++中的知識(shí)點(diǎn)。指針較靈活，迭代器功能較豐富。
（3）迭代器提供一個(gè)對(duì)容器對(duì)象或者string對(duì)象的訪問方法，并定義了容器范圍。

迭代器和指針的區(qū)別：
容器和string有迭代器類型同時(shí)擁有返回迭代器的成員。如：容器有成員begin和end,其中begin成員復(fù)制返回指向第一個(gè)元素的迭代器，而end成員返回指向容器尾元素的下一個(gè)位置的迭代器，也就是說end指示的是第一個(gè)不合法地址，所以end返回的是尾后迭代器。

容器迭代器的使用
每種容器類型都定義了自己的迭代器類型，如vector：vector< int>:: iterator iter;//定義一個(gè)名為iter的變量，數(shù)據(jù)類型是由vector< int>定義的iterator 類型。簡(jiǎn)單說就是容器類定義了自己的iterator類型，用于訪問容器內(nèi)的元素。每個(gè)容器定義了一種名為iterator的類型，這種類型支持迭代器的各種行為。
我么們先講一下各種迭代器的類型，在講容器所用的迭代器類型，就可以明白怎么操作。

常見迭代器類型如下:

所有迭代器操作

p++	后置自增迭代器
++p	前置自增迭代器
輸入迭代器	操作介紹
*p	復(fù)引用迭代器，作為右值
p=p1	將一個(gè)迭代器賦給另一個(gè)迭代器（迭代器指向地址值）
p==p1	比較迭代器的相等性（比較地址）
p!=p1	比較迭代器的不等性
輸出迭代器	操作
*p	復(fù)引用迭代器，作為左值
p=p1	將一個(gè)迭代器賦給另一個(gè)迭代器
正向迭代器	提供輸入輸出迭代器的所有功能
雙向迭代器	操作
–p	前置自減迭代器
p–	后置自減迭代器
隨機(jī)迭代器
p+=i	將迭代器遞增i位
p-=i	將迭代器遞減i位
p+i	在p位加i位后的迭代器
p-i	在p位減i位后的迭代器
p[i]	返回p位元素偏離i位的元素引用
p<p1	如果迭代器p的位置在p1前，返回true，否則返回false
p<=p1	p的位置在p1的前面或同一位置時(shí)返回true，否則返回false
p>p1	如果迭代器p的位置在p1后，返回true，否則返回false
p>=p1	p的位置在p1的后面或同一位置時(shí)返回true，否則返回false

只有順序容器和關(guān)聯(lián)容器支持迭代器遍歷，各容器支持的迭代器的類別如下：

容器支持的迭代器類別說明

vector	隨機(jī)訪問	一種隨機(jī)訪問的數(shù)組類型，提供了對(duì)數(shù)組元素進(jìn)行快速隨機(jī)訪問以及在序列尾部進(jìn)行快速的插入和刪除操作的功能。可以再需要的時(shí)候修改其自身的大小
deque	隨機(jī)訪問	一種隨機(jī)訪問的數(shù)組類型，提供了序列兩端快速進(jìn)行插入和刪除操作的功能?？梢栽傩枰臅r(shí)候修改其自身的大小
list	雙向	一種不支持隨機(jī)訪問的數(shù)組類型，插入和刪除所花費(fèi)的時(shí)間是固定的，與位置無關(guān)。
set	雙向	一種隨機(jī)存取的容器，其關(guān)鍵字和數(shù)據(jù)元素是同一個(gè)值。所有元素都必須具有惟一值。
multiset	雙向	一種隨機(jī)存取的容器，其關(guān)鍵字和數(shù)據(jù)元素是同一個(gè)值?？梢园貜?fù)的元素。
map	雙向	一種包含成對(duì)數(shù)值的容器，一個(gè)值是實(shí)際數(shù)據(jù)值，另一個(gè)是用來尋找數(shù)據(jù)的關(guān)鍵字。一個(gè)特定的關(guān)鍵字只能與一個(gè)元素關(guān)聯(lián)。
multimap	雙向	一種包含成對(duì)數(shù)值的容器，一個(gè)值是實(shí)際數(shù)據(jù)值，另一個(gè)是用來尋找數(shù)據(jù)的關(guān)鍵字。一個(gè)關(guān)鍵字可以與多個(gè)數(shù)據(jù)元素關(guān)聯(lián)。
stack	不支持	適配器容器類型，用vector，deque或list對(duì)象創(chuàng)建了一個(gè)先進(jìn)后出容器
queue	不支持	適配器容器類型，用deque或list對(duì)象創(chuàng)建了一個(gè)先進(jìn)先出容器
priority_queue	不支持	適配器容器類型，用vector或deque對(duì)象創(chuàng)建了一個(gè)排序隊(duì)列

二、容器

所有容器都支持自定義數(shù)據(jù)類型，就是結(jié)構(gòu)體。

vector

使用此容器需在程序前加上頭文件#include< vector >。
vector可理解為變長數(shù)組，基于倍增思想。當(dāng)以已申請(qǐng)vector長度為m時(shí)，若實(shí)際長度n=m,則申請(qǐng)長度為2m的數(shù)組，將內(nèi)容轉(zhuǎn)移至新地址上，并釋放舊空間；刪除元素時(shí)，若n<=m/4,則釋放一半空間。
vector容器能像數(shù)組一樣隨機(jī)訪問第i個(gè)數(shù)a[i]，但不支持隨機(jī)插入.

#include<vector> //頭文件 vector<int> a; 定義了一個(gè)int類型的vector容器a vector<int> b[100];定義了一個(gè)int類型的vector容器b組 struct rec{···}; vector<rec> c; /定義了一個(gè)rec類型的vector容器c vector<int>::iterator it; //vector的迭代器，與指針類似

具體操作如下：

a.size() //返回實(shí)際長度（元素個(gè)數(shù)），O(1)復(fù)雜度a.empty() //容器為空返回1，否則返回0，O(1)復(fù)雜度a.clear() //把vector清空a.begin() //返回指向第一個(gè)元素的迭代器，*a.begin()與a[0]作用相同a.end() //越界訪問，指向vector尾部，指向第n個(gè)元素再往后的邊界a.front() //返回第一個(gè)元素的值，等價(jià)于*a.begin和a[0]a.back() //返回最后一個(gè)元素的值，等價(jià)于*--a.end()和a[size()-1]a.push_back(x) //把元素x插入vector尾部a.pop_back() //刪除vector中最后一個(gè)元素

迭代器使用與指針類似,可如下遍歷整個(gè)容器

for ( vector<int>::iterator it=a.begin() ; it!=a.end() ; it++ )

queue

循環(huán)隊(duì)列queue需使用頭文件< queue >

queue<int> q; //定義了一個(gè)int類型的隊(duì)列容器q struct rec{···};queue<rec> q; //定義了一個(gè)rec類型的隊(duì)列容器q q.push(x); //從隊(duì)尾使元素x入隊(duì)，O(1) q.pop(x); //使隊(duì)首元素出隊(duì)，O(1) int x=q.front(); //詢問隊(duì)首元素的值，O(1) int y=q.back(); //詢問隊(duì)尾元素的值，O(1)

priority_queue

優(yōu)先隊(duì)列priority_queue可理解為一個(gè)大根二叉堆，必須定義“小于號(hào)”，而int，string本身就能比較。同樣需要頭文件< queue >。
其定義方式與queue相似。

priority_queue<int> q; 由大到小 priority_queue<pair<int,int>> q; //pair是一個(gè)數(shù)對(duì)，由first和scond兩個(gè)元素構(gòu)成，按照第一個(gè)排序 priority_queue<int, vector<int>, greater<int> >qi2; //由小到大，小根堆，vector<int>是適配器，不用知道很詳細(xì)，記住就行 struct rec //舉個(gè)栗子 {int a,b,c;bool operator<(const rec&w){if(a==w.a) return b==w.b?c<w.c:b<w.b;return a<w.a;} }; priority_queue<rec> q; 如果不寫重載函數(shù)，會(huì)出錯(cuò)，他不知道怎么排序 q.push(x); //插入 O(log n) q.pop(); //刪除堆頂元素 O(log n) q.top(); //查詢堆頂元素 O(1)

可通過插入元素的相反數(shù)取出時(shí)再取反，或重載“小于號(hào)”的方式實(shí)現(xiàn)小根堆，通過懶惰刪除法實(shí)現(xiàn)隨機(jī)刪除操作。

deque

雙端隊(duì)列，是一個(gè)支持在兩端高效插入或刪除元素的連續(xù)線性存儲(chǔ)空間，可像數(shù)組一樣隨機(jī)訪問，使用前加頭文件< deque >。

q.begin()/q.end() //頭/尾迭代器，與vector類似 q.front()/q.back() //頭/尾元素，與queue類似 q.push_back(x)/q.push_front(x) //從隊(duì)尾/隊(duì)頭入隊(duì) q.pop_back(x)/q.pop_front(x) //從隊(duì)尾/隊(duì)頭出隊(duì) q.clear() //清空隊(duì)列

定義方式

deque<類型> 名稱

ps:clear復(fù)雜度為O(n),其余為O(1)。

set/multiset

兩容器相似，但set為有序集合，元素不能重復(fù)，multiset為有序多重集合，可包含若干相等的元素，內(nèi)部通過紅黑樹實(shí)現(xiàn)，支持的函數(shù)基本相同，同樣必須定義“小于號(hào)”運(yùn)算符，頭文件為< set >。
其迭代器不支持隨機(jī)訪問，支持星號(hào)(*)結(jié)束引用，僅支持 ++ 、-- 兩個(gè)與算術(shù)有關(guān)的操作。迭代器it++,則指向從小到大排序的結(jié)果中排在it下一名的元素，兩操作時(shí)間復(fù)雜度均為O(log n)。

q.size() //返回容器內(nèi)元素個(gè)數(shù) q.empty() //判斷容器是否為空 q.clear() //清空容器 q.begin()/q.end() //作用與上文幾種容器類似 q.insert(x) //將元素x插入集合中，O(log n) q.find(x) //查找等于x的元素，返回其迭代器，無則返回q.end()，O(log n) q.lower_bound(x) //查找>=x的元素中最小的一個(gè)，返回指向該元素的迭代器 q.upper_bound(x) //查找>x的元素中最小的一個(gè)，返回指向該元素的迭代器 q.erase(it) //刪除迭代器it指向的元素，O(log n) q.erase(x) //刪除所有等于x的元素，復(fù)雜度為O(k+log n),k為被刪除的元素個(gè)數(shù) q.count(x) //返回等于x的元素個(gè)數(shù)，O(k+log n)，k為元素x的個(gè)數(shù)

定義方式

set<int> demo 定義一個(gè)類型為int的set容器 struct rec {int a,b,c;bool operator<(const rec&w){if(a==w.a) return b==w.b?c<w.c:b<w.b;return a<w.a;} };set<rec> ob; 一樣所有排序的容器不重載就出錯(cuò)

map/multimap

map/multimap映射容器的元素?cái)?shù)據(jù)是由一個(gè)Key和一個(gè)Value成的，key與映照value之間具有一一映照的關(guān)系。

map/multimap容器的數(shù)據(jù)結(jié)構(gòu)也采用紅黑樹來實(shí)現(xiàn)的，map插入元素的鍵值不允許重復(fù)，類似multiset，multimap的key可以重復(fù)。比較函數(shù)只對(duì)元素的key進(jìn)行比較，元素的各項(xiàng)數(shù)據(jù)只能通過key檢索出來。雖然map與set采用的都是紅黑樹的結(jié)構(gòu)，但跟set的區(qū)別主要是set的一個(gè)鍵值和一個(gè)映射數(shù)據(jù)相等，Key=Value。

map<first,second> a; //map，會(huì)按照first（鍵值）排序（查找也是）；

map/multimap用法
頭文件

#include< map >

map成員函數(shù)

begin() //返回指向 map 頭部的迭代器 clear(） // 刪除所有元素 count() //返回指定元素出現(xiàn)的次數(shù) empty() // 如果 map 為空則返回 true end() //返回指向 map 末尾的迭代器 erase() // 刪除一個(gè)元素 find() // 查找一個(gè)元素 insert() //插入元素 key_comp() //返回比較元素 key 的函數(shù) lower_bound() //返回鍵值>=給定元素的第一個(gè)位置 max_size() //返回可以容納的最大元素個(gè)數(shù) rbegin() //返回一個(gè)指向 map 尾部的逆向迭代器 rend() //返回一個(gè)指向 map 頭部的逆向迭代器 size() //返回 map 中元素的個(gè)數(shù) swap() //交換兩個(gè) map

創(chuàng)建map對(duì)象

#include<iostream> #include<map> using namespace std; map<int,char>mp;//定義map容器

創(chuàng)建結(jié)構(gòu)體map對(duì)象

struct student{ int birth; string name; }; int id; typedef map<int,student> Student;// 這里相當(dāng)于給map<int,student> 起了個(gè)別名Student，后續(xù)代碼均可以用student代替map<int,student> 使用。

插入結(jié)構(gòu)體對(duì)象
接上文代碼

Stduent a； cin>>id>>student.birth>>student.name; a.insert(make_pair(id,student）);

棧（stack)

1.定義：
棧是一種只能在某一端插入和刪除數(shù)據(jù)的特殊線性表。他按照先進(jìn)先出的原則存儲(chǔ)數(shù)據(jù)，先進(jìn)的數(shù)據(jù)被壓入棧底，最后進(jìn)入的數(shù)據(jù)在棧頂，需要讀數(shù)據(jù)的時(shí)候從棧頂開始彈出數(shù)據(jù)(最后被壓入棧的，最先彈出）。因此棧也稱先進(jìn)后出表。
允許進(jìn)行插入刪除操作的一端稱為棧頂，另一端稱為棧底。棧底固定，棧頂浮動(dòng)。插入元素稱為進(jìn)棧，刪除一個(gè)元素稱為進(jìn)棧，棧內(nèi)元素為零稱為空棧。
2.stack成員函數(shù)

bool empty ( ) ————>棧為空返回true，否則返回false；void pop （ ) ————>刪除棧頂元素，出棧；void push（const TYPE&value）————> 插入新元素value，放置在棧頂進(jìn)棧；TYPE：類型int，char…；size_type size ( ) ————> 返回堆棧中元素個(gè)數(shù)；（注意注意！！！！切不可賦值給int ，很容易超過int的范圍TYPE&top（）————> 查看當(dāng)前棧頂元素；

List

定義：List類表示可通過索引訪問的對(duì)象的強(qiáng)類型列表，提供用于對(duì)列表進(jìn)行搜索、排序和操作的方法。
作用：
泛型最常見的用途是泛型集合
我們?cè)趧?chuàng)建列表類時(shí)，列表項(xiàng)的數(shù)據(jù)類型可能是int,string或其它類型，如果對(duì)列表類的處理方法相同，
就沒有必要事先指定數(shù)據(jù)類型，留待列表類實(shí)例化時(shí)再指定。相當(dāng)于把數(shù)據(jù)類型當(dāng)成參數(shù)，這樣可以最
大限度地重用代碼，保護(hù)類型的安全以及提高性能。
定義 list<類型> 名稱
成員函數(shù)

l.begin() 將迭代器返回到開頭(Return iterator to beginning)l.end() 將迭代器返回到最后(Return iterator to end)l.rbegin() Return reverse iterator to reverse beginningl.rend() Return reverse iterator to reverse endl.l.empty() 檢查容器是否為空l.size() 返回當(dāng)前容器內(nèi)元素個(gè)數(shù)l.max_size() 返回當(dāng)前容器能容納的最大元素?cái)?shù)量l.front() 訪問第一個(gè)元素l.back() 訪問最后一個(gè)元素l.push_front() 將元素插入到開頭l.pop_front() 刪除第一個(gè)元素l.push_back() 將元素插入到最后l.pop_back() 刪除最后一個(gè)元素l.insert() 插入元素l.erase() 刪除元素l.swap() 交換兩個(gè) list 內(nèi)容l.resize ()改變?nèi)萜鞔笮.clear() 刪除容器所有內(nèi)容

bitset

bitset可看作一個(gè)多位二進(jìn)制數(shù)，每8位占用1個(gè)字節(jié)，相當(dāng)于采用了狀態(tài)壓縮的二進(jìn)制數(shù)組，并支持基本的位運(yùn)算。一般以32位整數(shù)的運(yùn)算次數(shù)為基準(zhǔn)估算運(yùn)行時(shí)間，n位bitset執(zhí)行一次的位運(yùn)算復(fù)雜度可視為n/32，效率較高。頭文件< bitset >。
同樣具有~,&,|,^,<<,>>操作符，==，!=可比較二進(jìn)制數(shù)是否相等

bitset<10000> q; //聲明一個(gè)10000位的二進(jìn)制數(shù) q[k] //表示q的第k位，可取值，賦值，最低位為q[0] q.count() //返回有多少位1 q.none() //所有位都為0則返回true,至少1位為1則返回false q.any() //所有位都為0則返回false,至少1位為1則返回true,與函數(shù)none相反 q.set() //把所有位變?yōu)? q.set(k,v) //把第k位變?yōu)関，即q[k]=v q.reset() //把所有位變?yōu)? q.reset(k) //把第k位變?yōu)?，即q[k]=0 q.flip() //把所有位取反，即s=~s q.flip(k) //把第k位取反，即q[k]^=1

三、算法

查找算法(9個(gè))：判斷容器中是否包含某個(gè)值

（可以去看看C++primer學(xué)學(xué)別的，但是我認(rèn)為太多了沒必要）
1.count:
利用等于操作符，把標(biāo)志范圍內(nèi)的元素與輸入值比較，返回相等元素個(gè)數(shù)。

#include<iostream> #include<algorithm> using namespace std; int main() {int a[14]={0,1,2,3,4,5,6,7,7,7,7,7,7,8};cout<<count(a,a+14,7)<<endl;vector<int> demo;for(int i=0;i<10;i++)demo.push_back(i);demo.push_back(1);cout<<count(demo.begin(),demo.end(),1)<<endl; } //運(yùn)行結(jié)果 6 2；

2.count_if:
利用輸入的操作符，對(duì)標(biāo)志范圍內(nèi)的元素進(jìn)行操作，返回結(jié)果為true的個(gè)數(shù)。

#include<iostream> #include<algorithm> using namespace std; bool cmp(int a) {return (a>1); } int main() {int a[14]={0,1,2,3,4,5,6,7,7,7,7,7,7,8};int po=count_if(a,a+14,cmp);cout<<po<<endl;vector<int> demo;for(int i=0;i<10;i++)demo.push_back(i);demo.push_back(1);int poi=count_if(demo.begin(),demo.end(),cmp);cout<<poi<<endl; }// 運(yùn)行結(jié)果 8 12 //看到網(wǎng)上大佬的代碼寫的比較深?yuàn)W，特地去查了查書，我這樣用沒毛病的。

補(bǔ)充：捕獲值列表，是允許我們?cè)贚ambda表達(dá)式的函數(shù)體中直接使用這些值，捕獲值列表能捕獲的值是所有在此作用域可以訪問的值，包括這個(gè)作用域里面的臨時(shí)變量，類的可訪問成員，全局變量。捕獲值的方式分兩種，一種是按值捕獲，一種是按引用捕獲。顧名思義，按值捕獲是不改變?cè)凶兞康闹?#xff0c;按引用捕獲是可以在Lambda表達(dá)式中改變?cè)凶兞康闹怠?/p>

[捕獲值列表]:

1、空。沒有使用任何函數(shù)對(duì)象參數(shù)。
2、=。函數(shù)體內(nèi)可以使用Lambda所在作用范圍內(nèi)所有可見的局部變量（包括Lambda所在類的this），并且是值傳遞方式（相當(dāng)于編譯器自動(dòng)為我們按值傳遞了所有局部變量）。
3、&。函數(shù)體內(nèi)可以使用Lambda所在作用范圍內(nèi)所有可見的局部變量（包括Lambda所在類的this），并且是引用傳遞方式（相當(dāng)于編譯器自動(dòng)為我們按引用傳遞了所有局部變量）。
4、this。函數(shù)體內(nèi)可以使用Lambda所在類中的成員變量。
5、a。將a按值進(jìn)行傳遞。按值進(jìn)行傳遞時(shí)，函數(shù)體內(nèi)不能修改傳遞進(jìn)來的a的拷貝，因?yàn)槟J(rèn)情況下函數(shù)是const的。要修改傳遞進(jìn)來的a的拷貝，可以添加mutable修飾符。
6、&a。將a按引用進(jìn)行傳遞。
7、a, &b。將a按值進(jìn)行傳遞，b按引用進(jìn)行傳遞。
8、=，&a,&b。除a和b按引用進(jìn)行傳遞外，其他參數(shù)都按值進(jìn)行傳遞。
9、&, a, b。除a和b按值進(jìn)行傳遞外，其他參數(shù)都按引用進(jìn)行傳遞。

3.equal_range:
功能類似equal，返回一對(duì)iterator，第一個(gè)表示lower_bound，第二個(gè)表示upper_bound。

#include<iostream>#include<algorithm>using namespace std;bool cmp(int a){return (a>1);}int main(){// int a[14]= {0,1,2,3,4,5,6,7,7,7,7,7,7,8};//equal_range(a,a+14,auto po);vector<int> demo;for(int i=0; i<10; i++) demo.push_back(i);demo.push_back(1);cout<<*equal_range(demo.begin(),demo.end(),7).first<<endl;cout<<*equal_range(demo.begin(),demo.end(),7).second<<endl;cout<<equal_range(demo.begin(),demo.end(),7).first-demo.begin()<<endl;cout<<equal_range(demo.begin(),demo.end(),7).second-equal_range(demo.begin(),demo.end(),7).first<<endl;}//也可以加cmp函數(shù)，同樣適用于數(shù)組，在下文中不再舉出數(shù)組的例子

4.find:
利用底層元素的等于操作符，對(duì)指定范圍內(nèi)的元素與輸入值進(jìn)行比較。當(dāng)匹配時(shí)，結(jié)束搜索，返回該元素的一個(gè)InputIterator。

補(bǔ)充
InputIterator是用于輸入的Iterator
OutputIterator是用于輸出的Iterator
ForwardIterator是InputIterator，同時(shí)可以保證++運(yùn)算不會(huì)使之失效
RandomIterator是ForwardIterator，同時(shí)具有+，-，+=，-=等運(yùn)算及各種比較操作

#include<iostream> #include<algorithm> using namespace std; int main() {int a[14]= {0,1,2,3,4,5,6,7,7,7,7,7,7,8};vector<int> demo;for(int i=0; i<14; i++) demo.push_back(a[i]);demo.push_back(1);cout<<find(demo.begin(),demo.end(),8)-demo.begin()<<endl; } //可以直接取地址獲取值。

5.find_end:
在指定范圍內(nèi)查找"由輸入的另外一對(duì)iterator標(biāo)志的第二個(gè)序列"的最后一次出現(xiàn)。找到則返回最后一對(duì)的第一個(gè)ForwardIterator，否則返回輸入的"另外一對(duì)"的第一個(gè)ForwardIterator。重載版本使用用戶輸入的操作符代替等于操作。

#include<iostream> #include<algorithm> using namespace std; int main() {int a[14]= {0,1,2,3,4,5,6,7,7,7,7,7,7,8};vector<int> demo;for(int i=0; i<14; i++) demo.push_back(a[i]);demo.push_back(1);cout<<find_end(demo.begin(),demo.end(),a+2,a+3)-demo.begin()<<endl; }

6.find_first_of:
在指定范圍內(nèi)查找"由輸入的另外一對(duì)iterator標(biāo)志的第二個(gè)序列"中任意一個(gè)元素的第一次出現(xiàn)。重載版本中使用了用戶自定義操作符。

#include<iostream> #include<algorithm> using namespace std; int main() {int a[14]= {0,1,2,3,4,5,6,7,7,7,7,7,7,8};vector<int> demo;for(int i=0; i<14; i++) demo.push_back(a[i]);demo.push_back(1);cout<<find_first_of(demo.begin(),demo.end(),a+2,a+3)-demo.begin()<<endl; }

7.find_if:
使用輸入的函數(shù)代替等于操作符執(zhí)行find。返回的是迭代器，為了是大家更明白的理解，減去第一個(gè)元素的位置，就相當(dāng)于得到了下標(biāo)；

#include<iostream> #include<algorithm> using namespace std; bool cmp(int w) {return w>5; } int main() {int a[14]= {0,1,2,3,4,5,6,7,7,7,7,7,7,8};vector<int> demo;for(int i=0; i<14; i++) demo.push_back(a[i]);cout<< find_if(demo.begin(),demo.end(),cmp)-demo.begin(); }

8.lower_bound:
返回一個(gè)ForwardIterator，指向在有序序列范圍內(nèi)的可以插入指定值而不破壞容器順序的第一個(gè)位置。重載函 數(shù)使用自定義比較操作。
在一個(gè)有序的范圍內(nèi)時(shí)間復(fù)雜度為log2n，普遍適用于二分算法。
跟3.equal_range的用法一樣不過這個(gè)返回的是first
9.upper_bound:
返回一個(gè)ForwardIterator，指向在有序序列范圍內(nèi)插入value而不破壞容器順序的最后一個(gè)位置，該位置標(biāo)志 一個(gè)大于value的值。重載函數(shù)使用自定義比較操作。跟3.equal_range的用法一樣不過這個(gè)返回的是second；

排序和通用算法(7個(gè))：提供元素排序策略

inplace_merge:

合并兩個(gè)有序序列，結(jié)果序列覆蓋兩端范圍。重載版本使用輸入的操作進(jìn)行排序。

merge:

合并兩個(gè)有序序列，存放到另一個(gè)序列。重載版本使用自定義的比較。 nth_element:
將范圍內(nèi)的序列重新排序，使所有小于第n個(gè)元素的元素都出現(xiàn)在它前面，而大于它的都出現(xiàn)在后面。重載版本使用自定義的比較操作。

partial_sort:

對(duì)序列做部分排序，被排序元素個(gè)數(shù)正好可以被放到范圍內(nèi)。重載版本使用自定義的比較操作。

partial_sort_copy:

與partial_sort類似，不過將經(jīng)過排序的序列復(fù)制到另一個(gè)容器。 partition:
對(duì)指定范圍內(nèi)元素重新排序，使用輸入的函數(shù)，把結(jié)果為true的元素放在結(jié)果為false的元素之前。 random_shuffle:
對(duì)指定范圍內(nèi)的元素隨機(jī)調(diào)整次序。重載版本輸入一個(gè)隨機(jī)數(shù)產(chǎn)生操作。 reverse:
將指定范圍內(nèi)元素重新反序排序。 reverse_copy: 與reverse類似，不過將結(jié)果寫入另一個(gè)容器。

rotate:

將指定范圍內(nèi)元素移到容器末尾，由middle指向的元素成為容器第一個(gè)元素。

rotate_copy:

與rotate類似，不過將結(jié)果寫入另一個(gè)容器。

sort:（常用，相信大家都不陌生）

以升序重新排列指定范圍內(nèi)的元素。重載版本使用自定義的比較操作。

sort（首地址，第一個(gè)不合法地址（即末地址+1），cmp）//cmp可以缺省bool cmp（）//可以用到結(jié)構(gòu)體上 {return (); }

stable_sort:

與sort類似，不過保留相等元素之間的順序關(guān)系。 stable_partition:
與partition類似，不過不保證保留容器中的相對(duì)順序。 <三>刪除和替換算法(15個(gè)) copy:
復(fù)制序列 copy_backward: 與copy相同，不過元素是以相反順序被拷貝。 iter_swap:
交換兩個(gè)ForwardIterator的值。

刪除修改復(fù)制(12個(gè))：簡(jiǎn)單操作區(qū)間元素

remove:

刪除指定范圍內(nèi)所有等于指定元素的元素。注意，該函數(shù)不是真正刪除函數(shù)。內(nèi)置函數(shù)不適合使用remove和 remove_if函數(shù)。

remove_copy:
將所有不匹配元素復(fù)制到一個(gè)制定容器，返回OutputIterator指向被拷貝的末元素的下一個(gè)位置。

remove_if:

刪除指定范圍內(nèi)輸入操作結(jié)果為true的所有元素。

remove_copy_if:

將所有不匹配元素拷貝到一個(gè)指定容器。

replace:

將指定范圍內(nèi)所有等于vold的元素都用vnew代替。

replace_copy:

與replace類似，不過將結(jié)果寫入另一個(gè)容器。

replace_if:

將指定范圍內(nèi)所有操作結(jié)果為true的元素用新值代替。

replace_copy_if:

與replace_if，不過將結(jié)果寫入另一個(gè)容器。

swap:

交換存儲(chǔ)在兩個(gè)對(duì)象中的值。

swap_range:

將指定范圍內(nèi)的元素與另一個(gè)序列元素值進(jìn)行交換。

unique: （常用于離散化）

清除序列中重復(fù)元素，和remove類似，它也不能真正刪除元素。重載版本使用自定義比較操作。

unique_copy: （同上）

與unique類似，不過把結(jié)果輸出到另一個(gè)容器。

排列組合算法(2個(gè))：提供計(jì)算給定集合按一定順序的所有可能排列組合

以深搜的形式實(shí)現(xiàn)：

next_permutation:

取出當(dāng)前范圍內(nèi)的排列，并重新排序?yàn)橄乱粋€(gè)排列。重載版本使用自定義的比較操作。

prev_permutation:

取出指定范圍內(nèi)的序列并將它重新排序?yàn)樯弦粋€(gè)序列。如果不存在上一個(gè)序列則返回false。重載版本使用 自定義的比較操作。

//常以此方式使用，但時(shí)間復(fù)雜度N！這個(gè)。。。。 do {//操作 }while（(next_permutation（首地址，第一個(gè)不合法地址）

生成和異變算法(3個(gè))

fill:
將輸入值賦給標(biāo)志范圍內(nèi)的所有元素。

fill(首地址，第一個(gè)不合法地址,2); //該區(qū)間內(nèi)全部賦值為2

區(qū)別于memset，memset是按位賦值，只能賦每位值相同值。

memset（首地址，value，(字節(jié)數(shù))常用sizeof()獲取）

fill_n:

將輸入值賦給first到first+n范圍內(nèi)的所有元素。

// 從開始以此賦值，3個(gè)5 fill_n(首地址,3,5);

transform:

將輸入的操作作用與指定范圍內(nèi)的每個(gè)元素，并產(chǎn)生一個(gè)新的序列。重載版本將操作作用在一對(duì)元素上，另外一個(gè)元素來自輸入的另外一個(gè)序列。結(jié)果輸出到指定容器。

transform (原始對(duì)象首地址, 原始對(duì)象第一個(gè)不合法地址, 輸出對(duì)象首地址, operate（操作函數(shù))）;char operate（char c）//常用轉(zhuǎn)化大小寫，以此為例子{if (isupper(c)){return c+32;}return c;}

關(guān)系算法(6個(gè))

equal:

如果兩個(gè)序列在標(biāo)志范圍內(nèi)元素都相等，返回true。重載版本使用輸入的操作符代替默認(rèn)的等于操作符。

includes:

判斷第一個(gè)指定范圍內(nèi)的所有元素是否都被第二個(gè)范圍包含，使用底層元素的<操作符，成功返回true。重載版本使用用戶輸入的函數(shù)。

max:（很多人問我，這不是cmath嗎，呃。。。。。不是）
返回兩個(gè)元素中較大一個(gè)。重載版本使用自定義比較操作。

max（3，5）的值是5；

max_element:

返回一個(gè)ForwardIterator，指出序列中最大的元素。重載版本使用自定義比較操作。

max_element(a, a+6) 返回一個(gè)最大值位置指針

min:

返回兩個(gè)元素中較小一個(gè)。重載版本使用自定義比較操作。

min（3，5）的值是5；

min_element:

返回一個(gè)ForwardIterator，指出序列中最小的元素。重載版本使用自定義比較操作。

集合算法(4個(gè))

set_union:
構(gòu)造一個(gè)有序序列，包含兩個(gè)序列中所有的不重復(fù)元素。重載版本使用自定義的比較操作。

set_intersection:
構(gòu)造一個(gè)有序序列，其中元素在兩個(gè)序列中都存在。重載版本使用自定義的比較操作。

set_difference:
構(gòu)造一個(gè)有序序列，該序列僅保留第一個(gè)序列中存在的而第二個(gè)中不存在的元素。重載版本使用自定義的比較操作。

set_symmetric_difference:

構(gòu)造一個(gè)有序序列，該序列取兩個(gè)序列的對(duì)稱差集(并集-交集)。

堆算法(4個(gè))

make_heap:

把指定范圍內(nèi)的元素生成一個(gè)堆。重載版本使用自定義比較操作。

pop_heap:

并不真正把最大元素從堆中彈出，而是重新排序堆。它把first和last-1交換，然后重新生成一個(gè)堆。可使用容器的back來訪問被"彈出"的元素或者使用pop_back進(jìn)行真正的刪除。重載版本使用自定義的比較操作。

push_heap:

假設(shè)first到last-1是一個(gè)有效堆，要被加入到堆的元素存放在位置last-1，重新生成堆。在指向該函數(shù)前，必須先把元素插入容器后。重載版本使用指定的比較操作。

sort_heap:

對(duì)指定范圍內(nèi)的序列重新排序，它假設(shè)該序列是個(gè)有序堆。重載版本使用自定義比較操作。

總結(jié)

以上是生活随笔為你收集整理的学了C++不会STL，简直少了左膀右臂的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。