把c++視訊全部又看了一遍,總結了stl類庫

總結如下:

vector:
vector向量中,可以用[x][y]表示第x-1位裡的第y-1個元素;
s[i] //  直接以下標方式訪問容器中的元素
s.front() //  返回首元素
s.back() //  返回尾元素
s.push_back(x) //  向表尾插入元素x
s.size() //  返回表長
s.empty() //  表為空時，返回真，否則返回假
s.pop_back() //  刪除表尾元素
s.begin() //  返回指向首元素的隨機存取迭代器
s.end() //  返回指向尾元素的下一個位置的隨機存取迭代器
s.insert(it, val) //  向迭代器it指向的元素前插入新元素val
s.insert(it, n, val)//  向迭代器it指向的元素前插入n個新元素val
s.insert(it, first, last) //  將由迭代器first和last所指定的序列[first, last)插入到迭代器it指向的元素前面
s.erase(it) //  刪除由迭代器it所指向的元素 s.erase(first, last)//  刪除由迭代器first和last所指定的序列[first, last) s.reserve(n) //  預分配緩衝空間，使儲存空間至少可容納n個元素
s.resize(n) //  改變序列長度，超出的元素將會全部被刪除，如果序列需要擴充套件（原空間小於n），元素預設值將填滿擴展出的空間 s.resize(n, val) //  改變序列長度，超出的元素將會全部被刪除，如果序列需要擴充套件（原空間小於n），val將填滿擴展出的空間 s.clear() //  刪除容器中的所有元素
s.swap(v) //  將s與另一個vector物件進行交換

deque//雙向動態陣列
deque  可以在陣列的開頭和末尾插入和刪除資料
a.push_back(x) 陣列後面加資料
a.push_front(y)陣列前面加資料
a.pop_back()陣列後面依次刪除資料
a.pop_front()陣列前面依次刪除
deque迭代器
deque<int>::itreator x
size_t n=distance(a.begin(),x(迭代器名))//algorithm演算法distance()

list雙向連結串列   連結串列沒有下標,只能用迭代器,不能用陣列迴圈輸入或輸出連結串列中的資料//插入刪除資料時比vector速度快
可以在list開頭插入元素
可以在list末尾插入元素
可以在list中間插入元素
刪除list中的元素
元素進行反轉和排序
a.push_front(x) 在連結串列前面加入資料//從前往後排序,先插入的在後面
a.front()//連結串列前面第一個的元素
a.back()//連結串列最後一個的元素
a.push_back(x) 連結串列後面加資料//輸入資料速度很快//vector速度慢,因為擴大陣列時是先建立一個新陣列,然後再複製到新數組裡
a.push_front(y)連結串列前面加資料
a.pop_back()連結串列後面依次刪除資料
a.pop_front()連結串列前面依次刪除
a.insert(a.begin(),10)//在開頭的前面插入10;a.begin為迭代器
a.insert(a.end(),4,20)//在後端插入4個20//a.end()為迭代器
a.insert(a.begin(),b.begin(),b.end())//將b全部插入A的前面,換成b.end()則插入a後面,
a.insert(a.begin(),++b.begin(),b.end())
a.erase(迭代器)//刪除迭代器
a.erase(x,y)//從X刪除y,包括x,不包括y
list 反轉和排序
a.reverse();//連結串列反轉
a.sort();//連結串列排序,從小到大

stl  stack  堆疊後進先出,後進先出  無迭代器,只能在末端操作資料
自適應容器(容器介面卡)
棧介面卡//定義堆疊
    stack< int,deque<int> > a;
    stack< int,vector<int> > b;
    stack< int,list<int> > c;
    stack<int> d;
a.empty();//檢查堆疊是否為空
a.size();//檢查堆疊的大小
a.pop();//彈出資料
a.top();//檢視棧頂資料,不刪除
a.push(x);//把x壓入堆疊

stl  queue 佇列  先進先出,要求兩端都能操作,所以不能建立vector佇列 ;
插入只能在隊尾,彈出只能是隊首   無迭代器,所以只能在兩端操作資料,不能在中間插入或者刪除元素
棧介面卡
q.empty();//檢查佇列是否為空
q.size();//檢查佇列的大小
q.front();//檢視隊首的資料,並不刪除
q.back();//檢視隊尾資料,並不刪除
q.push(x);從對首到隊尾依次新增元素
q.pop();//只能在隊首依次刪除;

stl 優先順序佇列  priority_queue  不能使用list
分為 :最大值優先順序佇列,最小優先順序佇列
a.push(x);//插入元素,按降序或升序
a.top();//檢視優先順序佇列首元素
a.pop();//刪除優先順序佇列首元素
a.empty();//判斷是否為空
a.size();//求優先順序佇列大小
priority_queue<int> a;//最大值優先順序佇列
priority_queue<int,greater<int>() > a;//最小值優先順序佇列

bitset

在 STL
的標頭檔案中 <bitset> 中定義了模版類 bitset，用來方便地管理一系列的 bit 位的類。bitset 除了可以訪問指定下標的 bit

位以外，還可以把它們作為一個整數來進行某些統計。

bitset
模板類需要一個模版引數，用來明確指定含有多少位。
bt.any()  //  bt 中是否存在置為 1 的二進位制位？
bt.none()  //  bt 中不存在置為 1 的二進位制位嗎？
bt.count()  //  bt 中置為 1 的二進位制位的個數
bt.size()  //  bt 中二進位制位的個數
bt[pos]  //  訪問 bt 中在 pos 處的二進位制位
bt.test(pos)  //  bt 中在 pos 處的二進位制位是否為 1
bt.set()  //  把 bt 中所有二進位制位都置為 1
bt.set(pos)  //  把 bt 中在 pos 處的二進位制位置為 1
bt.reset()  //  把 bt 中所有二進位制位都置為 0
bt.reset(pos)  //  把 bt 中在pos處的二進位制位置為0
bt.flip()  //  把 bt 中所有二進位制位逐位取反
bt.flip(pos)  //  把 bt 中在 pos 處的二進位制位取反
bt[pos].flip()  //  同上
bt.to_ulong()  //  用 bt 中同樣的二進位制位返回一個 unsigned long 值
os << bt  //  把 bt 中的位集輸出到 os 流

迭代器  
常用的迭代器操作:*iter  ++iter  --iter iter1==iter2  iter1!=iter2
vector deque
iter+n  iter-n >  >=  
迭代器範圍
begin/end //end()是指向最後一個的下一個地址   first/last

順序容器:  vector   list   deque
    vector<int>::size_type a1;//陣列迴圈時,定義i的型別.用於陣列中資料較多時
    vector<int>::iterator  a2;
    vector<int>::const_iterator    a3;
    vector<int>::reverse_iterator  a4;//逆序迭代器,rbegin(),rend();
    vector<int>::const_reverse_iterator a5;
    vector<int>::difference_type      a6;
        vector<int>::value_type          a7;
    vector<int>::reference    a8;
    vector<int>::const_reference    a9;

a.size() 返回型別是  size_type   
a.max_size()//返回這個容器能容納的最大數量  返回型別 size_type
a.resize(x)或a.resize(x,y)表示新增x個y//調整容器大小

刪除元素:
a.erase(x)//第x個元素                                    
a.erase(x,y)//刪除x-y,包括x,不包括y
a.clear()//全部刪除
a.swap(b)//a向量陣列與b向量陣列交換
a.assign(c.begin(),c.end())//將c的begin()到c的end()賦值a,begin不一定是陣列開始的位置
a.reserve(x)//增大陣列容量至x
a.capacity()//測量陣列的容量

向量陣列排序快
向量陣列二分查詢   binary_search(a.begin(),a.end(),x)//在陣列中找x

只適合string型別的操作
s.substr(x,y):從字串中的第x到y的所有元素
s.substr(x);x以後的所有元素
s.substr():s中的所有字串
s.append("x"):在最後新增字串x=s.insert(s.end(),"x")
replace(x,y,"z"):從x到y換成z

set:
set(集)//不能放入重複的資料//與multiset//資料可以重複//插入後會排好序
插入:a.insert(x);
支援find()和erase();
if(a.find(x)==a.end())//判斷x是否在a中
set清除資料可以用a.clear();
set<int> a;
set<double> ss;
a.insert(x);//將x插入陣列a中,插入結束後,a中陣列已經排好序    
s.begin() //  返回指向第一個元素的迭代器
s.clear() //  清除所有元素
s.count() //  返回某個值元素的個數
s.empty() //  如果集合為空，返回true(真）
s.end() //  返回指向最後一個元素之後的迭代器，不是最後一個元素
s.equal_range() //  返回集合中與給定值相等的上下限的兩個迭代器
s.erase() //  刪除集合中的元素
s.find() //  返回一個指向被查詢到元素的迭代器
s.get_allocator() //  返回集合的分配器
s.insert() //  在集合中插入元素
s.lower_bound() //  返回指向大於（或等於）某值的第一個元素的迭代器
s.key_comp() //  返回一個用於元素間值比較的函式
s.max_size() //  返回集合能容納的元素的最大限值
s.rbegin() //  返回指向集合中最後一個元素的反向迭代器
s.rend() //  返回指向集合中第一個元素的反向迭代器
s.size() //  集合中元素的數目
s.swap() //  交換兩個集合變數
s.upper_bound() //  返回大於某個值元素的迭代器
s.value_comp() //  返回一個用於比較元素間的值的函式

對映:map//插入資料後也是自動按字典順序排列 二叉樹,紅黑樹
map就是從鍵（key,不可以重複）到值（value）的對映。因為過載了[ ]運算子，map像是陣列的“高 級版”。例如可以用一個map<string，int>month_name來表示“月份名字到月份編號”的對映， 然後用month_name["July"]=7這樣的方式來賦值。
map插入方法:1: a.insert(map<int,string>::value_type(x,"y"));
2:a.insert(make_pair(x,"y"));
3:a.insert(pair<int,string>(x,"y"));
4:a[x]="y";
輸出 鍵 a->first 鍵值 a->second.c_str;  
查詢:cout<<a[x]//直接輸出x對應的值
multimap鍵值可以重複
插入方法:
1: a.insert(multimap<int,string>::value_type(x,"y"));
2:a.insert(make_pair(x,"y"));
3:a.insert(pair<int,string>(x,"y"));
multimap的查詢
multimap<int,string>::iterator fi;
fi=a.find(x)//查詢x
cout<<fi->first<<fi->second.c_str()<<endl;
a.count(x)統計multimap中x的個數
刪除:
1:ma.erase(x);//x為鍵
2:ma.erase(ma.lower_bound(x),ma.upper_bound(x));//刪除一個範圍

stl演算法
標頭檔案
#include<algorithm>
#include<numeric>//數值演算法
#include<functional>//函式介面卡
預定義的函式物件
negate<type>()
plus<type>()
minus<type>()
greater<type>//從大到小
less<type>//從小到大
for_each(v.begin(),v.end(),函式預定義);//對兩個迭代器內的資料進行
預定義的函式介面卡
  int visit(int v)    //  遍歷運算元函式
{
    cout << v << " ";
    return 1;
}
  for_each(L.begin(), L.end(), visit);

min_element/max_element找出容器中的最小/最大值//
    vector<int>::iterator min_it = min_element(L.begin(), L.end());
    vector<int>::iterator max_it = max_element(L.begin(), L.end());

copy在容器間複製元素
     copy(vOne.begin(), vOne.begin() + 3, vTwo.begin() + 4);

元素計數演算法
count(a.begin(),a.end(),x)
最大值和最小值
min_element(b,e)//迭代器b到迭代器e之間//返回值是一個迭代器 輸出時:cout<<*min_element
max_element(b,e)//同上
查詢演算法:
find()    //返回是所在位置的地址的迭代器
find_if() //
search_n(b,e,c,v)//找連續的數