C++ stl概括

這個只是我個人學習Stl過程中的一些隨手筆記，內容不是很全，以後會為大家更新一份詳細的STL講解，

有STL基礎的人請跳過這篇文章

Deque容器是一個動態數組 順序容器**

Deque可以在數組的開頭和末尾插入或者刪除數據

Dequea;

a.push_back()在容器尾部添加數據

a.push_front()在容器頭部添加數據

a.pop_front()刪除容器頭部數據

a.pop_back()刪除容器尾部數據

對vector的所有操作 在deque上也可以進行

**List 順序容器 是一個雙向鏈表 不能夠使用下標訪問裡面的數據 只能使用迭代器訪問數據**

List a ;

a.push_front();在容器前端增加數據

a.push_back();在容器的後端增加數據

std::list::iterator iter; 迭代器

a.insert(a.begin(),10); 在容器中間插入數據 需要傳入一個迭代器和 傳入的數值 迭代器指向你需要插入的位置 這個代表在容器的開頭插入一個10

a.insert(a.end(),4,20);這個代表在容器的尾部（a.end()迭代器是容器的尾部）插入4個20

list b

a.insert(iter, ++b.begin(), --b.end());這個代表在a容器的iter迭代器指向的位置 插入b容器 ++begin() 到 --end()位置的所有數據

a.insert()返回一個迭代器

a.erase(iter)用來刪除迭代器指向位置的數據

a.erase(a.begin(), a.end()) 刪除a.begn 到 a.end 位置的數據 a.end位置的數據不會被刪除

a.reverse()對a容器進行反轉

a.sort()對a容器進行排序

**stack （堆）棧 LIFO後進先出 自適應容器（容器適配器）**

stack> a 默認使用deque來做堆棧

stack> a

stack> a

a.empty()檢查堆棧是否為空

a.size()檢查堆棧裡面面有多少個數據

a.pop()從堆棧裡面彈出一個數據

a.top()查看棧頂的數據

a.push(item)把一個數據壓入堆棧裡面

**queue 隊列：FIFO先進先出 自適應容器（容器適配器）**

個人理解：因為隊列可以雙向操作 vector只支持單向操作 所以不能用vector

queue> a;

queue> a

a.empty()檢查隊列是否為空

a.size()檢查隊列裡面數據的個數

a.front()查看隊列的開頭數據

a.back()查看隊列的尾部數據

a.pop()刪除隊列的頭部數據

a.push(item)在隊列尾部添加數據

**priority_queue 自適應容器（容器適配器）**

不能使用list 因為list的迭代器不是任意存取iterator，而pop中用到堆排序時是要求randomaccess iterator 的

數據放在優先級隊列裡面 隊列根據優先級 將數據放在隊首

最大值優先級隊列：始終將最大值放在隊首

最小值優先級隊列：始終將最小值放在隊首

priority_queue> a

priority_queue> a 最大值優先隊列 默認方式是vector 默認是最大值放在前面

a.empty()檢查隊列是否為空

a.size()檢查隊列裡面數據的個數

a,top()查看隊列的開頭數據

a.pop()刪除隊列的頭部數據

a.push(item)在隊列尾部添加數據

priority_queue， greater>最小值優先隊列

順序容器的定義

順序容器：vector list deque，

容器適配器：stack，queue，priority_queue

vector<string> a/<string>

vector<string> b(a); 用a向量的參數 來初始化b向量的參數（這種初始化方式 要求a和b的類型必須一致）/<string>

list<string> c(a.begin(), a.end()); 可以使用迭代器來初始化兩個不同類型的數據/<string>

list<string> d(64，"hello") d容器裡面有64個hello字符串/<string>

順序容器的操作

迭代器和迭代器範圍

每一個容器都有自己的迭代器 但是每個迭代器的接口是一樣的

常用的迭代器操作

*iter ++iter --iter iter1==iter2 iter!=iter2

vector和deque容器的迭代器的額外操作

iter+n iter-n > >= < <=

迭代器範圍

begin/end first/last end是最後一個的下一個

某些對容器的操作 會使迭代器失效

順序容器的操作

容器定義的類型別名

begin和end成員

vector::size_type a1

vector::iterator a2 迭代器

vector::const_iterator a3 常迭代器

vector::reverse_iterator a4逆序迭代器

vector::const_reverse_iterator a5 常逆序迭代器

vector::difference_type a6用來保存容器中兩個迭代器之間的距離

《主要用在泛型程序設計時候使用》

vector::value_type a7

vector::reference a8 引用

vector::const_reference a9

順序容器的操作

在順序容器中添加數據

a.push_back(t)在容器的尾部添加數據

a.push_front(t)在容器的頭部添加數據（vector不可以進行這個操作）

c.insert(p,t)在p迭代器位置插入t元素

c.insert(p,n,t)在p迭代器位置插入n個t元素

c.insert(p,b,e)在p迭代器位置插入 另一個容器b迭代器到e迭代器的所有數據（不包括e迭代器所指向位置的元素）

容器元素都是副本 把原本數據拷貝一份

添加元素可能會使迭代器失效

避免存儲end操作返回的迭代器

順序容器的操作

關係運算符

所有容器類型都可以使用

比較的容器必須具有相同的容器類型

容器的比較是基於容器內元素的比較

容器內元素必須具有相應的關係運算符

兩個容器比較 假如兩個容器元素個數和元素都相等 則這兩個容器相等

順序容器的操作

容器大小的操作

a.size() 用來計算容器數據的個數 返回結果是size_type類型

a.max_size() 容器能夠容納數據的最大數量 返回結果是size_type類型

a.empty() 檢查容器是否為空

a.resize(n) 調整容器大小為n

a.resize(n, t) 調整容器大小為n 新增加的數據為t

resize操作可能會使迭代器失效

順序容器的操作

訪問元素

a.back()返回最後一個數據

a.front()返回第一個數據

a[n]

a.at[n]

注意：a[n]和a.at[n]只適合vector和deque容器

vector::reference a = a.back()/a.front(

順序容器的操作

刪除元素

c.erase(p) 刪除p迭代器所指向的數據

c.erase(b, e) 刪除b迭代器 到e 迭代器 所有數據

c.clean() 全部刪除

c.pop_back() 刪除最後一個

c.pop_front() 刪除最前面的一個

注意：c.pop_front()只適用list和deque

順序容器的操作

賦值與交換

c1 = c2 賦值

c1.swap(c2) 交換兩個容器的值

c.assign(b,e)

c.assgin(n,t)

使用assign：類型兼容就可以了

使用swap：類型必須相同

vector容器的自增長

vector是用數組做出來的

數組的優點和缺點

capacity和reserve成員

capacity 可以顯示容器的容量

reserve 可以設置容器容量

順序容器的選用

順序容器

vector的優點和缺點：

list優點和缺點

deque的優點和缺點

插入操作如何影響容器的選擇

元素的訪問如何影響容器的選擇

選擇容器的提示

構造string對象的方法

string s 定義一個s的空串

String s(s2) 用s2來定義s s2中的字符全部拷貝到s中 兩者沒有任何關係

string s("value") 定義一個字符串 用value 來初始化

string s(n, 'c') 用n個c來定義一個字符串

string s(b, e) 把迭代器b 到迭代器e之間的數值賦值給s

string s(cp, n) cp指針開始 後面的n個數 給字符串s

string s(s2, pos2) 從字符串s2的pos2位置開始賦值給s

string s(s2,pos2,len2) 從字符串s2的pos2位置開始 賦值len2個字符給s

修改string對象的方法

《-----------迭代器操作---------------》

s.insert(p, t)

s.insert(p, n, t)

s.insert(p, b, e)

s.assign(b, e)

s.assign(n, t)

s.erase(p)

s.erase(b, e)

《---------string方法---------------》

s.insert(pos, n, c)

s.insert(pos, s2)

s.insert(pos, s2, pos2, len)

s.insert(pos, cp, len)

s.insert(pos, cp)

s.assign(s2)

s.assign(s2,pos2,len)

s.assign(cp, len)

s.assign(cp)

s.erase(pos, len)

map（映射）、multimap（多映射）前者鍵不可以重複 後者可以

用來保存鍵值對數據

紅黑樹（數據結構）

基本操作

insert ：4種方法

count和find

erase：3種方法

注意不可以通過find進行修改

map a;

a.insert(map::value_type(1,"one")) 插入數據 1：one

a.insert(make_pair(-1,"minus one"));插入數據

a.insert(pair(1000,"one thousand")) 插入數據

a[1000000] = "one million" 插入數據

a.count(1000) 查找鍵為1000的個數

find(45) 查找鍵為45的元素 返回一個迭代器

erase(-1) 刪除鍵為-1的元素 成功返回的數大於0

erase(p) p是要刪除元素的迭代器位置 先用find查找要刪除數據位置的迭代器 ，最後刪除

a.erase(a.lower_bound(1000), a.upper_bound(1000)) 刪除所有鍵為1000的元素

set（集）、multiset（多集）前者不可以重複 後者可以

用來保存鍵值對數據

紅黑樹（數據結構）

基本操作

insert

count和find

erase

注意不可以通過find進行修改

函數對象：有自己的類型 比普通函數要快 有自己的狀態

STL算法------元素計數

count

count(b, e, t) 計算b迭代器 到 e迭代器之間t元素的個數

count_if

count_if(b, e, 函數或者函數對象) 計算b迭代器 到 e迭代器之間符合 函數或者函數對象 要求的元素的個數

關聯容器的等效成員函數

set.count

multiset.count

map.count

multimap.count

STL算法------最大值和最小值

min_element(b, e) 查找b迭代器到e迭代器之間元素的最小值 返回值是一個迭代器 需要對迭代器解引用才會出現值

min_element(b,e,op) 查找b迭代器到e迭代器之間元素滿足op函數條件的最小值 返回值是一個迭代器 需要對迭代器解引用才會出現值

max_element(b, e) 查找b迭代器到e迭代器之間元素的最大值 返回值是一個迭代器 需要對迭代器解引用才會出現值

max_element(b, e, op) 查找b迭代器到e迭代器之間元素滿足op函數條件的最大值 返回值是一個迭代器 需要對迭代器解引用才會出現值

STL算法------查找算法

find()

find(b, e , t) 在容器中查找b迭代器到e迭代器中t元素的位置 返回類型是迭代器 返回是找到的第一個t元素位置

find_if()

find_if(b, e, 謂詞) 在容器中查找b迭代器到e迭代器中查找符合謂詞要求元素的位置 返回類型是迭代器 返回是找到的第一個t元素位置

如果是已序區間，可以使用已序區間查找算法

binary_search() 二分查找

includes()

lower_bound()

upper_bound()

關聯式容器有等效的成員函數find()

string有等效的成員函數find()

string a("aaaaaaaaaaaaaaa")

string::size_type pos = s.find("a")

STL算法------查找算法

search_n() 用來查找連續的n個匹配的詞 例如：連續的8等等 返回一個迭代器

search_n(b, e, c, v) 在b迭代器到e迭代器中 查找連續c個v的元素位置

search_n(b, e, c, v, p) 在b迭代器到e迭代器中 查找符合謂詞p規定的連續c個的位置

STL算法------查找算法 視頻stl查找算法3

search() 結果返回迭代器 可以使用這個函數查找連續的偶數或者特定序列的數列

search(b1, e1, b2, e2)在b1迭代器到e1迭代器範圍裡面找b2迭代器到e2迭代器的數據

find_end()從容器尾部開始查找

STL算法------查找算法

find_first_of(b, e, sb, se) 在b迭代器到e迭代器範圍裡面查找sb迭代器到se迭代器裡面的任意一個數據

find_first_of(b, e, sb, se, bp) 在b迭代器到e迭代器範圍裡面查找符合謂詞的的任意一個數據

使用逆向迭代器

STL算法------查找算法

adjacent_find(b, e) 在b迭代器到e迭代器範圍裡面查找連續兩個相等的樹

adjacent_find(b, e, p) 在b迭代器到e迭代器範圍裡面查找連續兩個符合謂詞規則的樹

STL算法------查找算法

已序區間查找算法 查找的容器元素 和被查找的容器裡面的數據 都需要排序

binary_search() 二分查找 返回true 或者 false 不返回目標元素位置

binary_search(b, e, v) 在b迭代器到e迭代器範圍裡面查找v元素的位置

binary_search(b, e, v, p)

includes() 包含查找 查找範圍元素的位置 元素不一定連續 只要被查找容器裡面有這些元素就可以了

includes(b, e, sb, se)

includes(b, e, sb, se, bp)

STL算法------查找算法

已序區間查找算法

lower_bound(b, e, v) 查找第一個可能的位置 返回一個迭代器

upper_bound() 查找最後一個可能的位置

equal_range() 同時查找第一個 和最後一個可能的位置

關聯式容器有等效的成員函數，性能更佳

STL算法-for_each

for_each(b, e, p)

使用for_each()算法遍歷數據

使用for_each()和函數對象修改數據

使用for_each()的返回值

STL算法-區間的比較

equal(b, e, b2) 比較兩個容器區間的數據是否相等

equal(b, e ,b2, p) b迭代器到e迭代器之間的元素 和 b2迭代器之後的數據 經過謂詞p比較之後是否相等

mismatch(b , e, b2) 查找兩個容器中的不相等數據 返回值是一個pair<>a pair裡面是兩個迭代器 第一個迭代器指向第一個容器裡面不相等的數據， 第二個迭代器指向第二個容器裡面不相等的數據

mismatch(b, e, b2, p) 查找 第一個容器裡面的數據 與第二個容器裡面的數據符合p關係的數據

lexicographical_compare(b, e, b2, e2) 比較第一個區間是不是比第二個區間小

lexicographical_compare(b, e, b2, e2, p)

STL算法-複製元素

copy(b, e, b2)

copy_backward(b, e, e2)

注意：

沒有copy_if()，可以使用remove_copy_if()算法

複製過程中要逆轉元素次序，使用reverse_copy()算法

把容器內所有元素賦值給另一個容器，要使用賦值操作符或者容器的assign()成員函數

複製過程中刪除某些元素，使用remove_copy()和remove_copy_if()

複製中改變元素，使用transform()或replace_copy()算法

back_inserter(容器) 插入型迭代器 專門用於容器容量不夠時候

ostream_iterator(cout, “ ”)輸出流適配器 把數據拷貝到cout

STL算法-transform()

transform(b1, e1, b2, op) 把b1迭代器裡面到e1迭代器裡面的數據經過op之後 放到b2迭代器裡面

transform(b1, e1, b2, ,b3 op)

如果目標與源相同， transform()就和for_each()一樣

如果想以某值替換符合規則的元素，應該使用replace()算法

STL算法-交換算法

swap_ranges(b, e, b2) 交換數據的多少受到第一個迭代器容器的限制 返回一個迭代器 指向第二個容器沒有交換的位置

注意：下列兩種也是交換算法

容器的swap()成員函數

賦值函數

STL算法-填充新值

fill(b, e, v)

fill_n(b, n, v) 可以指定填充的個數

generate(b, e, p) 插入 經過p函數 得到的值

generate_n(b, n, p)

STL算法-替換算法

replace(b, e, ov, nv) 把b迭代器裡面到e迭代器裡面的 所有的ov 換成nv

replace_if(b, e, p, v) 把b迭代器裡面到e迭代器裡面的 所有的滿足函數對象p的數據 換成v

replace_copy(b1, e1, b2, ov, nv) 邊複製邊替換 把b1迭代器裡面到e1迭代器裡面的數據 複製到b2迭代器裡面 並且把所有的ov 換成nv

replace_copy_if(b1, e1, b2, p, v) 把b1迭代器裡面到e1迭代器裡面的數據 複製到b2迭代器裡面 並且把所有的滿足函數對象p的數據 換成v

STL算法-刪除算法

remove(b, e, n) 返回最後一個的下一個迭代器

remove_if(b, e, p) 符合函數p規則的都會被刪除

並不是真正的刪除，而是把後面的元素向前移動，覆蓋被刪除的元素

返回新的邏輯終點

STL算法-刪除算法

remove_copy(b, e, b2, n) 把b迭代器裡面到e迭代器裡面的拷貝到b2 並且把n刪除掉

remove_copy_if(b, e, b2, op) 把b迭代器裡面到e迭代器裡面的拷貝到b2 把符合函數op規則的數據刪除掉

STL算法-刪除算法

unique(b,e) 刪除連續的重複的數據

unique(b,e,p) 比較兩個元素的大小 符合p函數規則的刪除

unique_copy(b1,e1, b2) 拷貝到b2並且 刪除連續的重複的數據

unique_copy(b1,e1, b2, p) 拷貝到b2並且 比較兩個元素的大小 符合p函數規則的刪除

STL算法-逆序和旋轉

reverse(b ,e) 逆序

reverse_copy(b, e, b2) 拷貝到b2 並且逆序

rotate(b , b+n, e)旋轉 旋轉之後以b+n開頭 將b 到 b+n 放在後面

rotate_copy(b, b+n, e, b2)複製到b2並且旋轉 旋轉之後以b+n開頭 將b 到 b+n 放在後面

STL算法-排列組合

next_permutation(b, e) 返回值為true（沒有排列完成）或者false（排列結束）

prev_permutation()

STL算法-重列算法、分區算法

random_shuffle() 隨機排序 打亂排序

partition(b, e, p) 分區算法

stable_partition() 穩定的

STL算法-對所有元素排序

sort(b, e)

sort(b, e, p)

stable_sort(b, e)

stable_sort(b, e, p)

不適用於list容器，list有成員函數sort()

STL算法-局部排序

partial_sort(b, se, e)

partial_sort(b, se, e, p)

partial_sort_copy(sb, se, db de)

partial_sort_copy(sb, se, db de, p)

STL算法-根據第n個元素排序

nth_element(b, n, e)

nth_element(b, n, e, p)

STL算法-Heap算法

堆排序算法（heapsort）

make_heap(b, e) 把容器中的數據按堆方式排序

push_heap() 把新加入數據加入堆裡面 對容器所有數據重新進行堆排序

pop_heap() 把最大的數字 放在容器後面

pop_back()把最後的刪除

閱讀更多 小糖hpp 的文章

關鍵字: 元素 講解 vector