STL大法使用详解

STL大法

vector, 变长数组，倍增的思想
    size()  返回元素个数
    empty()  返回是否为空
    clear()  清空
    erase()  删除
    front()/back()
    push_back()/pop_back()
    begin()/end()
    sort()
    支持比较运算，按字典序

pair<int, int>
    first, 第一个元素
    second, 第二个元素
    支持比较运算，以first为第一关键字，以second为第二关键字（字典序）

string，字符串
    size()/length()  返回字符串长度
    empty()
    clear()
    erase()
    find()
    replace()
    substr(起始下标，(子串长度))  返回子串

queue, 队列
    size()
    empty()
    push()  向队尾插入一个元素
    front()  返回队头元素
    back()  返回队尾元素
    pop()  弹出队头元素

priority_queue, 优先队列，默认是大根堆
    size()
    empty()
    push()  插入一个元素
    top()  返回堆顶元素
    pop()  弹出堆顶元素
    定义成小根堆的方式：priority_queue<int, vector<int>, greater<int>> q;

stack, 栈
    size()
    empty()
    push()  向栈顶插入一个元素
    top()  返回栈顶元素
    pop()  弹出栈顶元素

deque, 双端队列
    size()
    empty()
    clear()
    front()/back()
    push_back()/pop_back()
    push_front()/pop_front()
    begin()/end()
    []

set, map, multiset, multimap, 基于平衡二叉树（红黑树），动态维护有序序列
    size()
    empty()
    clear()
    begin()/end()
    ++, -- 返回前驱和后继，时间复杂度 O(logn)

    set/multiset
        insert()  插入一个数
        find()  查找一个数
        count()  返回某一个数的个数
        erase()
            (1) 输入是一个数x，删除所有x   O(k + logn)
            (2) 输入一个迭代器，删除这个迭代器
        lower_bound()/upper_bound()
            lower_bound(x)  返回大于等于x的最小的数的迭代器
            upper_bound(x)  返回大于x的最小的数的迭代器
    map/multimap
        insert()  插入的数是一个pair
        erase()  输入的参数是pair或者迭代器
        find()
        []  注意multimap不支持此操作。 时间复杂度是 O(logn)
        lower_bound()/upper_bound()

unordered_set, unordered_map, unordered_multiset, unordered_multimap, 哈希表
    和上面类似，增删改查的时间复杂度是 O(1)
    不支持 lower_bound()/upper_bound()， 迭代器的++，--

bitset, 圧位
    bitset<10000> s;
    ~, &, |, ^
    >>, <<
    ==, !=
    []

    count()  返回有多少个1

    any()  判断是否至少有一个1
    none()  判断是否全为0

    set()  把所有位置成1
    set(k, v)  将第k位变成v
    reset()  把所有位变成0
    flip()  等价于~
    flip(k) 把第k位取反

string

1.数组访问

for(int i=0;i<str.length()/str.size();i++){
	cout<<str[i];
}

4.实例应用:
1.operator+=:string加法,可以将两个string连接起来;
str3=str1+str2;
2.compare operator:比较字典序;

    cout << a + b << endl;//连接
    if(a<b) cout<<a;//比较

6.str.clear();清空字符串
7.str.substr(pos,len);返回从pos号位开始,长度为len的子串

string a;
cin >> a;
cout << a.substr(1, 5);//左闭右闭

8.string::nops 是unsigned_int型本身值为-1/4294967295作为find函数失配时的返回值
9.str.find(str2),当str2是str的子串时,返回其在str中第一次出现的位置,如果不是则返回string::npos
str.find(str2,pos).从str的pos号位开始匹配str2,返回值与上式相同

string a, b;
cin >> a >> b;
if(a.find(b)!=string::npos){
    cout << a.find(b) << endl;
}
if(a.find(b,3)!=-1){//包括3的这一位
    cout << a.find(b,3) << endl;
}

10.str.replace(pos,len,str2)把str从pos号位开始,长度为len的子串替换为str2
str.replace(it1,it2,str2)把str的迭代器[it1,it2)范围的子串替换为str2

string a = "maybe you will turn around.";
string b = "will not";
string c = "surely";
cout << a.replace(10, 4, b) << endl;
cout << a.replace(a.begin(), a.begin() + 5, c) << endl;

11.erase():删除若干字符

string s = "hello,word!";
string s1 = s.erase(6);//删除下标为6的字符开始的所有字符
string ss2 = s.erase(1,2);	//删除下标为2的字符开始的2个字符

12.string中的sort使用

sort(s.begin(),s.end());

常见字符串处理:

string对象中字符的处理（头文件cctype）
    isalnum(c)  如果c是字母或数字，返回 true
    isalpha(c)  如果c是字母，返回true
    islower(c)  如果c是小写字母，则为true
    isupper(c)  如果c是大写字符，则为true
    tolower(c) 如果c是大写字符，则返回其小写字母，否则直接返回c
	toupper(c)  跟tolower相反

pair

1.定义:

#include <utility>
pair<typename1,typename2>name;
初始化:

pair<string,int>p("haha,5");
2.临时构建:

p=pair<string,int>("hhaa",5);
p=make_pair("xixi",4);

vector

vector<typename>name;
vector<vector<typename>name;//嵌套
vector<vector<typename>name(n,vector<int >(n,0));//建立一个n行m列的二维数组
//可以省略列和初始化
vector<vector<int> > viA(10);

vector 排序 :

//二维对每一列第一个大小进行排序
bool cmp1(const vector<int> &a, const vector<int> &b)
{
	return a[0] > b[0];
}
for (int i = 0; i < 10; i++)
{
	sort(viA[i].begin(), viA[i].end());//默认为从小到大排序
}

#include<stdio.h>
#include<algorithm>
#include<vector>
#include<stdlib.h>
#include<iostream>
using namespace std;
bool cmp1(vector<int> a, vector<int> b)
{
	return a[0] < b[0];
}
int main()
{
	vector<vector<int> > viA(10);
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			viA[i].push_back(rand() % 100);
		}
	}
	
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << viA[i][j] << "\t";
		}
		cout << endl;
	}
	cout << "按行列排序后的输出" << endl;
 
 	for (int i = 0; i < 10; i++)
	{
		sort(viA[i].begin(), viA[i].end());//默认为从小到大排序
	}
	sort(viA.begin(), viA.end(), cmp1);
	
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << viA[i][j] << "\t";
		}
		cout << endl;
	}

    return 0;
}

vector对pair对的排序

#include <bits/stdc++.h>

using namespace std;

bool judge(pair<int,char> a, pair<int ,char> b) {
    return a.first<b.first;
}

int main(){
    vector<pair<int ,char> > p;
    p.push_back(make_pair(10,'a'));
    p.push_back(make_pair(9,'c'));
    p.push_back(make_pair(10,'t'));
    p.push_back(make_pair(17,'y'));
    p.push_back(make_pair(10,'b'));
    sort(p.begin(),p.end(),judge);
    for(int i=0;i<p.size();i++)
        cout<<p[i].first<<"    "<<p[i].second<<endl;
    return 0;
}

删除单个元素和删除区间个元素

#include<iostream>
#include<vector> 
using namespace std;

int main(){
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(1);
    v.push_back(4);
    v.push_back(5);
    vector<int>::iterator it = v.begin();
    while(it != v.end()){    
        if (2 == *it)
            v.erase(it);
        else
            ++it;
    }
    it = v.begin();
    while(it != v.end()){
        cout << *it << endl;
        it++;
    }
    
    v.erase(v.begin()+1,v.begin()+4);//左闭右开
    for(auto it : v){
        cout << it << endl;
    }//结果 1 4 5
    return 0;
}

set

1.定义:set翻译为集合,是一个内部自动有序且不含重复元素的容器

set<typename>name
set<node>name//结构体

**3.**插入元素insert函数

st.insert(i)插入set容器,并且递增排序和去重

4.find函数

find(value)返回set中对应值为value的迭代器
set<int>::iterator it = st.find(2);在set中查找2,返回其迭代器
作用为在st中查找相应元素,然后返回相应元素的值

#include <iostream>
#include <set>
using namespace std;
int main(){
        set<int> st;
        int a, b;
        for (int i = 1; i <= 10;++i){
            cin >> a;
            st.insert(a);
        }
        cin >> b;
        set<int>::iterator it = st.find(b);
        cout << *it << endl;
        st.erase(it, st.end());
        for(set<int>::iterator it=st.begin();it!=st.end();it++){
	        cout<< *it <<" ";
        }    
    return 0;
}

5.erase()删除元素

st.erase(it)  st.erase(st.find(100));找到100然后删去
st.erase(100)直接删去100
set<int>::iterator it = st.find(2);
set<int>::iterator it1 = st.find(4);
st.erase(it,st.end());删除区间
st.erase(it,it1);

6.st.size()返回个数
7.st.clear()

map

1.定义:

map翻译为映射,把任何结构类型映射为其他类型

2,作用:

如果需要判断一个数是否出现过,可以通过bool数组进行标记,但是如果这些数字很大,那么这个数组就会开不了,这时就可以使用map
例如把这些数看成字符串,然后建立string 与 int 型的映射
如果是字符串的映射,那么必须使用string 而不能使用char
头文件#include <map>
map<typename1,typename2>mp;前者为键,后者为值
map<set<int>,string>mp;

3.访问:

通过下标访问,通过迭代器
mp['c']=28;
map<typename,typename>::iterator it;
map会以键的大小进行从小到大的自动排序

4,功能:

mp.find(key)返回键为key的映射的迭代器
用关键字查找，成功返回对应关键字的迭代器，失败返回mp.end()
map<int,char>mp;
mp[1]='a';
mp[3]='b';
map<int, char>::iterator it = mp.find(3);
auto it = mp.find(3);
cout << it->second;

5.mp.erase();

mp.erase(it);删除一个元素
map<int, char>::iterator it = mp.find(3);
mp.erase(it);
mp.erase(3);删除键为3的映射
map<int, char>::iterator it1 = mp.find(3);
map<int, char>::iterator it2 = mp.find(5);
mp.erase(it1,it2)//左闭右开

6.auto.map

for(auto it : q){
        if(it.second != 0){
            cout << it.first << ":" << it.second << endl;
            it.second = 0;
        }
    }

cctype

函数名称   返回值
isalnum()  如果参数是字母数字，即字母或者数字，函数返回true
isalpha()  如果参数是字母，函数返回true
iscntrl()  如果参数是控制字符，函数返回true
isdigit()  如果参数是数字（0－9），函数返回true
isgraph()  如果参数是除空格之外的打印字符，函数返回true
islower()  如果参数是小写字母，函数返回true
isprint()  如果参数是打印字符（包括空格），函数返回true
ispunct()  如果参数是标点符号，函数返回true
isspace()  如果参数是标准空白字符，如空格、换行符、水平或垂直制表符，函数返回true
isupper()  如果参数是大写字母，函数返回true
isxdigit() 如果参数是十六进制数字，即0－9、a－f、A－F，函数返回true

tolower()  如果参数是大写字符，返回其小写，否则返回该参数
toupper()  如果参数是小写字符，返回其大写，否则返回该参数

priority_queue

1.基本定义

priority_queue<int>q;
priority_queue<int,vector<int>,less<int> >q;
如果第一个元素是char double,则把vector中元素变为对应类型
less<int>则是对第一个参数的比较类,,less<int>表示数字越大优先级越高,greater<int>表示数字小的优先级大

2.结构体的优先级设置

struct fruit{
	string name;
	int price;
}

结构体重载队列使结构体中某一变量按从大到小或者从小到大的顺序从队列出队
#include <queue>

friend bool operator<(node n1,node n2)
                return n1.elem>n2.elem;
priority_queue<node>q;//其中node为结构体名称，q为优先队列名称
//意思是如果a.times > b.times成立，那么结构体point a < point b成立。由于优先队列是按照从大到小排列，
//所以结构体b会排列到a之前，然而b.times是最小的，所以实现了按照times的从小到大排序
struct point{    
    int x, y,times;  
    friend bool operator < (point a, point b)    
    {    
        return a.times > b.times;    //重载小于号使得小的先出队列    
    }    
};    
重载小于号即是:如果a>b,但是结构体a在b后面,说明b的优先级高,则是小的优先级高
==**下面大于,则小的优先级高**==
==**下面小于,则大的优先级高**==
与sort函数的cmp相反
    struct node {
    int x,y;
}a[maxn];
bool cmp(node w,node q)
{
    return w.y<q.y;
}