c++刷题函数

# 数学函数   要导入 \#include <cmath> 

~~~c++
#include <cmath> 
求绝对值 abs( int/float/double a)                 求a的绝对值     
求平方根sqrt(int/float/double/a)                求a的平方根
求指数pow(2,3)                 2的3次方
向下取整floor(double/float a)   int(a)
向上取整ceil()
atoi(string s)                      stoi(string s)        将一串字符转换为int型
atof(string s)                       同上，转换为double型
to_string(int/long/float/double s)    将数字值转化为字符串
max(int a, int b)                    取最大值
min(int a, int b)                取最小值
swap(int/double/float/string a,int/double/float/string b)  交换ab的值
~~~

## 字符

char a[100]

~~~c++
strlen(a)          //求实际存储了多少个字符
 a[下标]             //求元素
isalnum(char c)     判断一个字符是不是alphanumeric，即大小写英文字母或是数字
memset(a,'7',5)      a的值为77777
isalpha( char c)    判断一个字符是不是alphabetic，即英文字母
isdigit(char c)                判断一个字符是不是数字
tolower(char c)                将大写转换为小写
toupper(char c)                将小写转换为大写
    
#字符串转化为字符数组
#方法一
char arr[50]; //数组大小根据s的大小确定
string s="1234";
int len=s.copy(arr,50);
arr[len]='\0';
cout<<arr;
方法2
char buf[10];
string str("ABCDEFG");
strcpy(buf, str.c_str());//strncpy(buf, str.c_str(), 10);
字符数组转化为string
char ch [] = "ABCDEFG";
string str(ch);//也可string str = ch;
或者
char ch [] = "ABCDEFG";
string str;
str = ch;//在原有基础上添加可以用str += ch;

~~~

## 整形数组

~~~c++
几个整型的全局变量
最大值                最小值 
LONG_MAX             LONG_MIN
INT_MAX              INT_MIN
LONG_LONG_MAX           LONG_LONG_MIN
~~~

int a[100]

~~~~c++
sort(a,a+n)
~~~~

## 字符串

string s1,s2;

~~~c++
s1.length()   // s1.size()  返回实际s中几个元素   每个元素的类型是char
s1<s2;   // 字典序比较要使用string变量，不能用字符串值（"123">"12"）
sort(s.begin(),s.end())    //执照字典顺序（ascii）排序
s.find('3')  s.find("ee")
    string a="12abcdef"
    if(a.find("abc")!=string::npos){
        cout<<"yes"   //找到
    }else{
        cout<<"no";    //找不到
    }

s.rbegin()
s.rend()
s.find('3',int i);   s.find("abc",int i)
________________________
    
    string a,b;
    a="abcd1efdcdf1";
    int sum=0;
    int i=0;
    while(a.find("cd",i)!=string::npos){
        sum++;
        i=a.find("cd",i)+1;
    }
 
___________________________
    
+表示字符串连接
to_string(int a)      利用a生成一个字符串
reverse(s.begin(),s.end())    将字符串倒置   "123"变成"321"
stoi(string s)      string类型字符串转换为int
stod(string s);     string类型字符串转换为double
to_string()     重载方法，将一些整形，浮点型等转换为string类型字符串
strcmp(char* str1, char* str2)    比较两个字符串，前一个小返回<0，前一个大返回>0，否则返回0
strcpy(char* destination, char* source)    将后一个字符串拷贝到前一个字符串
reverse(s.begin(),s.end());      //字符串左右翻转a="123"    a="321"
1.插入操作： 
str.insert(pos,str)；   str.insert(pos,str,len)；       //在下标pos处插入字符串str 
2.删除操作： str.erase(pos,length)                     //删除下标pos开始的长度为length的区间元素 
(1)// 删除单个元素 str.erase(iter);            //删除迭代器iter指定的元素 
(2) //删除区间元素：
① //str.erase(first_iter, last_iter)          //删除迭代器[first,second)之间的元素

------
    string s1="hello wollrld"
    删除s1中所有的ll子串
    while(s1.find("ll")!=string::npos){
        s1.erase(s1.find("ll"),2);
        cout<<s1<<endl;
    }
    运行结果：s1为 heo world
--------    
    
3.截取字符串： (取子符串连续的一部分,原字符串不受影响)
string newstr = str.substr(pos,length)；    //截取从下标pos开始的长度为length的子串 

4.查找操作： 
1)str.find(str2)；               //如果str2是str的子串，则返回str2在str中首次出现的位置；否则，返回string::npos，这个值是-1 
2)str.find(str2,pos)             //从str下标为pos的位置开始匹配sr2 

 5，替换 
        str.replace(开始位置，替换长度，替换字符串)
  ----
      string s1="hello wollrld";   //"
    string s2="ww";
    s1.replace(s1.rfind("ll"),4,s2);  
运行结果 s1为：hello wowwd
  ----
注意，如果我在字符串str="3.1415"中查询小数点出现的位置，应该写成 str.find(".") 而不是 str.find('.') ，后者查找的是char型字符，而不是string型，是没有这种写法的！

6.字符串转数字函数： 
stoi(string s)；          //如string str="123"，可以int val=stoi(str)；

7.string类型支持下标访问和迭代器访问，不过一般就用下标[]访问，和C的写法一样 。
另外，C++11之后，如果要完整遍历一个string，还可以用下面的写法。

8.数字转字符串函数：to_string(int/float/double);

~~~

## 排序

~~~c++
int a[100];
sort(a,a+n);
~~~

~~~c++
string s="2321";
sort(s.begin(),s.end());
~~~

~~~c++
vector<int> v;
sort(v.begin(),v.end())
vector<pair<int,int>> ve;
sort(ve.begin(),v.end(),cmp)
~~~

## stl

## vector

 这个是用的最多的，基本就拿来当数组来用。
vector是最简单也是最重要的一个容器。其头文件为vector
vector是数组的一种类表示，它有以下优点：
[1]自动管理内存、动态改变长度并随着元素的增减而增大或缩小。
[2]在尾部添加元素是固定时间，在头部或中间添加或删除元素是线性时间。 

~~~c++
基本操作
vector<int> a;         //声明
1.push_back   在数组的最后添加一个数据
2.pop_back    去掉数组的最后一个数据 
3.at                得到编号位置的数据
4.begin           得到数组头的指针
5.end             得到数组的最后一个单元+1的指针
6．front        得到数组头的引用
7.back            得到数组的最后一个单元的引用
8.max_size     得到vector最大可以是多大
9.capacity       当前vector分配的大小
10.size           当前使用数据的大小
11.resize         改变当前使用数据的大小，如果它比当前使用的大，者填充默认值
12.reserve      改变当前vecotr所分配空间的大小
13.erase         删除指针指向的数据项
14.clear          清空当前的vector
15.rbegin        将vector反转后的开始指针返回(其实就是原来的end-1)
16.rend          将vector反转构的结束指针返回(其实就是原来的begin-1)
17.empty        判断vector是否为空
18.swap         与另一个vector交换数据
注：
*a[n]和a.at(n)都返回一个指向容器中第n个元素的引用。
区别在于：如果n落在容器有效区间之外，a.at(n)将执行边界检查，并引发out_of_range异常。
*之所以vector没有push_front()，是因为vector执行此表达式复杂度为线性时间，而deque为固定时间。
    
~~~

~~~c++
int main(){
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(0);
    sort(v.begin(),v.end());
    for(vector<int>::iterator it=v.begin();it!=v.end();it++){
        cout<<*it<<endl;
    }
    for (auto iter = v.begin(); iter != v.end(); iter++) {
        cout << *iter << endl;
      }
      for (auto lin : v) {
           cout << lin<<endl;
     }
    for(int i=0;i<v.size();++i){
        cout << v[i] << " ";
    }
    for(int i=0;i<v.size();++i){
        cout << v[i].first << " "<<v[i].second<<endl;
    }    
      
    return 0;
}
~~~

| 1    | 2    | 0    |      |      |      |
| ---- | ---- | ---- | ---- | ---- | ---- |
| v[0] | v[1] | v[2] |      |      |      |

vector<pair<int,int>> sort

~~~c++
abc.txt
4
1 2 
3 1
4 5
1 1
#include<bits/stdc++.h>
using namespace std;
bool cmp(pair<int,int> a,pair<int,int> b){
    if(a.second<b.second||a.first==b.first&&a.second<b.second){
        return true;
    }else{
        return false;
    }
}
int main(){
    freopen("abc.txt","r",stdin);
    vector<pair<int,int>> v;
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        int a,b;
        cin>>a>>b;
        v.push_back(make_pair(a,b));
        //v.push_back(pair<int,int> (a,b));
    }
    sort(v.begin(),v.end(),cmp);

    for(vector<pair<int,int>>::iterator it=v.begin();it!=v.end();it++){
        cout<<it->first<<" "<<it->second<<endl;
    }

    for (auto iter = v.begin(); iter != v.end(); iter++) {
            cout<<iter->first<<" "<<iter->second<<endl;
    }

    return 0;
}
~~~

~~~c++
截取vector的一部分
vector<pair<int,int>> v;
v.push_back(make_pair(1,2));
v.push_back(make_pair(2,2));
v.push_back(make_pair(3,2));
v.push_back(make_pair(4,2));
vector<pair<int,int>> ve(v.begin(),v.begin()+1);      //(1,2)
cout<<ve.size();
cout<<"_________"<<endl;
map<int,int> m(v.begin(),v.end());
for(map<int,int>::iterator it=m.begin();it!=m.end();it++){
    cout<<it->first<<" "<<it->second<<endl;
}
~~~

|            (1,2)            |         (2,2)         | (3,2)  | (4,2)  |         |
| :-------------------------: | :-------------------: | :----: | :----: | :-----: |
|          v.begin()          |      v.begin()+1      |        |        | v.end() |
|         ve.begin()          | ve.begin()+1/ve.end() |        |        |         |
|            v[0]             |         v[1]          |  v[2]  |  v[3]  |         |
| v[0].first=1//v[0].second=2 |                       |        |        |         |
|           m[1]=2            |        m[2]=2         | m[3]=2 | m[4]=2 |         |
|          m.begin()          |                       |        |        | m.end() |

vector二数组

~~~c++
int main()
{
    vector<vector<int>> matrix;        //假设这是一个4*3的矩阵
    int row=4,col=3;
    matrix.resize(row);
    for(int i=0;i<matrix.size();i++)
        matrix[i].resize(col);
    //接下来就可以用下标运算访问了
    matrix[1][2]=233;
    matrix[0][0]=422;
    for(int i=0;i<matrix.size();i++){
        for(int j=0;j<matrix[i].size();j++){
            printf("%d ",matrix[i][j]);
        }
        printf("\n");
    }
    return 0;
}
~~~

## 【deque】双端队列（double ended queue）

## 头文件deque

在STL中deque类似vector，并且支持随机访问；
区别在于：
【1】从deque起始位置插入删除元素时间是固定的；
【2】为了实现在deque俩段执行插入和删除操作的时间为固定这一目的，deque对象设计比vector设计更为复杂一些。因此，在序列中部执行插入删除操作时，vector更快一些；

~~~c++
基本操作
deque<int> a;           //声明一个空队列
a.empty()               //判断队列是否为空，如果为空则返回 1，不为空则返回 0 
a.size()                //返回队列元素个数
a.front()               //返回指向队首元素的引用
a.back()                //返回指向队尾元素的引用
a.push_front()          //从队首插入
a.push_back()           //从队尾插入
a.push(t)               //队尾插入元素
a.pop()                 //删除队首元素
a[n]
a.at(t)
注：
pop() 是一个删除数据的方法，不是检索数据的方法！！！
如果要使用队列中的值，首先要使用 front() 来检索这个值，然后用 pop() 将他从队列中删除。
~~~

## 【stack】堆栈

头文件stack
stack是一个适配器，它给底层类（默认vector）提供典型栈接口；
stack不允许随机访问栈元素，不允许遍历栈，把使用限制在定义栈的基本操作上；
可以将值压入栈顶，从栈顶弹出元素，查看栈顶的值，检查元素数目，测试栈是否为空；

~~~c++
基本操作
stack<int> a;        //声明
a.empty()             //如果栈为空，返回true，否则返回false
a.size()             //返回栈中元素数目
a.top()                 //返回指向栈顶元素的引用
a.push(t)             //在栈顶插入x
a.pop()                 // 删除栈顶元素
注：
pop() 是一个删除数据的方法，不是检索数据的方法！！！
如果要使用栈顶的值，首先要使用 top() 来检索这个值，然后用 pop() 将他从栈顶删除。
~~~

## queue 队列

##  priority_queue 优先队列

priority_queue 容器适配器为了保证每次从队头移除的都是当前优先级最高的元素，每当有新元素进入，它都会根据既定的排序规则找到优先级最高的元素，并将其移动到队列的队头；同样，当 priority_queue

 从队头移除出一个元素之后，它也会再找到当前优先级最高的元素，并将其移动到队头。 

| 成员函数                       | 功能                                                         |
| ------------------------------ | ------------------------------------------------------------ |
| empty()                        | 如果 priority_queue 为空的话，返回 true；反之，返回 false。  |
| size()                         | 返回 priority_queue 中存储元素的个数。                       |
| top()                          | 返回 priority_queue 中第一个元素的引用形式。                 |
| push(const T& obj)             | 根据既定的排序规则，将元素 obj 的副本存储到 priority_queue 中适当的位置。 |
| push(T&& obj)                  | 根据既定的排序规则，将元素 obj 移动存储到 priority_queue 中适当的位置。 |
| emplace(Args&&... args)        | Args&&... args 表示构造一个存储类型的元素所需要的数据（对于类对象来说，可能需要多个数据构造出一个对象）。此函数的功能是根据既定的排序规则，在容器适配器适当的位置直接生成该新元素。 |
| pop()                          | 移除 priority_queue 容器适配器中第一个元素。                 |
| swap(priority_queue<T>& other) | 将两个 priority_queue 容器适配器中的元素进行互换，需要注意的是，进行互换的 2 个 priority_queue 容器适配器中存储的元素类型以及底层采用的基础容器类型，都必须相同。 |

~~~c++
#include <iostream>
#include <queue>
#include <array>
#include <functional>
using namespace std;
int main()
{
    //创建一个空的priority_queue容器适配器
    std::priority_queue<int>values;
    //使用 push() 成员函数向适配器中添加元素
    values.push(3);//{3}
    values.push(1);//{3,1}
    values.push(4);//{4,1,3}
    values.push(2);//{4,2,3,1}
    //遍历整个容器适配器
    while (!values.empty())
    {
        //输出第一个元素并移除。
        std::cout << values.top()<<" ";
        values.pop();//移除队头元素的同时，将剩余元素中优先级最大的移至队头
     }
    return 0;
}

~~~

运行结果：

~~~c++
4 3 2 1
~~~

## 【set】集合

 特点：
【1】储存同一类型的数据元素（这点和vector、queue等其他容器相同）；
【2】每个元素的值都唯一（没有重复的元素）；
【3】根据元素的值自动排列大小（有序性）；
【4】无法直接修改元素；
【5】高效的插入删除操作； 

~~~c++
基本操作
set<int> a;            //声明
a.begin();            //返回指向第一个元素的迭代器
a.end();              //返回指向超尾的迭代器
a.clear();            //清空容器a
a.empty();            //判断容器是否为空
a.size();             //返回当前容器元素个数
a.count(x);           //返回容器a中元素x的个数
a.insert(x);          //插入元素，其中a为set<T>型容器，x为T型变量
了解
a.insert(first,second);       //其中first为指向区间左侧的迭代器，second为指向右侧的迭代器。作用是将first到second区间内元素插入到a（左闭右开）。
a.erase(x)：删除建值为x的元素
a.erase(first,second)：删除first到second区间内的元素（左闭右开）
a.erase(iterator):删除迭代器指向的元素
注：set中的删除操作是不进行任何的错误检查的，比如定位器的是否合法等等，所以用的时候自己一定要注意。
lower_bound（x1）:返回第一个不小于键参数x1的元素的迭代器
upper_bound（x2）:返回最后一个大于键参数x2的元素的迭代器
由以上俩个函数，可以得到一个目标区间，即包含集合中从'x1'到'x2'的所有元素
set_union():对集合取并集
set_intersection():对集合取交集，它的接口与set_union()相同。
~~~

## 【map && unordered_map】映射

分别在头文件和<unordered_map>中，别混了。
这两个刷题时用的也非常多，其中map的底层实现是RB-Tree（红黑树），因此会根据键值自动进行排序，默认是字典序。而unordered_map的底层实现是哈希。因此，如果只是单纯的用来创建某种映射关系的话，推荐unordered_map，效率会高一些。

**map是一种key-value型容器，其中key是关键字，起到索引作用，而value就是其对应的值。与set不同的是它支持下标访问。头文件是map**

特点：
【1】增加和删除节点对迭代器的影响很小(高效的插入与删除)；
【2】快速的查找（同set）；
【3】自动建立key-value的对应，key和value可以是任何你需要的类型；
【4】可以根据key修改value的记录；
【5】支持下标[]操作


~~~c++
//遍历
4
1 2 
3 1
4 5
1 1
#include<bits/stdc++.h>
using namespace std;
int main(){
    freopen("abc.txt","r",stdin);
    map<int,int>m;
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        int a,b;
        cin>>a>>b;
        m[a]=b;
    }
    for(map<int,int>::iterator it=m.begin();it!=m.end();it++){
         cout<<it->first<<" "<<it->second<<endl;
    }
    for (auto it =  m.begin(); it != m.end(); it++) {
            cout<<it->first<<" "<<it->second<<endl;
    }
    #
    return 0;
}
运行结果
    1 1
    3 1 
    4 5
说明 1 2 被覆盖了,且换key的值从小到大排序   m[key]=value
~~~

## 【heap】最大堆和最小堆

头文件是algorithm

~~~c++
一般用到这四个：make_heap()、pop_heap()、push_heap()、sort_heap()；

（1）make_heap()        //构造堆 
void make_heap(first_pointer,end_pointer,compare_function); 
默认比较函数是(<)，即最大堆。 
函数的作用是将[begin,end)内的元素处理成堆的结构

（2）push_heap()        //添加元素到堆 
void push_heap(first_pointer,end_pointer,compare_function); 
新添加一个元素在末尾，然后重新调整堆序。该算法必须是在一个已经满足堆序的条件下。 
先在vector的末尾添加元素，再调用push_heap

（3）pop_heap()         //从堆中移出元素 
void pop_heap(first_pointer,end_pointer,compare_function); 
把堆顶元素取出来，放到了数组或者是vector的末尾。 
要取走，则可以使用底部容器（vector）提供的pop_back()函数。 
先调用pop_heap再从vector中pop_back元素

（4）sort_heap()        //对整个堆排序 
排序之后的元素就不再是一个合法的堆了。
~~~

~~~c++
void testHeap() 
{
    vector<int> data{ 3,1,2,7,5 };c
    //构造堆，最大堆
    make_heap(data.begin(), data.end(), less<int>());
    //pop堆顶元素，最大的元素
    pop_heap(data.begin(), data.end(), less<int>());
    cout << data.back() << endl;//输出7
    data.pop_back();
    //往堆中添加元素
    data.push_back(4);
    push_heap(data.begin(), data.end(), less<int>());//调整堆
    //排序
    sort_heap(data.begin(), data.end(), less<int>());
    for (int x : data)
        cout << x << " ";
    cout << endl;//输出 1，2，3，4，5
}
~~~

## 【list】链表

 List将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢. 

~~~c++
链表的基本操作：
assign() 给list赋值 
back() 返回最后一个元素 
begin() 返回指向第一个元素的迭代器 
clear() 删除所有元素 
empty() 如果list是空的则返回true 
end() 返回末尾的迭代器 
erase() 删除一个元素 
front() 返回第一个元素 
get_allocator() 返回list的配置器 
insert() 插入一个元素到list中 
max_size() 返回list能容纳的最大元素数量 
merge() 合并两个list 
pop_back() 删除最后一个元素 
pop_front() 删除第一个元素 
push_back() 在list的末尾添加一个元素 
push_front() 在list的头部添加一个元素 
rbegin() 返回指向第一个元素的逆向迭代器 
remove() 从list删除元素 
remove_if() 按指定条件删除元素 
rend() 指向list末尾的逆向迭代器 
resize() 改变list的大小 
reverse() 把list的元素倒转 
size() 返回list中的元素个数 
sort() 给list排序 
splice() 合并两个list 
swap() 交换两个list 
unique() 删除list中重复的元素

list<int> numbers;                //链表初始化
for(int i=0; i<n; i++ )
    numbers.push_back(i);         //链表的建立

numbers.begin();                  //链表头元素
numbers.end();                    //链表尾元素
numbers.erase(current);           //删除链表元素
numbers.size();                   //链表尺寸
~~~

~~~c++
4
1 2 
3 1
4 5
1 1
    
#include<bits/stdc++.h>
using namespace std;
int main()
{
    freopen("abc.txt","r",stdin);
    int n;
    cin>>n;
    list<pair<int,int> > numbers;                //Á´±í³õʼ»¯
    for(int i=0; i<n; i++ ){
        int x,y;
        cin>>x>>y;
        numbers.push_back(make_pair(x,y));         //Á´±íµÄ½¨Á¢
    }
    int x=0;
    for(list<pair<int,int> >::iterator it=numbers.begin();it!=numbers.end();it++){
         //cout<<it->first<<" "<<it->second<<endl;
         if(it->first==3){
             cout<<"sf";
             numbers.erase(it++);         //删除
         }
    }
    for(list<pair<int,int> >::iterator it=numbers.begin();it!=numbers.end();it++){
         cout<<it->first<<" "<<it->second<<endl;
    }
    return 0;
}
~~~

### STL容器之间的差异和联系

1.vector （连续的空间存储,可以使用[]操作符）快速的访问随机的元素，快速的在末尾插入元素，但是在序列中间的插入，删除元素要慢（涉及元素复制移动），而且如果一开始分配的空间不够的话，有一个重新分配更大空间，此时需要拷贝的性能开销

2.deque 在开始和最后添加删除元素都一样快,并提供了随机访问方法,像vector一样使用[]访问任意元素,但是随机访问速度比不上vector快,因为它要内部处理堆跳转deque也有保留空间.另外,由于deque不要求连续空间,所以可以保存的元素比vector更大,这点也要注意一下.还有就是在前面和后面添加元素时都不需要移动其它块的元素。对deque的排序操作，可将deque先复制到vector，排序后在复制回deque。
1)两端都能快速插入元素和删除元素（vector只在尾端快速进行此类操作）。
2）存取元素时，deque的内部结构会多一个间接过程，所以元素的存取和迭代器的动作会稍稍慢一些。
3）迭代器需要在不同区块间跳转，所以必须是特殊的智能型指针，非一般指针。
4）在对内存区块有所限制的系统中（例如PC系统），deque可以内含更多元素，因为它使用不止一块内存。因此deque的max_size()可能更大。
5）deque不支持对容量和内存重分配时机的控制。特别要注意的是，除了头尾两端，在任何地方插入或删除元素，都将导致指向deque元素的任何指针、引用、迭代器失效。不过，deque的内存重分配优于vector，因为其内部结构显示，deque不必在内存重分配时复制所有元素。
6）deque的内存区块不再被使用时，会被释放。deque的内存大小是可缩减的。

3.list（元素间使用链表相连）访问随机元素不如vector快，随机的插入元素比vector快，对每个元素分配空间，所以不存在空间不够，重新分配的情况。list可以快速地在所有地方添加删除元素,但是只能快速地访问最开始与最后的元素

4.set 内部元素唯一，用一棵平衡树结构来存储，因此遍历的时候就排序了，查找比较快。

5.map 一对一的映射的结合，key不能重复。

6.stack 适配器，必须结合其他的容器使用，stl中默认的内部容器是deque。先进后出，只有一个出口，不允许遍历。

7.queue 适配器。是受限制的deque，内部容器一般使用list较简单。先进先出，不允许遍历和元素的随机访问。

需要说明的是：
由于deque可以从首位两端插入或剔除元素，所以只需要对其进行简单的封装就可以分别实现先进先出（FIFO）的stack和先进后出（FILO）的queue了。stack和queue中都有一个deque类型的成员，用做数据存储的容器，然后对deque的部分接口进行简单的封装，例如stack只提供从末端插入和删除的接口以及获取末端元素的接口，而queue则只提供从尾部插入而从头部删除的接口以及获取首位元素的接口。像这样具有“修改某物接口，形成另一种风貌”的性质的，称为配接器（adapter），因此STL中stack和queue往往不被归类为容器（container），而被归类为容器配接器（container adapter）。