STL整理

vector/string

#include <algorithm>
#include <iostream>
#include <vector>
#include <unordered_set>
#include <set>
#include <string>
using namespace std;
int main(){
    vector<int> vi;
    for(int i=1;i<=5;i++){
        vi.push_back(i);
    }
    vector<int>::iterator it = vi.begin();
    //取首元素地址
    //在STL中使用的和位置有关的返回的都是对应位置的迭代器
    for(int i=0;i<5;i++){
        cout<<*(it+i)<<endl;
    }
    set<int> si;
    si.insert(1);
    si.insert(5);
    si.insert(3);
    for(set<int>::iterator it=si.begin();it!=si.end();it++){
        //这里使用si.end()!=it
        //不能比较><啥的
        cout<<*it<<" ";
    }
    cout<<endl;
    //会是按照顺序输出的
    /*
     string 常用部分
     （1）遍历访问
     （2）常用函数解析
     */
    string str;
    string str1 = "abcd";
    /*
     （1）通过下标访问，一般的string通过这种方法即可
     （2）通过迭代器访问，一些函数的参数需要iterator类型
      (3)和vector一样支持直接使用iterator加减某个数字
     */
    for(int i=0;i<str1.size();i++){
        cout<<str1[i]<<" ";
    }
    //可以直接像字符数组那样去访问
    //使用c_str()进行字符串和字符数组的转化,使用printf输出
    printf("%s",str1.c_str());
    cout<<endl;
    string::iterator its ;
    for(its = str1.begin();its!=str1.end();its++){
        printf("%c",*its);
    }
    cout<<endl;
    /*
     （1）operator+= 将两个string拼接起来
     （2）compare operator
     （3）length()/size()
     （4）insert()
     （5）erase()
     （6）clear() 清除
     （7）substr()
     （8）string::npos
     （9）find()
     （10）replace()
     */
    /*
     operator+=/+
     */
    string str2 ="efgh";
    str2 += str1;
    string str3 = str1+str2;
    cout<<str2<<" "<<str3<<endl;
    /*
     compare operator > < == != >= <=
     字典序
     */
    string s1="a";
    string s2 = "aa";
    string s3 = "abc";
    string s4 = "xyz";
    if(s1<s2) cout<<"ok"<<endl;
    if(s2<s3) cout<<"ok"<<endl;
    /*
     length/size
     */
    cout<<str2.length()<<" "<<str2.size()<<endl;
    /*
     insert(pos,string);//在pos位置插入字符串string
     insert(it,it2,it3);//it是插入位置，it2和it3是待插入字符的首尾迭代器，包含it2，不包括it3
     */
    /*
     erase(it);//it为相应位置的迭代器
     erase(first,end);//first和end也是迭代器
     erase(pos,length);//pos是起始位置，length是删除字符个数
     */
    /*
     substr(pos,len);返回从pos开始长度为len的子串
     */
    cout<<str2.substr(2,2)<<endl;
    /*
     string::npos是一个常数，本身的值为-1.是unsigned_int类型，认为是unsigned_int类型的最大值
     string::npos用以作为find函数失败时的返回值
     */
    if(string::npos==-1)
        cout<<"-1 is true!"<<endl;
    if(string::npos==4294967295)//这个不是了？
        cout<<"also true"<<endl;
    /*
     str1.find(str2);//返回和str2匹配上的第一个位置
     str.find(str2,pos);//从pos开始匹配str2
     */
    cout<<str2.find("gh")<<endl;//返回的不是迭代器
    /*
     replace(pos,len,str2);//从pos开始替换为len长的str2
     replace(it1,it2,it3);//使用iterator
     */
    str2.replace(2, 3, "aaa");
    cout<<str2<<endl;
    
    return 0;
}

map

 /*
     1.map的定义：如果要使用字符串必须用string，不能用char数组
     */
    map<string, int> mp;
    map<set<int>,int> mp1;//也可以是其他STL容器到其他类型
    /*
     2.map容器内的元素访问
     两种访问方式：
     （1）直接使用mp[key]访问
     （2）通过迭代器访问map<typename1,typename2>::iterator it;
     map的每一对映射都有两个typename，必须使用一个it同时访问key和value
     it->first 访问key
     it->second 访问value
     map会按照键的从小到大进行排序（内部红黑树）
     */
    mp["java"]=20;
    mp["c++"]=30;
    map<string,int>::iterator it;
    for(it=mp.begin();it!=mp.end();it++){
        cout<<it->first<<" "<<it->second<<endl;
    }
    /*
     常用的函数
     (1)find(key); return iterator O(logN)
     (2)erase(it); it=iterator  O(1)
        erase(key); 删除对应key的整条记录 O(logN)
        erase(first,last); first->the start iterator / last->the end iterator
     (3)size();O(1)
     (4)clear();O(N)
     */
    /*
     map常见用途：
     (1)建立字符/字符串与整数之间映射的题目，使用map可以减少代码量
     (2)判断大整数或其他类型数据是否存在的题目，可以把map当bool数组使用
     (3)字符串和字符串的映射也可能遇到
     */
    /*
     一个key对应多个value-> multimap
     散列代替map内部红黑树实现,只映射不排列->unordered_map
     */

queue

 /*
     1.定义
     */
    queue<int> q;
    /*
     2. queue容器内元素的访问
     front()访问队头元素
     back()访问队尾元素
     */
    /*
     3. 常用函数解析
     (1)push()
     (2)front()/back()
     (3)pop()
     (4)empty()判断是否为空
     (5)size()判断队列大小
     */
    /*
     4. 应用
     当进行广度优先遍历的时候不用自己实现队列
     在使用front / back函数之前必须使用emoty判断队列是否为空
     */
    for(int i=1;i<=5;i++){
        q.push(i);
    }
    cout<<q.size()<<endl;

priority_queue

优先队列，内部是用堆实现的，在优先队列中，队首元素一定是当前队列中优先级最高的一个。
可以任何时候往队列中push元素，而优先队列底层的数据结构（heap）会随时调整结构，使得每次的队首元素都是优先级最大的。
设置优先级是关键

#include <queue>
#include <iostream>
using namespace std;
struct fruit{
    string name;
    int price;
    //需要对相应的运算符进行重载
    //重载大于号会编译错误，因为在数学上只需要重载小于号即可实现大于号存在的同样功能
    friend bool operator < (fruit f1,fruit f2){
        return f1.price <  f2.price;
    }
};
struct fruit1{
    string name;
    int price;
};
struct cmp{
    bool operator () (fruit1 f1,fruit1 f2){
        return f1.price>f2.price;
    }
                  
};
int main(){
    /*
      1. 定义
     */
    priority_queue<int>  q;
    /*
     2. 元素访问
     只能使用top()
     */
    q.push(1);
    q.push(3);
    q.push(10);
    q.push(7);
    cout<<q.top()<<endl;
    /*
     3. 常用函数
     (1)push();
     (2)top();
     (3)pop();
     (4)empty();
     (5)size();
     */
    /*
     4. priority_queue内部优先级的设置
     (1)基本类型 数字的按照数值，字符按照字典序
     (2)结构体
     */
    priority_queue<int,vector<int>,less<int>> q1;
    //vector<int>用来填写底层数据结构heap的容器
    //less<int>是用来对第一个参数的比较类，less<int>表示数字大的优先，greater<int>表示数字小的优先
    //如果第一个参数是double或者char型不需要第三个参数
    priority_queue<fruit> fq;//这样直接定义就会按照里面对于运算符的重载来处理
   //也可以把重载部分写在结构体外面
    priority_queue<fruit1,vector<fruit1>,cmp> self_q;
    //其他基本数据类型或者其他STL容器都可以通过同样的方式来定义优先级
    /*
     5. 常见用途
     （1）可以解决一些贪心问题
     （2）对Dijkstra进行优化
     */
    return 0; 
}

//如果结构体内的数据较为庞大，建议使用饮用&来提高效率
friend bool operator < (const fruit& f1,const fruit& f2){
    return f1.price>f2.price;
}
bool operator () (const fruit&f1,const fruit&f2){
    return f1.price>f2.price;
}

stack

/*
     1. 定义
     */
    stack<int> st;
    /*
     2. 元素访问
     只能通过top来访问栈顶元素
     */
    for(int i=0;i<5;i++){
        st.push(i);
    }
    while(!st.empty())
    {cout<<st.top()<<endl;
        st.pop();}
    /*
     3. 相关函数
     (1)push();
     (2)top();
     (3)pop();
     (4)empty();
     (5)size();
     */
    /*
     4. 常见用途
     模拟一些递归，防止程序对内存的限制而导致程序出错
     */

pair

pair，当想要将两个元素绑在一起作为一个元素、又不想要因此定义结构时，使用pair可以很方便的作为替代

struct pair{
  typename1 first;
  typename2 second;
};

 /*
     1. 定义
     */
    pair<string, int> p;
    pair<string,int> p0("haha",1);//初始化
    //构建pair的两种方法
    pair<string,int>("haha",2);
    make_pair("haha", 2);
    /*
     2. pair中元素的访问
     按照正常的结构体的方式去访问即可
     */
    cout<<p0.first<<p0.second<<endl;
    /*
     3. 常用函数
     (1)比较操作数
      == >= <= != < >
     比较的标准是先以first的大小为标准，当first相等时再去比较second
     */
    /*
     4. 常见用途
     （1）用来代替二元体结构，可以节省编码时间
     （2）作为map的键值对来进行插入
     */
    map<string,int> mp;
    mp.insert(make_pair("hhaha", 4));
    mp.insert(pair<string,int>("haha1",5));
    

algorithm头文件下常用函数

max(<#const _Tp &__a#>, <#const _Tp &__b#>);
    min(<#const _Tp &__a#>, <#const _Tp &__b#>);
    abs(<#int#>);//浮点数用math下的fabs
    
    swap(x,y);
    reverse(it,it2);//参数是迭代器
    next_permutation(it, it2);//返回一个序列在全排列中的下一个序列
    //在已经到达全排列的最后一个时会返回false
    //注意使用do while还是while，while可能少一个输出
    int a[3]={1,2,3};
    do{
        cout<<a[0]<<a[1]<<a[2]<<endl;
    }while (next_permutation(a, a+3));
    
    fill(it, it2, value);//把数组或者容器中的某一区间赋为某个相同的值
    //和memset不同，这里的赋值可以是数组类型对应范围中的任意值
    fill(a,a+3,2333);
    
    sort(firstaddress,tailaddress+1,compare function);
    //实现比较函数cmp
    //(1)基本类型
    bool cmp(int a,int b){
        return a<b;//结果会按照从小到大排列
    }
    sort(a,a+3,cmp);
    //(2)结构体数组
    bool cmp(node a,node b){
        return a.x <  b.x;
    }
    bool cmp(node a,node b){
        if(a.x!=b.x) return a.x > b.x;
        else return a.y > b.y;
        }
    sort(ssd,ssd+3,cmp);
    //(3)容器的排序
    //在标准STL中只有vector\string\deque可以使用sort
    //set、map这种容器都是通过红黑树实现的，元素本身有序，不允许使用sort进行排序
    //在对vector进行排序的时候也可以直接使用cmp在sort函数中
    //string的排序默认按照字典序，如果想要改成按照字符串长度也可以
    bool cmp(string str1,string str2){
        return str1.length()<str2.length();
    }
    sort(str,str+2,cmp);
    
   upper_bound(first,last,val);//在[first,last)范围内寻找第一个值大于等于val元素的位置
   lower_bound(first,last,val);//找第一个大于val元素的位置