C++标准模板库STL自学【PAT准备二】

内容简介

因为要参加2020年六月份的PAT考试，所以打算重新复习C++，在CSDN上做了笔记，需要的朋友可以来一起进步——
（注：本文持续更新）
【这一部分学完之后应该马上配套练习晴神宝典上机册的对应章节练习】

我的邮箱： [email protected]

使用教材

晴神宝典（算法笔记）

算法笔记pdf版本资源： https://pan.baidu.com/s/1WtrX-uvKQ-UwmK7dViP3vg
提 取 码: u3gk

含上机，需要的朋友请自提

内容一览

1. vector
2. set
3. string
4. map
5. queue
6. priority_queue
7. stack
8. pair
9. algorithm
10. lower_bound()和upper_bound()

正文

1.vector

1.1定义

即“变长数组”：长度根据需要自动改变的数组，它的主要用途：
①用以解决普通数组超内存的情况；
②vector可以用邻接表的方式存储图。

1.2 vector的头文件：

#include <vector>
using namespace std;

1.3 vector常见用法

1.3.1 定义一个变长数组

vector <typename> name;    //单独定义一个vector

①意思是：定义一个变长数组，名字叫做name。在typename 的部分，里面可以是任何基本类型，比如int ,double,char ,结构体等等。如：

vector <int> a;     //定义一个变长整形数组a

②用vector套vector：实现一个双维度长度都在变化的数组

vector <vector<int> > name;

③vector vi [100] //vector数组，vi中的每一个元素都是vector容器

1.3.2 vector容器内元素的访问

像正常数组一样访问就可以了，比如：

vector <int>  name;
name[20]= 6;

1.4vector常用函数

1.4.1 push_back()
在vector后面添加一个元素x

vector <int > vi;
vi.push_back(3);//向这个变长数组的后面插入一个元素3

1.4.2 pop_back()
删除vector的队尾元素

vector <int> vi;
vi.pop_back(); //删除队尾元素

1.4.3 size()
获得变长数组vector的长度

int len=vi.size();

1.4.4 clear()
用以清空vector中的所有元素

vi.clear()

1.4.5 insert( it, x)
用以向vector的任意迭代器 it 处插入一个元素 x（任意迭代器是一个指针）

vector <int> vi;
vi.insert(vi.begin()+2,-1);  //向变长数组的第二个元素后面插入一个元素 -1

**注意：*所有STL容器中只有vector和string允许使用(it+1)的写法来控制迭代器，其它所有容器都必须自行迭代。

for ( it=st.begin();it!=st.end();it++)
{
    
    
}

1.4.6 erase()
①删除单个元素 erase(it);

vi.erase(vi.begin()+3);

②删除一个区间内的所有元素 erase (first,end)

vi.erase(vi.begin()+1,vi.begin()+4);

2.set

集合，内部自动有序且去重的集合。

2.1 set的头文件

#include <set>
using namespace std;

2.2 set的定义

set <typename> name;
例子：set <int> a;   //设置一个名为a的整形集合

2.3 set的数组

set <int> a[100];   //设定一百个set

2.4 set内元素访问
先为set设定指针：set ::iterator it; //指针名为it，可以通过*it来访问集合中的元素(只能迭代访问）

for (it=st.begin(); it!=st.end();it++)
{
    
    }

2.5 set常用函数
2.5.1 插入函数insert()

#include <stdio.h>
#include <set>
using namespace std;

int main()
{
    
    
         set<int > st;
         st.insert(3);   //定义一个名为st的集合，并向其中插入元素3
}

2.5.2 查找函数find()
find(x)返回set中对应置为value的迭代器（指针）。

set<int>::iterator it =st.find(2);   //在集合中查找2这个元素，并返回其迭代器

2.5.3 删除单个元素或者删除某个区间的元素 erase()

删除单个元素

st.erase(it);   //括号里是迭代器
st.erase(st.find(100));//利用find函数找到100，然后删除它

删除单个元素

st.erase(value);  //value为要删除元素的值

删除一个区间内的元素

st.erase(first ,last);   
st.erase(it,st.end());   //删除it所指代的元素直到set的末尾

2.5.4 clear() 用以清空集合中的所有元素

st.clear()   //清空set

3.string

字符串操作合集

3.1 string的定义

string str;
string str="abcd" ;  //初始化

3.2 string的头文件以及string中元素的访问方式

#include <stdio.h>
#include<string.h>   //头文件
using namespace std;

int main()
{
    
    
      string str="abcd";
       for(int i=0;i<str.length();i++)    //使用length函数统计字符串的长度
       {
    
    
       printf("%c",str[i]);    //直接用下标访问
       }
}

3.3 通过迭代器访问

string::iterator it;
for(it=str.begin();it!=str.end();it++)
{
    
    
      printf("%c",*it)
      }

3.3 string的常用函数

3.3.1 拼接两个字符串operator+=

str3=str2+str1;   //将后两个字符串拼接，赋值给3
str1+=str2;  //将str2直接拼接到str1上

3.3.2 比较两个字符串（字典序比较）

if(str1>str2){
    
    }
if(str1!=str2){
    
    }
if(str1>=str3){
    
    }

3.3.3 计算字符串的长度和大小

int len= str.length();
int len2= str.size();

3.3.4 向字符串中插入

str.insert(3,str2);    //在str[3]的位置插入str2
str.insert(str.begin() +3,str2.begin(),str2.end());  //在 str的三号位之间插入str2的第二种写法

3.3.5 删除字符串中的元素

str.erase(it);       //删除单个元素
str.erase(first,last) ;      //删除一个区间的元素，其中first和last都是迭代器
str.erase(pos,length);   /*删除一个区间的元素，其中pos为要删除的起始位置，length是要删除的元素个数，它们都是整形*/

3.3.6 清空字符串

str.clear();//清空字符串

3.3.7 返回子串

str.substr(pos,len)  ;    //从第pos位开始，返回长度为len的字串

3.3.7 字符串的边界值 ?

string::npos是一个常数，其本身的值为-1，可以用作find失配时的返回值。

if(string ::npos  ==-1)

3.3.8 KMP，查找一个子串第一次在母串中出现的位置find()

if(str.find(str2)!=string::npos)   //在str中找到了str2
{
    
    
	int i;
	i=str.find(str2);   //返回值是一个int 值，是子串第一次出现的位置
}

3.3.9 子串替换

str.replace(pos,len,str2);   //在str中，从第pos个位置开始，将长为len的子串替换为str2

4.map

map是映射类型，能将任意一个类型映射到任意一个类型。map在建立映射的时候会自动排序

4.1头文件

#include <map>
using namespace std;

4.2 map的定义

map <string,int> mp;   //将string映射为int的map，命名为mp

4.3 map的访问

map <char ,int> mp;
mp['c'] =20;

4.4 map的常用函数

4.4.1 查找map中的元素find()

map<char ,int>::interator it =mp.find('b');

4.4.2 删除单个元素

mp.erase（it）;   //it是迭代器
mp.erase(key);    //key是想要删除的元素的键值
mp.erase('b');
mp.erase(first,last);  //删除这两个迭代器之间夹着的所有元素

4.4.3 测量map的大小

map<char,int> mp;
int length = mp.size();

4.4.4 清空map

mp.clear();

5.队列Queue

先进先出的容器

5.1头文件

#include <queue>
using namespace std;

queue <int > a;   //建立一个命名为a的整形队列

5.2元素访问

queue <int > q;
q.push(i);      //将i压入队列
int j= q.front();   //访问队首元素
int j2=q.back();  //访问队尾元素

5.3 常用函数

5.3.1 入队出队

queue <int > q;
q.push(i);
int i = q.pop();

5.3.2 检测队伍是否为空

if(q.empty() ==true)
{
    
    
     printf("队列为空。");
}

5.3.3 查看队列大小

queue <int > q;
int length = q.size();

6.priority_queue

优先队列，队首元素永远是当前队列中优先级最高的那一个，即按优先级出队。每次一个新的元素入队之后，会根据优先级被选择位置，然后入队。

6.1 定义

priority_queue<int> a;   //设定一个优先级队列a

6.2 元素访问
不同于队列，优先队列中没有front()和back（）这两个访问队首队尾的函数，只能通过top()来访问队首元素，即优先级最高的函数。

#include <queue>  //优先队列的头文件也是queue
using namespace std;

int main()
{
    
    
	priority_queue<int> q;
	q.push(3);   //将元素3压入队列
	q.push(4);
	int i = q.top(); //用元素i来获取队首元素的值
}

6.3 常用函数
6.3.1 push（）压入队列

priority_queue <int > q;
q.push(2);

6.3.2 top() 获取队首元素
使用方式见6.2

6.3.3 pop() 弹出队首元素

q.pop();

6.3.4 empty() 检查队列是否为空

if(q.empty()==true)
{
    
    
       printf("\n\n\t队列为空。"）;
}

6.3.5 size() 返回优先队列内元素的个数

int len = q.size();

6.3.6 优先级设置
如果存储的数字，则优先队列总是把数字较大的元素设置为高优先级；如果是字符串，则将字典序较大的设置为高优先级。（这是默认设置）

priority_queue <int ,vector<int>,greater<int>> q;//这样设置的就是小的元素在前的优先级队列

7.stack

堆栈。

7.1 头文件

#include <stdio.h>
#include <stack.h>
using namespace std;

7.2 元素的访问

stack <int> st;
for(int i=0;i<5;i++)
{
    
    
	st.push();//向栈中压入元素
}
printf("%d",st.top());   //top()取栈顶元素

7.3 常用函数
7.3.1 push(); st.push(x); //向栈st中压入一个元素x
7.3.2 top(); int x=st.top(); //从栈st中取出栈顶元素并存入x
7.3.3 pop(); st.pop();//弹出栈顶元素
7.3.4 empty();判断栈是否为空 if(st.empty()==true)
7.3.5 size(); int len = st.size(); //获取栈的大小

8.Pair

用以捆绑两个变量（相当于一个只有两个元素的结构体），而且这两个变量的类型可以指定。

#include <stdio.h>
#include <utility>
using namespace std;
pair <string,int> p;  //定义一个pair,里面第一个元素为string型，第二个为int

8.1 初始化

pair <string,int>  p("haha",5);

8.2 元素的访问

pair <string,int> p;
p.first="haha";
p.second = 5;

8.3 两个pair的相互比较
pair 可以直接做比，先比较第一个元素，再比较第二个

pair<int ,int > p1(5,10);
pair<int ,int >p2 (5,15);
if(p1>p2)  
{
    
    
    return true;
    }

9.Algorithm

9.1 max(),min(),abs()
头文件

#include <stdio.h>
#include <algorithm>
using namespace std;

int k = max(x,y); //返回最大值
int k =min(x,y) //返回最小值
int k =abs(x); //返回绝对值，且x必须是整数
int k =fabs(x); //返回绝对值，且x为浮点数

9.2 swap(x,y) 交换函数

交换x和y两个数的值，void型函数，无返回值

9.3 reverse() 倒置函数
reverse(it,it2) //将从it指代的数据到it2指代的数据倒置（逆序）

int a[10];
reverse(a,a+4);

9.4 next_permutation()
给出一个序列在全排列中的下一个序列
比如当n=3时，全排列为：123,132,213,231,312,321
所以231的下一个序列就是312

int a[3]={
    
    1,2,3};
do{
    
    
     printf("%d%d%d\n",a[0],a[1],a[2]);
     }while  (next_permutation(a,a+3);

9.5 fill() 填充函数
把数组或容器中的某一段区间赋为某个相同的值。

int a[5]={
    
    1,2,3,4,5};
fill(a,a+5,233);   //将a[0]~a[5]赋值为233

9.6 sort() 排序函数（从小到大）

#include <stdio.h>
#include <algorithm>
using namespace std;

int a[6]={
    
    9,4,2,5,6,-1};
sort(a,a+4);  //将a[0]到a[4]全部排序

9.7 lower_bound() 和upper_bound()
需要用在一个有序数组中，
lower_bound()用来寻找在数组或容器的(First,Last)范围内第一个值大于等于val元素的位置，如果是数组，则返回该位置的指针；如果是容器，则返回该位置的迭代器；
upper_bound()用来寻找在数组或容器的(First,Last)范围内第一个值大于val元素的位置。