STL常用方法

简介c++ STL的常用方法

 dwh  5个月前 (03-03)  分类：知识点  阅读(173)  评论(0)

#以下type可以代表int char float double或者string vector set等等 即是数据类型的都可以

vector    容器类   头文件 <vector>

定义      之间可以进行=  ==  !=  等逻辑运算 如v1==v2  判断两个容器是否相等

vector<type>v

vector<type>v(v1)    即v=v1

vector<type>v(n)     确定容器的初始容量

vector<type>v(n,first) 确定容器的初始容量和初始值

 

常用方法

v.assign(v1.begin(),v1.end())  v1从begin到end的位置的元素给v  覆盖操作

v.size()        返回容器的个数

v[i]类似v.at(i) 取出第i个数  第一个为0

v.begin()       得到数组头的指针

v.end()         得到数组的最后一个单元+1的指针

v．front()      得到数组头的引用

v.back()        得到数组的最后一个单元的引用

v.max_size()    得到vector最大可以是多大

v.capacity()    当前vector分配的大小

v.resize(n)      改变当前使用数据的大小，如果它比当前使用的大，或者填充默认值

v.resize(n,i)       更改为n长 如果新增加的 初始化为i

v.reserve()     改变当前vecotr所分配空间的大小   少用

v.rbegin()      将vector反转后的开始指针返回(其实就是原来的end-1)

v.rend()        将vector反转构的结束指针返回(其实就是原来的begin-1)

v.empty()       判断vector是否为空

v.swap(v1)        与另一个vector交换数据

 

插入移除操作

v.push_back(i)  在数组的最后添加i

v.pop_back()    去掉数组的最后一个数据

v.erase(iterator it)       删除指针指向的数据项     要使用迭代器

v.erase(begin , end)   删除[begin,end)的区间

v.clear()       清空当前的vector

v.insert(iterator,n)   在指向的地方 插入n

v.insert(iterator,k,n)   在指向的地方 连续插入k个n

v.insert(iterator,begin,end)  在指向的地方 插入[begin,end) 区间的元素

set 集合类 头文件<set>    ///set比multiset常用 两者用法基本一样

定义       放入集合内的元素 都是有序存放的 所以每次插入都是logN 因为集合的唯一性，同一个元素 放进去两次，只会保留一个

set<type>s

set<type,cmp>s     重载比较符号 就是默认是从小到大排序 可以改写成从大到小     

multiset<type>mts    ///这个要注意 如果放10个2进去 里面会有10个2 而set只会保存1个

 

插入移除操作

s.insert(k)     插入元素k，多次插入同一个元素后面无效  

s.insert(a, b)  插入指针[a, b)之间的元素，已有元素不会再次插入  

s.erase(k)      删除元素k，若不存在则删除无效  ///如果在multiset内这样 会把10个2都删除 应该mts.erase(mts.find(k));

s.erase(it)     删除迭代器it对应的元素

s.erase(l, r)   删除迭代器[l, r)之间的元素

 

常用方法

s.count(k)  判断元素k是否在容器内 

s.clear()   清空容器

s.size()    返回容器现有元素个数

s.empty()   判断容器是否为空

s.begin()  返回set中第一个元素，类型为正向迭代器

s.rbegin() 返回set中最后一个元素，类型为反向迭代器

s.end()    返回set中最后一个元素，类型为正向迭代器

s.rend()   返回set中第一个元素，类型为反向迭代器

s.find(k)  寻找k，若找到返回对应的迭代器，否则返回end()

s.lower_bound(k)  返回第一个大于等于k的元素的迭代器

s.upper_bound(k)  返回第一个大于k的元素的迭代器

map  映射类  头文件<map>    ///这个很常用

定义     内部实现方法为红黑树

map<type,type>m     基中 第一个type为key 第二个type为value  注意 key值唯一

插入操作

如 map<string,int>m   想添加一个元素进去 可以

m[abc]=1或者m.insert(make_pair("abc",1))   

再用printf("%d\n",m["abc"]);就会输出1

这里可以看出来 像数组 我想访问第i个 就a[i] 这里的key=i value=a[i]   映射就没有局限 可以用各种类型当key value也是

 

查找与删除操作

it=m.find(key)    反回一个pair类型  要用迭代器接收 使用it->first为key it->second为value

it=m.find(key)  m.earse(it);

 

常用方法

begin()          返回指向map头部的迭代器

empty()          如果map为空则返回true

end()            返回指向map末尾的迭代器

rbegin()         返回一个指向map尾部的逆向迭代器

rend()           返回一个指向map头部的逆向迭代器

size()           返回map中元素的个数

swap()           交换两个map

lower_bound()    返回键值>=给定元素的第一个位置

upper_bound()    返回键值>给定元素的第一个位置

 

value_comp()     返回比较元素value的函数

equal_range()    返回特殊条目的迭代器对

clear(）         删除所有元素

count()          返回指定元素出现的次数

key_comp()       返回比较元素key的函数

get_allocator()  返回map的配置器

max_size()       返回可以容纳的最大元素个数

 

 

其实还有个mulitmap的  ///http://blog.csdn.net/believefym/article/details/1627874

queue   队列类   头文件<queue>

定义   先进来先出去像排队一样  衍生类 优先队列 priority_queue  这个比队列常用

queue<type>q

priority_queue<type>pri_q  定义一个有序队列(默认从小到大排,其顶端元素为最大的那个)

priority_queue<(队列中元素的数据类型), (用于储存和访问队列元素的底层容器的类型), (比较规则) > k  

priority_queue<int, vector<int>, greater<int> > k;(注意:比较规则后面必须要空上一格) ->定义一个有序队列，

排序规则为从大到小（其顶端元素为最小的那个）（greater为从小到大，顶端最小，less为从大到小，顶端最大）

 

q.empty() 查看是否为空范例,是的话返回1,不是返回0

q.push(i) 从已有元素后面增加元素i(队伍大小不预设)

q.pop()   清除位于顶端的元素(当然是排完序后,下同)

q.front()   q.top()   队列用前者，优先队列内部实现为堆，top为堆顶的意思     显示顶端的元素

q.size()  输出出现有元素的个数

 

例子-->>http://www.dengwenhuo.cn/?id=115

string  字符类  头文件<string>

定义        字符串可以直接用<=、==等进行比较，并返回0或1   类似strcmp()

string  str

char *cstr = "bbbbb";  string str(cstr);

string str(10,'1')  初始化为10个字符1

 

 

str.resize(len, ch)

str.length() 

 

str = str2                字符串复制    类似strcpy()

str.assign(cstr)          将C类字符串赋值给str

str.assign(cstr, 2)       将C类字符串的前n个字符赋值给str

str.assign(8, 'c')        用8个字符c赋值给当前字符串 

str.assign(str2, 0, 3)    把字符串str2中从0开始的3个字符赋给当前字符串

 

str += str2               把str2连接到str的后面   类似strcat();

str.append(cstr)          将C类字符串str2连接到str的后面

str.append(cstr, 2)       将C类字符串str2的前n个字符连接到str的后面

str.push_back('k')        把一个字符连接到str的结尾

 

str.replace(0, 3, "abcd")    删除从0开始的3个字符，然后在0处插入字符串"abcd" 

str.replace(0, 3, str2, 2)   删除从0开始的3个字符，然后在0处插入字符串str2的前2个字符 

str.replace(0, 3, "opqrstuvw", 2, 4) 删除从0开始的3个字符，然后在0处插入字符串“opqrstuvw”从位置2开始的4个字符 

str.replace(0, 3, 8, 'c')            删除从0开始的3个字符，然后在0处插入8个字符c 

对于插入，将replace改为insert，并将前两个参数改为1个，即插入的位置即可

 

str.find('i', 0)          从第0个字符开始查找字符'i'并返回其下标，找不到返回-1

str.find("name", k)       从第k个字符开始查找字符串"name"并返回其下标，找不到返回-1

str.rfind("name", string::npos)  反向查找字符串"name"并返回其下标，找不到返回-1

 

reverse(str.begin(), str.end())  翻转字符串

stack 栈类  头文件<stack>

定义     先进来后出去

stack<type>sta

sta.empty()  查看是否为空范例,是的话返回1,不是返回0

sta.push(i)  在栈的最前面增加元素i(栈的大小不预设)

sta.pop()    清除第一个元素

sta.top()    显示第一个元素      例如n = k.top();

sta.size()   输出现有元素的个数