c11容器常用方法

1、vector：

vector<int> v

vector<int> v(10)//定义大小为10的int型向量容器。

vector<int> v(10，3)//定义大小为10，每个元素为3。

_back(2)//尾部添加元素2.

_back()//尾部删除一个元素.

v[0]=2

v[1]=3//下标访问。

vector<int>::iterator it//迭代器访问

for(it=n()it!=()it++)

{

cout<<*it<<" "

}

//元素插入，插入位置必须是迭代器位置

rt(n()，8)//最前面插入

rt(n()+2，8)

rt(()，8)//末尾追加

//元素删除

e(n()+2)//删除第2+1个元素

e(n()+1，n()+5)//删除迭代器第一到第五区间的所有元素

r()//删除所有元素

reverse(n()，())//反向排列向量所有元素（可以反向排列某段迭代器区间元素）

sort(n()，())//sort排序（默认升序排列）

//设计排序比较函数

bool comp(const int& a，const int& b)

{

return a>b//降序排列

}

sort(n()，()，comp)

()//返回向量大小，即元素个数

y()//判空，空时返回1，不空时返回0。

2、stack：

//堆栈容器

stack<int> s

(1)//入栈

()//出栈

()//返回栈顶元素

()//返回元素个数

y()//判空

3、queue：

//队列容器

//只能从队尾插入元素，队首删除元素

queue<int> q

(1)//入队

()//出队

t()//返回队首元素

()//返回队尾元素

()//返回元素个数

y()//判空

4、priority_queue：

//优先队列容器

//只能从队尾插入元素，队首删除元素

//队列中最大的元素总是位于队首（默认从大到小排序，自己可以自定义比较函数来修改）

priority_queue<int> pq

(1)//入队

()//出队

()//返回队首元素

()//返回元素个数

y()//判空

//自定义比较函数

元素为结构体：

struct info

{

string name

float score

bool operator < (const info &a) const

{

return score&e//从小到大（注意这次的符号）

}

}

元素非结构体：

struct mycomp

{

bool operator () (const int &a，const int &b) const

{

return a>b//从小到大（注意这次的符号）

}

}

priority_queue<int，vector<int>，mycomp> pq//显示说明其内部结构是vector.（注意：当有自定义比较函数时，必须显示说明其内部结构是vector！）

5、deque：

创建

deque<int> d

deque<int> d(10)//容量为10

deque<int> d(10，8.5)//10个并初始化为8.5

插入：

push_back()尾部插入，扩张队列

push_front()头部插入，不扩张队列，往后挤，把尾部的元素挤出去了

以上两个参数是一个元素对象

insert()中间某位置插入元素，不扩张队列，仍是挤出尾部的元素

参数为两个：迭代器位置+元素对象

eg：rt(n()+1，88)//即插入到第二个位置，后面的往后顺延，最后一个丢失

遍历：

d[i]//数组方式

deque<int>::iterator it

for(it=n()it!=()it++)

{

cout<<*it<<" "

}//前向迭代器方式

deque<int>::reverse_iterator it

for(rit=in()rit!=()rit++)

{

cout<<*rit<<" "

}//反向迭代器方式

删除：

首部：_front()

尾部：_back()

中间：e(n()+1)

清空：r()

6、set：

#include <set>

#include <algorithm>

//不会重复插入相同键值的元素

//采用红黑树的平衡二叉检索树结构，中序遍历

set<int> s

rt(3)//默认从小到大

set<int>::iterator it

for(it=n()it!=()it++)

{

cout<<*it<<"　"

}

//反向遍历

set<int>::reverse_iterator rit//反向迭代器

for(rit=in()rit!=()rit++)

{

cout<<*rit<<" "

}

//元素删除，删除对象可以是某个迭代器位置上的元素、等于某键值的元素、一个区间上的元素

e(n()+1)

e(6)

e(n()，n()+4)

r()

()

(6)//查找键值6，查到了则返回其迭代器位置，否则返回最后一个元素后面的位置，即end()

set<int>::iterator it

it=(6)

if(it!=())

cout<<*it<<endl

//自定义比较函数 默认从小到大存储

//非结构体元素

struct comp

{

bool operator () (const int& a，const int& b) const

{

return a>b//从大到小

}

}

set<int，comp> s//创建

set<int，comp>::iterator it

其他操作一样

//结构体元素

struct info

{

string name

float score

bool operator < (const info &a) const

{

return score&e//从大到小

}

}

set<info> s//创建

set<info>::iterator it

7、multiset：

#include <set>

#include <algorithm>

//允许重复的元素键值插入

//在插入，删除，查找方面与<set>有区别

multiset&ltstring> ms

rt("abc")

multiset<string>::iterator it

//erase()可以删除某个迭代器位置的元素，某段区间的元素，键值等于某个值的所有重复元素（并返回删除元素个数）。

e(蕋")

r()

//find()，如果查到，返回该元素第一次出现的迭代器位置，否则返回end()

it=(蕋")

8、map：

#include <map>

#include <algorithm>

//不会重复插入相同键值的元素

//采用红黑树的平衡二叉检索树结构，中序遍历

//比较函数只对键值进行比较

//和set使用大都相同

map<string，float> m

m["jack"]=98.5//插入元素

rt(pair<string，float>("lvhuan"，18.5))

map<string，float>::iterator it

for(it=n()it!=()it++)

{

cout<<(*it)t<<":"<<(*it)nd<<endl//输出键值与映照数据

}

//可以删除某个迭代器位置元素、等于某键值的元素、某迭代器区间的所有元素

e(4)

r()

//反向遍历

map<string，float>::reverse_iterator it

for(it=in()it!=()it++)

{

cout<<(*it)t<<":"<<(*it)nd<<endl//反向输出键值与映照数据

}

//find()返回键值所处迭代器位置或end()位置

//自定义比较函数（默认从小到大）

非结构体元素

struct comp

{

bool operator () (const int &a，const int &b) const

{

return a>b//从大到小

}

}

map<int，char，comp> m

map<int，char，comp>::iterator it

结构体元素

struct info

{

string name

float score

bool operator < (const info &a) const

{

return score&e//从大到小

}

}

map<info，int> m//创建

map<info，int>::iterator it

for(it=n()it!=()it++)

{

cout<<(*it)nd<<":"

cout<<((*it)t)<<" "<<((*it)t)e<<endl

}

9、multimap：

#include <map>

#include <algorithm>

//允许重复插入相同键值的元素

multimap<string，float> m

m["jack"]=98.5//插入元素

rt(pair<string，float>("lvhuan"，18.5))

multimap<string，float>::iterator it

for(it=n()it!=()it++)

{

cout<<(*it)t<<":"<<(*it)nd<<endl//输出键值与映照数据

}

//erase()可以删除某个迭代器位置的元素，某段区间的元素，键值等于某个值的所有重复元素（并返回删除元素个数），还有清空clear()

//find()，如果查到，返回该元素第一次出现的迭代器位置，否则返回end()

it=(蕋")

10、list：

//双向循环链表容器

//迭代器只能使用“++”或“--”，不能使用“+n”或“-n”。

创建：

list<int> l

list<int> l(10)//容量10

插入，都会自动扩张：

尾部：push_back()

首部：push_front()

中间：只能插到迭代器位置处：rt(it，20)//元素对象为20

遍历：

list<int>::iterator it

for(it=n()it!=()it++)

{

cout<<*it<<" "

}//前向迭代器方式

list<int>::reverse_iterator it

for(rit=in()rit!=()rit++)

{

cout<<*rit<<" "

}//反向迭代器方式

删除：remove()删除一个元素值，值相同的元素都会被删除。

ve(1)//删除值为1的所有元素

_front()//删除首部元素

_back()//删除链表尾部元素

list<int>::iterator it

for(it=n()it!=()it++)

{

cout<<*it<<" "

}

it=n()

it++

it++

e(it)//删除迭代器位置元素

r()//清空

查找：find()，找到则返回迭代器位置，否则返回end().

eg:it=find(n()，()，5)//查找这个区间上的值为5的元素的位置

升序排序：

()

删除连续重复元素，只保留一个：

ue()//注意是删除连续重复，不是单单重复

11、bitset：

//bit位元素的序列容器，每个元素只占一个bit位，取值0或1.

/*

bitset类

方法列表：

() b中是否存在置为1的二进制位

() b中不存在置为1的二进制位吗

t() b中置为1的二进制位的个数

() b中二进制位的个数

b[pos] 访问b中在pos处的二进制位

(pos) b中在pos处的二进制位是否为1

() 把b中所有二进制位都置为1

(pos) 把b中在pos处的二进制位置为1

t() 把b中所有二进制位都置为0

t(pos) 把pos处的二进制位置为0

() 把b中所有二进制位取反

(pos) 把pos处的二进制位取反

_ulong() 用b中同样的二进制位返回一个unsigned long值

os<<b 把b中的位集输出到os流

*/

//创建

bitset<100000> b//创建时必须指定容器大小，且不能再修改大小。默认初始值为0.

//元素赋值

b[6]=1//下标法，最低位为第0位

()//全部置1

(6)//将指定位置1

t()//全部置0

t(6)//指定位置0

//输出元素

cout<<b[i]//下标法输出，可以借用()来控制个大规模输出

cout<<b//注意输出的可是二进制形式哦（01串）