【C++容器STL】vector、stack、queue、string、map

vector

头文件：#include<vector>

1. 创建普通变量

vector<int> x(v[1]);                //用v[1]初始化
vector<int> y=v[2];                 //用v[2]初始化
vextor<string> sevc{"vb","vc"};     //字符串初始化

2. 指定数量的元素

vector<int> ivec(10,-1);             //10个int元素，每个都初始化为-1,若不指定-1则均初始化为0；
vector<string> svec(10,"hello") ;    //均已“hello”初始化

3. 创建二维数组

vector<vector<ing>> arr(2,vector<int>(5));     //相当于二维数组a[2][5];
vector<int> V[10];                             //表示10个容器

4. 迭代器，相当于指针

vector<int>::iterator it;        //it读写vector<int>中的元素
string::iterator st;             //读写string对象中的字符
vector<int>::const_iterator it2; //it2只能读元素，不能写元素
string::const_iterator it3;      //it3只能读字符，不能写字符

使用方法eg：

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<<" ";
}

5. 常用部分：

V.begin();                //开始
V.end();                  //结尾
V.push_back(1);           //将元素1压入
V.pop_back();             //删除容器最后一个元素
V.empty()                 //判断容器是否为空
V.size();                 //返回容器大小
V[3];                     //取第三个元素此种类型的下标只能获取已经存在的元素，若不存在只能用push_back()压入

6. 常用的初始化方式

(1).清空元素，但不回收空间:

V.clear();             

(2).使用erase循环删除，不回收空间

vector<int>::iterator it;
for(it=v.begin();it!=v.end();)
{
    //注意使用erase()方法时，迭代不要随意的++
    it = vecnum.erase(it); 
}

注：erase在每次操作时，迭代器指针会整体前移1，就是每次都会移动全部数据，所以vector不适合做频繁删除的容器
erase还有一种用法：iterator erase(iterator first,iterator last)即删除first和last之间的元素，返回值：指向删除元素（或范围）的下一个元素。
eg:vector v中保存的为{1，2，3，4，5，6，7，8},执行：

v.erase(v.begin(),v.begin()+5);
vector<int>::iterator it;
for(it=v.begin();it!=v.end();it++)
{
    cout<<*it<<endl;
}

得到结果:

(3).最简单的使用swap,清除元素并回收内存

// 写法一
vector<int>().swap(vecnum);
//写法二
vecnum.swap(vector<int>());

7. 其他一些不太常用的操作

//将a的现有元素个数调至10个，多则删，少则补，其值随机
a.resize(10);
//将a的现有元素个数调至10个，多则删，少则补，其值为2
a.resize(10,2);
//在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4
a.insert(a.begin()+1,5);
//在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5
a.insert(a.begin()+1,3,5);
//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
a.insert(a.begin()+1,b+3,b+6);
//b为向量，将b的0~2个元素构成的向量赋给a
a.assign(b.begin(), b.begin()+3);
//定义了a值为b中第0个到第2个（共3个）元素 初始化
vector<int>a(b.begin(),b.begin+3); 

//元素反转
reverse(v.begin(),v.end());

stack

头文件：#include<stack>

1. 常用部分

stack<int> S;           //定义
count=S.size();         //count为栈中元素数目
a=S.top();              //a为栈顶元素
S.pop();                //弹出栈顶元素
S.push(a);              //在栈顶增加元素
bool=S.empty();         //堆栈为空则返回真

queue

头文件：#include<queue>

1. 常用操作

queue<int> Q;
Q.push(1);               //1入队列
Q.pop();                 //返回队列第一个值  //只能直接弹出，不能带返回值
x=Q.front()                //可以获取队头元素即下一个即将弹出队列的元素
                         //结合起来 即若想弹出队列第一个元素并且带有返回值：
                         //x=Q.front();   Q.pop();
Q.back()                 //队尾元素
Q.size()                 //元素个数

附：优先队列可用作大顶堆or小顶堆，定义优先队列方式：

priority_queue<int> Q;                               //默认为大顶堆
priority_queue <int,vector<int>,greater<int> > q;    //升序队列，取出的为队列中最小的元素，相当于小顶堆
priority_queue <int,vector<int>,less<int> >q;        //降序队列，相当于大顶堆

//数据类型可以使用结构体
struct process{
    int id;
    int p;
    process(int a = 0, int b = 0) :id(a), p(b) {} //init
};
struct cmp {
    bool operator() (process p1, process p2) {
        if (p1.p == p2.p) {
            return p1.id > p2.id; //优先级相同则id小的在前
        }
        return p1.p < p2.p; //优先级大的在前
    }
};
//priority_queue<int> qi; //后两个参数缺省,优先队列就是大顶堆,队头元素最大
priority_queue<process, vector<process>, cmp> pq;

string

头文件：#include<string>

1.定义及初始化

string s1;                //默认构造函数，s1位空串
string s2(s1);            //将s2初始化为s1的一个副本
string s3("value");       //将s3初始化为一个字符串字面值副本
string s4(n,'c');         //将s4初始化为字符'c'的n个副本
string s(cp,n);           //创建一个string对象，它被初始化为cp所指向数组的前n个元素副本
string s(s2,pos2);        //创建一个string对象，它被初始化为一个已存在的string对象s2中从下标pos2开始的字符的副本如果pos2>s.size(),则该操作未定义
string s(s2,pos2,len2);   //创建一个string对象，它被初始化为s2中从下标pos2开始的len2个字符的副本如果pos2>s2.size(),则该操作未定义无论len2的值是多少，最多只能复制s2.size()-pos2个字符

2.string 读写
cin>>s;
a.读取并忽略开头所有的空白字符（如空格，换行符，制表符，进纸符）
b.读取字符直至再次遇到空白符，读取终止

3.string 对象操作

s.empty();                //如果s为空串，则返回true，否则返回false
s.size();                 //返回s 中字符的字符个数
s.push_back(ch);            //在字符串末尾添加字符ch
s.pop_back();               //弹出字符串末尾元素
s[n]                      //返回s中位置为n的字符，位置从0开始计数
s1+s2                     //把s1和s2链接成一个新的字符串，返回新生成的字符串！！！注意不能使用类似：`str+'A'` (string+字符）！！！
s1=s2;                    //把s1内容替换为s2的副本
v1==v2;                   //判断v1与v2的内容，相等则返回true，否则返回false
!=, <, <=, >, >=,+=   //保持这些操作的惯有含义

4.修改string对象
迭代器定义：string::iterator it

//关于迭代器
s.insert(p,t);                //在迭代器p指向的元素之前插入一个值为t的新元素。返回指向新插入元素的迭代器
s.insert(p,n,t);              //在迭代器p指向的元素之前插入n个值为t的新元素。返回void
s.insert(p,b,e);              //在迭代器p指向的元素之前插入b和e标记范围内所有的元素，返回void

s.assign(b,e);                //用迭代器b和e标记范围内的元素替换s。对于string类型，该操作返回s，对于容器类型，则返回void
s.assign(n,t);                //用值为t的n个副本替换s。对于string类型，该操作返回s，对于容器类型，返回void

s.erase(p);                   //删除迭代器p指向的元素，返回一个迭代器，指向被删除元素后面的元素
s.erase(b,e);                 //删除迭代器b和e标记范围内所有的元素，返回一个迭代器，指向被删除元素段后面的第一个元素

reverse(b,e);                 //把迭代器b和e标记范围内的所有元素反转

//关于使用数组下标
s.insert(pos,n,c);            //在下表pos的元素之前插入n个字符c
s.insert(pos,s2);             //在下标为pos的元素之前插入string对象s2的副本
s.insert(pos,s2,pos2,len);    //在下标为pos的元素之前插入s2中从下标pos2开始len个字符
s.insert(pos,cp,len);         //在下标为pos的元素之前插入cp所指向数组的前len个字符
s.insert(pos,cp);             //在下标为pos的元素之前插入cp所指向的以空字符结束的字符串副本

s.assign(s2);                 //用s2的副本替换s
s.assign(s2,pos2,len);        //用s2中从下标pos2开始的len个字符副本替换s
s.assign(cp,len);             //用cp所指向数组的前len个字符副本替换s
s.assign(cp);                 //用cp所指向的以空字符结束的字符串副本替换s

s.erase(pos,len);             //删除从下标为pos开始的len个字符

s.substr(pos, n);             //截取s中从pos开始（包括0）的n个字符的子串，并返回
s.substr(pos);                //截取s中从从pos开始（包括0）到末尾的所有字符的子串，并返回

5.可使用的char*与string之间的转换

//char* to string
char c[]="my name is w^2j";
string ss=c;
//string to char*
string str="I like bbh";
char* cs=&str[0];
//or
char* cs=const_cast<char*>(str.c_str());

map

头文件：#include<map>
map提供一对一的hash

1. 第一个可以称为关键字（key），每个关键字只能在map中出现一次；
2. 第二个可能称为该关键字的值（vale）；
3. 主要用于一对一映射的情况，即自动建立key-value的对应，map内部实现自建一颗红黑树，这棵树具有对数据自动排序的功能

1.构造map

map<int,string> mapStudent;

2.插入元素

//第一种，用insert插入pair,如果map中有这个关键字，则插入失败
mapStudent.insert(pair<int,string>(000,"WWJ"));

//第二种，用insert函数插入value_type数据，同一，如果已有关键字则插入失败
mapStudent.insert(map<int,string>::value_type(001,"ZZH"))

//第三种，用数组方式插入，如果原来就有则进行覆盖
mapStudent[2]="WWj";

3.查找元素

当查找的值存在时则返回数据所在对象的位置，如果不存在，则返回end()函数值;

map<int,string>::iterator it;
it=mapStudent.find("WWj");
if(it!=mapStudent.end())
{
    cout<<it->second<<endl;        //second
    cout<<it->first<<endl;         //key
else 
    cout<<"not found"<<endl;

4.删除元素

//一、迭代器删除
it=maoStudent.find("WWj");
mapStudent.erase(it);                //删除迭代器it指向的元素，返回值void
mapStudent.erase(it,it2);            //删除迭代器it和it2范围内的元素，返回void

//二、用关键字删除,删除成功返回1，否则返回0
int n=mapStudent.erase("WWj");

//三、用迭代器范围删除：把整个map清空eg
mapStudent.erase(mapStudent.begin(),mapStudent.end());
//或者
mapStudent.clear();

5.其他一些基本操作

int size=mapStudent.size();           //map大小
it=mapStudent.begin();                //返回指向map头部的迭代器
it=mapStudent.end();

其他一些函数

** 1.count/count_if**

//统计目标的个数
int num=count(vector1.begin(),vector2.begin(),target);   //注意不是vector的类函数
//统计符合条件目标的个数
bool comp(int num)
{
    return 6>num;
}

int num=count_if(vector2.begin(),vector2.begin(),comp);      //统计容器中小于6的数的个数