加權並查集：
// http://poj.org/problem?id=1182
#include<stdio.h>
struct node
{
int p;
int r;
}a[50005];
int find(int x)
{
if(x==a[x].p) return x;
int t=a[x].p;
a[x].p=find(t);
a[x].r=(a[x].r+a[t].r)%3;
return a[x].p;
}
int main()
{
int N,k;
scanf("%d%d",&N,&k);
int i,j,d,x,y,ans=0;
for(i=1;i<=N;i++)
{
a[i].p=i;
a[i].r=0;
}
for(i=0;i<k;i++)
{
scanf("%d%d%d",&d,&x,&y);
if(x>N||y>N) ans++;
else
{
if(d==2&&x==y) ans++;
else
{
int c=find(x);
int b=find(y);
if(c!=b)
{
a[b].p=c;
a[b].r=(3+d-1+a[x].r-a[y].r)%3;
}
else
{
if(d==2&&((3-a[x].r+a[y].r)%3!=d-1)) ans++;
if(d==1&&a[x].r!=a[y].r) ans++;
}
}
}
}
printf("%d\n",ans);
return 0;
}
線段樹（單點更新，區間求和）
//http://acm.hdu.edu.cn/showproblem.php?pid=1754
#include<stdio.h>
#include<algorithm>
#include<math.h>
using namespace std;
const int N=200000+5;
struct Node
{
int left,right;
int value;
};
Node tree[N<<2];
int father[N<<2];
void BuiltTree(int l,int r,int i)
{
tree[i].value=0;
tree[i].right=r;
tree[i].left=l;
if(l==r)
{
father[l]=i;
// printf("f %d %d %d\n",father[l],i,l);
return ;
}
BuiltTree(l,(int)(floor)(l+r)/2,i<<1);
BuiltTree((int)(floor)(l+r)/2+1,r,(i<<1)+1);
}
void Update(int i)
{
i>>=1;
if(i==0) return ;
tree[i].value=max(tree[i<<1].value,tree[(i<<1)+1].value);
// printf("%d %d %d %d\n",i,tree[i].value,tree[i<<1].value,tree[(i<<1)+1].value);
Update(i);
}
int ans;
void query(int l,int r,int i)
{
if(l==tree[i].left && r==tree[i].right)
{
ans=max(tree[i].value,ans);
return ;
}
i<<=1;
if(l<=tree[i].right)
{
if(r<=tree[i].right)
query(l,r,i);
else query(l,tree[i].right,i);
}
i++;
if(r>=tree[i].left)
{
if(l>=tree[i].left) query(l,r,i);
else query(tree[i].left,r,i);
}
}
int main()
{
int n,m;
while(~scanf("%d%d",&n,&m))
{
BuiltTree(1,n,1);
int i=1;
while(i<=n)
{
scanf("%d",&tree[father[i]].value);
Update(father[i]);
// printf("%d \n",tree[father[i]].value);
i++;
}
while(m--)
{
char a[2];
int v;
scanf("%s%d%d",a,&i,&v);//printf("%c %d\n",a[0],father[i]);
if(a[0]=='U')
{
// printf("v%d %d\n",father[i],tree[father[i]].value);
tree[father[i]].value=v;
// printf("v%d %d\n",father[i],tree[father[i]].value);
Update(father[i]);
}
else
{
ans=0;
query(i,v,1);
printf("%d\n",ans);
}
}
}
return 0;
}
區間線段樹（區間修改，區間求和）
// http://poj.org/problem?id=3468
#include<stdio.h>
#define ll long long
const int N=100000;
struct Node
{
int l,r;
int mid()
{
return (l+r)>>1;
}
}tree[N<<2];
ll sum[N<<2],add[N<<2];
void pushup(int i){sum[i]=sum[i<<1]+sum[i<<1|1];}
void pushdown(int i,int m)
{
if(add[i])
{
add[i<<1]+=add[i];
add[i<<1|1]+=add[i];
sum[i<<1]+=add[i]*(m-(m>>1));
sum[i<<1|1]+=add[i]*(m>>1);
add[i]=0;
}
}
void buildtree(int l,int r,int i)
{
tree[i].l=l;
tree[i].r=r;
add[i]=0;
if(l==r)
{
scanf("%lld",&sum[i]);
// printf("%d %d %d\n",i,sum[i],l);
return ;
}
int m=tree[i].mid();
buildtree(l,m,i<<1);
buildtree(m+1,r,i<<1|1);
pushup(i);
}
void update(int l,int r,int i,ll w)
{
if(tree[i].l==l&&tree[i].r==r)
{
sum[i]+=(ll)w*(tree[i].r-tree[i].l+1);
add[i]+=w;
return ;
}
if(tree[i].l==tree[i].r) return ;
pushdown(i,tree[i].r+1-tree[i].l);
int m=tree[i].mid();
if(l>m) update(l,r,i<<1|1,w);
else if(r<=m) update(l,r,i<<1,w);
else
{
update(l,m,i<<1,w);
update(m+1,r,i<<1|1,w);
}
pushup(i);
}
ll ans;
ll query(int l,int r,int i)
{
if(tree[i].l==l&&tree[i].r==r)
{
return sum[i]+ans;
}
pushdown(i,tree[i].r+1-tree[i].l);
int m=tree[i].mid();
if(l>m) ans=query(l,r,i<<1|1);
else if(r<=m) ans=query(l,r,i<<1);
else
{
ans=query(l,m,i<<1);
ans=query(m+1,r,i<<1|1);
}
return ans;
}
int main()
{
int n,q,l,r,w;
scanf("%d%d",&n,&q);
buildtree(1,n,1);
while(q--)
{
char a[2];
getchar();
scanf("%s",a);
if(a[0]=='Q')
{
scanf("%d%d",&l,&r);
ans=0;
printf("%lld\n",query(l,r,1));
}
else
{
scanf("%d%d%d",&l,&r,&w);
update(l,r,1,w);
}
}
return 0;
}
STL
一．Algorithm
給定一個vector容器：vector<int> nums={8,7,5,4,2,9,6,1,3,0};
find：find(nums.begin(),nums.end(),4)；
find the number 4 ，return the iterator of the number。
返回第一次出現4的位置的迭代器（可以理解爲指針，但不同。）
想要得到4所在位置的下標，可以寫作
find(nums.begin(),nums.end(),4)-nums.begin();
注：若未找到則返回nums.end()
swap：swap(nums[0],nums[2]);
交換nums中下標爲0和下標爲2的元素。
for_each：for_each(nums.begin(),nums.end(),[](int n){cout<<n<<" ";});
此函數可以對參數1到參數2範圍內的元素執行參數3函數內容。
以上語句可以把nums內所有元素執行cout並輸出一個空格。
用例：
#include <iostream> #include <vector> #include <algorithm>
using namespace std;
int main()
{
vector<int>nums={8,7,5,4,2,9,6,1,3,0}; cout<<find(nums.begin(),nums.end(),4)-nums.begin()<<endl;//find the number 4 return the iterator of the number
swap(nums[0],nums[2]);
for_each(nums.begin(),nums.end(),[](int n){cout<<n<<" ";}); cout<<endl;
sort(nums.begin(),nums.end(),[](int n1,int n2){return n1>n2;}); for_each(nums.begin(),nums.end(),[](int n){cout<<n<<" ";});
return 0;
}
結果:
3
5 7 8 4 2 9 6 1 3 0
9 8 7 6 5 4 3 2 1 0
algorithm庫函數集合：
adjacent_find 在一個數組中尋找兩個相鄰的元素。如果相等，就返回這兩個相等元素第一個元素的迭代器，不等的話，就返回v.end(). vector<int>::iterator it; it=adjacent_find(nums.begin(),nums.end() );
all_of C++11 檢測在給定範圍中是否所有元素都滿足給定的條件bool flag= std::all_of(nums.begin(), nums.end(),[](int i);
any_of C++11 檢測在給定範圍中是否存在元素滿足給定條件
count 返回值等價於給定值的元素的個數
count_if 返回值滿足給定條件的元素的個數
equal 返回兩個範圍是否相等
find 返回第一個值等價於給定值的元素
find_end 查找範圍A中與範圍B等價的子範圍最後出現的位置
find_first_of 查找範圍A中第一個與範圍B中任一元素等價的元素的位置
find_if 返回第一個值滿足給定條件的元素
find_if_notC++11 返回第一個值不滿足給定條件的元素
for_each 對範圍中的每個元素調用指定函數
mismatch 返回兩個範圍中第一個元素不等價的位置
none_ofC++11 檢測在給定範圍中是否不存在元素滿足給定的條件
search 在範圍A中查找第一個與範圍B等價的子範圍的位置
search_n 在給定範圍中查找第一個連續n個元素都等價於給定值的子範圍的位置
修改內容的序列操作：
copy 將一個範圍中的元素拷貝到新的位置處
copy_backward 將一個範圍中的元素按逆序拷貝到新的位置處
copy_ifC++11 將一個範圍中滿足給定條件的元素拷貝到新的位置處
copy_nC++11 拷貝 n 個元素到新的位置處
fill 將一個範圍的元素賦值爲給定值
fill_n 將某個位置開始的 n 個元素賦值爲給定值
generate 將一個函數的執行結果保存到指定範圍的元素中，用於批量賦值範圍中的元素
generate_n 將一個函數的執行結果保存到指定位置開始的 n 個元素中
iter_swap 交換兩個迭代器（Iterator）指向的元素
moveC++11 將一個範圍中的元素移動到新的位置處
move_backwardC++11 將一個範圍中的元素按逆序移動到新的位置處
random_shuffle 隨機打亂指定範圍中的元素的位置
remove 將一個範圍中值等價於給定值的元素刪除
remove_if 將一個範圍中值滿足給定條件的元素刪除
remove_copy 拷貝一個範圍的元素，將其中值等價於給定值的元素刪除
remove_copy_if 拷貝一個範圍的元素，將其中值滿足給定條件的元素刪除
replace 將一個範圍中值等價於給定值的元素賦值爲新的值
replace_copy 拷貝一個範圍的元素，將其中值等價於給定值的元素賦值爲新的值
replace_copy_if 拷貝一個範圍的元素，將其中值滿足給定條件的元素賦值爲新的值
replace_if 將一個範圍中值滿足給定條件的元素賦值爲新的值
reverse 反轉排序指定範圍中的元素
reverse_copy 拷貝指定範圍的反轉排序結果
rotate 循環移動指定範圍中的元素
rotate_copy 拷貝指定範圍的循環移動結果
shuffleC++11 用指定的隨機數引擎隨機打亂指定範圍中的元素的位置
swap 交換兩個對象的值
swap_ranges 交換兩個範圍的元素
transform 對指定範圍中的每個元素調用某個函數以改變元素的值
unique 刪除指定範圍中的所有連續重複元素，僅僅留下每組等值元素中的第一個元素。
unique_copy 拷貝指定範圍的唯一化（參考上述的 unique）結果
劃分操作：
is_partitionedC++11 檢測某個範圍是否按指定謂詞（Predicate）劃分過
partition 將某個範圍劃分爲兩組
partition_copyC++11 拷貝指定範圍的劃分結果
partition_pointC++11 返回被劃分範圍的劃分點
stable_partition 穩定劃分，兩組元素各維持相對順序
排序操作：
is_sortedC++11 檢測指定範圍是否已排序
is_sorted_untilC++11 返回最大已排序子範圍
nth_element 部份排序指定範圍中的元素，使得範圍按給定位置處的元素劃分
partial_sort 部份排序
partial_sort_copy 拷貝部分排序的結果
sort 排序
stable_sort 穩定排序
二分法查找操作：
binary_search 判斷範圍中是否存在值等價於給定值的元素
equal_range 返回範圍中值等於給定值的元素組成的子範圍
lower_bound 返回指向範圍中第一個值大於或等於給定值的元素的迭代器
upper_bound 返回指向範圍中第一個值大於給定值的元素的迭代器
集合操作：
includes 判斷一個集合是否是另一個集合的子集
inplace_merge 就緒合併
merge 合併
set_difference 獲得兩個集合的差集
set_intersection 獲得兩個集合的交集
set_symmetric_difference 獲得兩個集合的對稱差
set_union 獲得兩個集合的並集
堆操作：
is_heap 檢測給定範圍是否滿足堆結構
is_heap_untilC++11 檢測給定範圍中滿足堆結構的最大子範圍
make_heap 用給定範圍構造出一個堆
pop_heap 從一個堆中刪除最大的元素
push_heap 向堆中增加一個元素
sort_heap 將滿足堆結構的範圍排序
最大/最小操作：
is_permutationC++11 判斷一個序列是否是另一個序列的一種排序
lexicographical_compare 比較兩個序列的字典序
max 返回兩個元素中值最大的元素
max_element 返回給定範圍中值最大的元素
min 返回兩個元素中值最小的元素
min_element 返回給定範圍中值最小的元素
minmaxC++11 返回兩個元素中值最大及最小的元素
minmax_elementC++11 返回給定範圍中值最大及最小的元素
next_permutation 返回給定範圍中的元素組成的下一個按字典序的排列
prev_permutation 返回給定範圍中的元素組成的上一個按字典序的排列
Vector
初始化：
(1) vector<int> a(10); //定義了10個整型元素的向量（尖括號中爲元素類型名，它可以是任何合法的數據類型），但沒有給出初值，其值是不確定的。
（2）vector<int> a(10,1); //定義了10個整型元素的向量,且給出每個元素的初值爲1
（3）vector<int> a(b); //用b向量來創建a向量，整體複製性賦值
（4）vector<int> a(b.begin(),b.begin+3); //定義了a值爲b中第0個到第2個（共3個）元素
（5）int b[7]={1,2,3,4,5,9,8};
vector<int> a(b,b+7); 或者vector<int> a(b,&b[7])//從數組中獲得初值;
函數：
（1）a.assign(b.begin(), b.begin()+3); //b爲向量，將b的0~2個元素構成的向量賦給a
（2）a.assign(4,2); //是a只含4個元素，且每個元素爲2
（3）a.back(); //返回a的最後一個元素
（4）a.front(); //返回a的第一個元素
（5）a[i]; //返回a的第i個元素，當且僅當a[i]存在2013-12-07
（6）a.clear(); //清空a中的元素
（7）a.empty(); //判斷a是否爲空，空則返回ture,不空則返回false
（8）a.pop_back(); //刪除a向量的最後一個元素
（9）a.erase(a.begin()+1,a.begin()+3); //刪除a中第1個（從第0個算起）到第2個元素，也就是說刪除的元素從a.begin()+1算起（包括它）一直到a.begin()+ 3（不包括它）
（10）a.push_back(5); //在a的最後一個向量後插入一個元素，其值爲5
（11）a.insert(a.begin()+1,5); //在a的第1個元素（從第0個算起）的位置插入數值5，如a爲1,2,3,4，插入元素後爲1,5,2,3,4
（12）a.insert(a.begin()+1,3,5); //在a的第1個元素（從第0個算起）的位置插入3個數，其值都爲5
（13）a.insert(a.begin()+1,b+3,b+6); //b爲數組，在a的第1個元素（從第0個算起）的位置插入b的第3個元素到第5個元素（不包括b+6），如b爲1,2,3,4,5,9,8 ，插入元素後爲1,4,5,9,2,3,4,5,9,8
（14）a.size(); //返回a中元素的個數；
（15）a.capacity(); //返回a在內存中總共可以容納的元素個數
（16）a.resize(10); //將a的現有元素個數調至10個，多則刪，少則補，其值隨機
（17）a.resize(10,2); //將a的現有元素個數調至10個，多則刪，少則補，其值爲2
（18）a.reserve(100); //將a的容量（capacity）擴充至100，也就是說現在測試a.capacity();的時候返回值是100.這種操作只有在需要給a添加大量數據的時候才 顯得有意義，因爲這將避免內存多次容量擴充操作（當a的容量不足時電腦會自動擴容，當然這必然降低性能）
（19）a.swap(b); //b爲向量，將a中的元素和b中的元素進行整體性交換
（20）a==b; //b爲向量，向量的比較操作還有!=,>=,<=,>,<
訪問vector的特殊方法
從現有向量中選擇元素向向量中添加：
int a[6]={1,2,3,4,5,6};
vector<int> b;
vector<int> c(a,a+4);for(vector<int>::iterator it=c.begin();it<c.end();it++)
b.push_back(*it);
從文件中讀取元素向向量中添加：
ifstream in("data.txt");
vector<int> a;for(int i; in>>i)
a.push_back(i);
從向量中讀取元素得方法：
int a[6]={1,2,3,4,5,6};
vector<int> b(a,a+4);for(int i=0;i<=b.size()-1;i++)
cout<<b[i]<<" ";
通過遍歷器方式讀取：
int a[6]={1,2,3,4,5,6};
vector<int> b(a,a+4);for(vector<int>::iterator it=b.begin();it!=b.end();it++)
cout<<*it<<" ";
Vector的幾種重要算法
1.
（1）sort(a.begin(),a.end()); //對a中的從a.begin()（包括它）到a.end()（不包括它）的元素進行從小到大排列
（2）reverse(a.begin(),a.end()); //對a中的從a.begin()（包括它）到a.end()（不包括它）的元素倒置，但不排列，如a中元素爲1,3,2,4,倒置後爲4,2,3,1
（3）copy(a.begin(),a.end(),b.begin()+1); //把a中的從a.begin()（包括它）到a.end()（不包括它）的元素複製到b中，從b.begin()+1的位置（包括它）開 始複製，覆蓋掉原有元素
（4）find(a.begin(),a.end(),10); //在a中的從a.begin()（包括它）到a.end()（不包括它）的元素中查找10，若存在返回其在向量中的位置
2.（使用時注意）
vector<int>::iterator it;//迭代器
int i;
初始化：
vector<int>v1; //定義空的vector
vector<int>v2(10); //產生大小爲10的vector
vector<int>v3(10,-1); //產生大小爲10，並且每個元素都是-1的vector
vector<int>v4(v3); //用一個vector產生一個vecotr
int arr[5]={1,2,3,4,5};
vector<int>v5(arr,&arr[5]); //以區間[beg;end)做爲初值的vector
cout<<v5.size()<<endl;
賦值
v1.assign(arr,arr+3);//將arr中的前三個元素賦給v1;
vector<int>a;
vector<int>b;
a.assign(4,2);//a只包含4個元素，且每個元素都爲2;
cout<<endl;
遍歷： for(i=0;i<a.size();i++) printf("%d ",a[i]);cout<<endl;
int v=a.back(); //返回a中最後一個元素;
v=a.front();// 返回a的第一個元素;
i=1;v=a[i]; //返回a的第i個元素，當且僅當
清空 a.clear();//清空a;
判斷是否爲空 if(a.empty()) printf("a is empty\n");
if(!a.empty()) a.pop_back();//刪除a中最後一個元素
插入
a.push_back(10);
v=a.front();//front前最好加個a.empty()判斷一下！！！
大小
vector<int>::size_type n=a.size();//Returns the number of elements in the vector.Member type size_type is an unsigned integral type.
cout<<"a.size:"<<a.size()<<endl;//size:返回a向量的元素的個數
刪除：
a.erase(a.begin()+1,a.begin()+3);//刪除a中第1個（從第0個算起）到第2個元素，也就是說刪除的元素從a.begin()+1 算起（包括它）
//一直到a.begin()+3（不包括它)
printf("a.size:%d\n",a.size());
//vector.erase(a.begin(),a.begin()+3)要求a中必須至少有a.begin()+3-a.begin()個元素
插入
it=a.begin();
it=a.insert(it,3);//在a中的it位置插入3個4,it爲迭代器;
printf("inset：%d\n",*it);
for(it=a.begin();it!=a.end();++it) printf("%d ",*it);
it=find(a.begin(),a.end(),10);//查找a中某一段區間，如果找到了則輸出這個地址，否則爲0;
printf("\n%d\n",*it);
printf("%d %d\n",a.capacity(),a.size()); //a.capacity:返回a在內存中總共可以容納的元素個數,a.size():
Resize
a.resize(10);//將a的現有元素個數調至10個，多則刪，少則補，其值隨機
a.resize(10,2);//將a的現有元素個數調至10個，多則刪，少則補，其值爲2
a.reserve(100);// 將a的容量（capacity）擴充至100，也就是說現在測試a.capacity();的時候返回值是100.這種操作只有在需要給a添加大量數據的時候才 顯得有意義，因爲這將避免內存多次容量擴充操作（當a的容量不足時電腦會自動擴容，當然這必然降低性能）
交換 a.swap(b); //b爲向量，將a中的元素和b中的元素進行整體性交換
a在內存中的容量 printf("%d\n",a.capacity());
//其他重要算法（需要頭文件algorithm）
sort(a.begin(),a.end(),cmp);//cmp決定sort的升降序
reverse(a.begin(),a.end());//對a中的從a.begin()（包括它）到a.end()（不包括它）的元素倒置，但不排列，如a中元素爲1,3,2,4,倒置後爲4,2,3,1
copy(a.begin(),a.end(),b.begin()+1);//把a中的從a.begin()（包括它）到a.end()（不包括它）的元素複製到b中，從b.begin()+1的位置（包括它）開 始複製，覆蓋掉原有元素
List
List定義和初始化：
list<int>lst1; //創建空list
list<int> lst2(5); //創建含有5個元素的list
list<int>lst3(3,2); //創建含有3個元素的list
list<int>lst4(lst2); //使用lst2初始化lst4
list<int>lst5(lst2.begin(),lst2.end()); //同lst4
操作函數
list<int>lst1; //創建空list
list<int> lst2(5); //創建含有5個元素的list,每個元素都爲0
list<int>lst3(3,2); //創建含有3個元素的list，每個元素都爲2
list<int>lst4(lst2); //使用lst2初始化lst4
list<int>lst5(lst2.begin(),lst2.end()); //聲明一個列表，其元素的初始值來源於由區間所指定的序列中的元素，
list<int> a;
list<int>::iterator it1,it2;
賦值:
a.push_back(i);//push_back()是從list末端插入，而push_front是從頭部插入
b.賦值 :a.push_front(i);
遍歷：
for(it1=a.begin();it1!=a.end();++it1)
printf("%d ",*it1);
a的大小 : printf("\nsize:%d\n",a.size());// a的元素個數
a的最大容量: cout<<a.max_size()<<endl;//返回a的最大元素數量
//調用resize(n)將list的長度改爲只容納n個元素，超出的元素將被刪除。
//如果n比list原來的長度長，那麼默認超出的部分元素置爲0。
//也可以用resize(n, m)的方式將超出的部分賦值爲m。
a.resize(10);//從新定義鏈表的長度,超出原始長度部分用0代替,小於原始部分刪除。
a.resize(20,1);// 從新定義鏈表的長度,超出原始長度部分用num代替。
a的頭部元素: printf("%d\n",a.front());
a的末段元素: printf("%d\n",a.back());
迭代器：
list<int>::reverse_iterator it3;
雙向鏈表末段： it3=a.rbegin();//返回逆向鏈表的第一個元素,即c鏈表的最後一個數據。
雙向鏈表的頭部： it3=a.rend();//返回逆向鏈表的最後一個元素的下一個位置,即c鏈表的第一個數據再往前的位置。
//使用pop_back()可以刪掉尾部第一個元素，pop_front()可以刪掉頭部第一個元素。注意：list必須不爲空，
//如果當list爲空的時候調用pop_back()和pop_front()會使程序崩掉。
//使用前最好先a.empty();
刪除：
a.pop_back();
a.pop_front();
賦值：
a.assign(3,1);//將a變成元素個數爲3，值都爲1的list
list<int>b;
b.assign(a.begin(),a.end());//將b初始化，且和a相同 ,a.begin()和a.end()只能能++或者--
int ints[]={1,2,3,4};
a.assign(ints,ints+4);//利用數組初始化a
交換：
a.swap(b);//交換兩個鏈表。a.swap(b)和swap(a, b)，都可以完成a鏈表和b鏈表的交換。
轉置：
reverse(b.begin(),b.end());
Empty：
if(a.empty()) {...;}
合併：
a.merge(b,less<int>());//將b合併到a,less<int>()(默認):a在前，b在後，greater則相反
//也可以用cmp （ bool mycomparison (double first, double second)
{ return ( int(first)<int(second) ); } ）
//使用splice()前搖先判斷b是否爲空
a.splice(a.end(),b);//a.end()是沒有元素，將b連接到a的a.end()位置 ,並釋放b
a.splice(it1,b,it2);//將b的it2位置上的元素連接到a的的it1,並釋放掉b的it2;
a.splice(it1,b,b.begin(),b.end());//同上
插入：
// a.insert(pos,num) 在pos位置插入元素num。
// a.insert(pos,n,num) 在pos位置插入n個元素num。
// a.insert(pos,beg,end) 在pos位置插入區間爲[beg,end)的元素。
// c.erase(pos) 刪除pos位置的元素。
對迭代器的：
advance(it1,4);//加減迭代器 ，n(4) = 0 不移動，n > 0 迭代器+n， n <0 迭代器-n。
it2++;
刪除： a.erase(it1);//刪除第5個元素(a從0開始)
it1=a.begin();
it2=a.begin();
advance(it1,4);
// a.erase(it1);//刪除it1位置的元素
// 因爲a.erase()是對地址進行操作，當執行這一步時，下面erase會爆炸
a.erase(++it2,it1);//刪除a中it2到it1-1之間的元素
刪除：
list<int>::iterator it=++a.begin();
a.remove(1);// 刪除鏈表中匹配num的元素。
a.remove_if(cmp_remove);//刪除條件滿足的元素,參數爲自定義的回調函數。
for(it1=a.begin();it1!=a.end();++it1)
printf("%d ",*it1);
printf("\n");
去重
for(int i=1;i<5;i++) a.push_back(0);
a.unique();//刪除相鄰且重複的元素（保留一個）
for(it1=a.begin();it1!=a.end();++it1)
printf("%d ",*it1);
printf("\n");
排序
a.sort(cmp);//排序b不能用sort(a.begin(),a.end());
for(it1=a.begin();it1!=a.end();++it1)
printf("%d ",*it1);
printf("\n");
清空
a.clear();//刪除鏈表中匹配num的元素。
Queue
queue<int> a,b;
//queue沒有迭代器！！！！！！！！！
插入
a.push(1);
刪除
a.pop();
size
printf("%d\n",a.size());//返回值爲 unsigned int
queue<int>q; //創建一個int型空隊列q
q.empty(); //判斷隊列是否爲空，爲空返回true
q.push(2); //將變量s從隊尾入隊
q.pop(); //將隊頭元素彈出
q.front(); // 只返回隊頭元素
q.back(); //只返回隊尾元素
q.size(); // 返回隊列中元素個數
Deque
(頭文件deque)雙端隊列的操作 (可以在隊頭隊尾進行入隊出隊操作)
//deque有迭代器！！！
deque<int> dq; //創建一個數雙端隊列dq
dq.empty(); //判斷隊列是否爲空，爲空返回true
dq.push_front(3); //將s從隊頭入隊
deque<int>::iterator it;
it=dq.begin();
printf("%d\n",*it);
dq.push_back(4); //將s從隊尾入隊,和普通隊列方式一樣
dq.front(); //只返回隊頭元素
dq.back(); //只返回隊尾元素
dq.pop_front(); //將隊頭元素彈出
dq.pop_back(); //將隊尾元素彈出
dq.clear(); //將隊列清空
雖然是自己寫的，但是都忘了。