一. vector相关操作
vector() 的最大、最小值，及其对应下标
例 a[]={1,2,3,4,5,6};

最大值：int maxValue = *max_element(a,a+6); 

最小值：int minValue = *min_element(a,a+6);

例 vector<int> v;

最大值下标：int maxPosition = max_element(v.begin(),v.end()) - v.begin(); 

最小值下标：int minPosition = min_element(v.begin(),v.end()) - v.begin();

vector的大小：
vector<int> tmp;
tmp.size();
tmp.capacity();

vector的第一个元素：
tmp.front();

vector的最后一个元素：
tmp.back();

判断vector是否为空：
tmp.empty();

删除系列：
//清空元素并回收空间
vector<int> tmp;
vector<int>().swap(tmp);
或
tmp.swap(vector<int>());

//清空元素，但不回收空间
tmp.clear();

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

删除 [begin，end)区间元素
tmp.erase(begin, end);

vector元素翻转
需要头文件#include<algorithm>
reverse(vec.begin(),vec.end());

删除vector中重复元素：
vector<int> a = {1, 4, 4, 3, 2, 4, 2};
sort(a.begin(), a.end());
auto it = unique(a.begin(), a.end());
a.erase(it, a.end());

将一个容器中的内容追加到另一个容器的后面
std::vector<int> v1, v2 ;
v1.insert(v1.end(), v2.begin(), v2.end());

swap 函数 交换两个值
vector<int>& nums;
swap(nums[i], nums[j]);

vector和set的互相转化
    vector<int> vec;
    vec = { 1, 2, 3, 4, 8, 9, 3, 2, 1, 0, 4, 8 };
    set<int> st(vec.begin(), vec.end());
    vec.assign(st.begin(), st.end());
    
    
vector 求交集和并集
vector<int> v1 = {1,2,3,4,5,6};
vector<int> v2 = {3,4,5,6,7,8};
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
vector<int> v;
set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), back_inserter(v)); //求交集
vector<int> vv;
set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), back_inserter(vv)); //求并集

二. string 相关
s_str从k开始的子字符串
string sub_str = s_str.substr(k);

从 s 中找 sub_str
if (s.find(sub_str) == string::npos) 找不到

string 找到字符串中的第一个出现“1”的位置
if (k = s_str.find_first_of("1")) != string::npos)

判断是否是数字
char a;
if (isdigit(a))

string转换int long等
string str;
int i = atoi(str.c_str()); // c
int i = std::stoi(str);  // c++

stol(long), stof(float), stod(double)

去掉string的最后一位字符
string res;
res.pop_back();

大写字符转换为小写字符
tolower(char ch);

比较两个字符串是否相等
string s1, s2;
if ((s1.compare(s2)) == 0)
当s1 < s2时，返回为负数(-1)；
当s1 == s2时，返回值= 0；
当s1 > s2时，返回正数(1)。

int转换成string
to_string
std::string to_string(int value); (1) (C++11起)
std::string to_string(long value); (2) (C++11起)
std::string to_string(long long value); (3) (C++11起)
std::string to_string(unsigned value); (4) (C++11起)
std::string to_string(unsigned long value); (5) (C++11起)
std::string to_string(unsigned long long value); (6) (C++11起)
std::string to_string(float value); (7) (C++11起)
std::string to_string(double value); (8) (C++11起)
std::string to_string(long double value); (9) (C++11起)
三. map
删除一个节点
auto iter = mapTest.find(key);  
mapTest.erase(iter);

map<string, int> dict;
map<string, int>::iterator iter;
// 插入方式
dict.insert(pair<string, int>("apple", 1));
dict.insert(map<string, int>::value_type("orange", 2));
dict["purple"] = 3;

// 遍历
for (iter = dict.begin(); iter != dict.end(); iter++) {
    cout << iter->first << iter->second << endl;
}

if ((iter = dict.find("sdfas")) != dict.end()) {}

// 查找
if (dict.count("fawsef") == 0) {}

iter = dict.lower_bound("buoluo"); //返回一个迭代器，指向键值>=key的第一个元素
cout << iter->first;
iter = dict.upper_bound("buoluo"); //返回一个迭代器，指向键值>key的第一个元素
cout << iter->first;

四、 stack
top()：返回一个栈顶元素的引用，类型为 T&。如果栈为空，返回值未定义。
push(const T& obj)：可以将对象副本压入栈顶。这是通过调用底层容器的 push_back() 函数完成的。
push(T&& obj)：
pop()：
size()：返回栈中元素的个数。
empty()：在栈中没有元素的情况下返回 true。
emplace()：用传入的参数调用构造函数，在栈顶生成对象。
swap(stack<T> & other_stack)：

五、数字和字符的一些操作
::min(minV, x);  // 取最小值

answer += max(0, oper);  // 0和oper中的最大值

算出len的平方根
sqrt(len)

tmp的n次方
int ans = pow(tmp, n);

将整数转成二进制
int i = 10;
std::bitset<32> tmp(i);

  std::bitset<16> foo;  //16是长度
  std::bitset<16> bar (0xfa2);
  std::bitset<16> baz (std::string("0101111001"));

  std::cout << "foo: " << foo << '\n';
  std::cout << "bar: " << bar << '\n';
  std::cout << "baz: " << baz << '\n';
  
foo: 0000000000000000
bar: 0000111110100010
baz: 0000000101111001  

foo.to_string() 返回它转换为string的结果

将二进制转换成十进制
std::bitset<10> ("010101");
int a = bit.to_ullong();
cout << a;
输出为21

string out= "0101";
int x = stoi(out, nullptr, 2);
cout << x << endl;
输出5

string binaryString = "11111111111111111111111110000000"; // 128
int retTmp = 0;
for (int i = 0; i < binaryString.length(); i++) {
    retTmp += (binaryString[i] - '0') * pow(2, binaryString.length() -i -1);
}

将十进制转换成16进制数
#include <iostream>
#include <iomanip>
string dec2hex(int i)
{
    stringstream ioss;
    string sTmp;
    //以8位宽度显示，不够补0，16进制以大写输出，hex 也可写为 setbase(16)
    ioss << setfill('0') << setw(8) << setiosflags(ios::uppercase) << hex << i; 
    //ioss << setiosflags(ios::lowercase) << hex << i; //小写
    ioss >> sTmp;
    return sTmp;
}

isalpha()用来判断一个字符是否为字母，如果是字符则返回非零，否则返回零。
isdigit()用来判断一个字符是否为数字
isalnum()用来判断一个字符是否为数字或者字母，也就是说判断一个字符是否属于a~z||A~Z||0~9
cout<<isalnum('a'); //输出非零
cout<<isalnum('2'); // 非零
cout<<isalnum('.'); // 零
islower()用来判断一个字符是否为小写字母，也就是是否属于a~z
isupper()和islower相反，用来判断一个字符是否为大写字母
tolower()函数是把字符串都转化为小写字母
toupper()函数是把字符串都转化为小写字母

六、deque  与vector不同的是收尾都开放
front()    返回第一个元素的引用。
back()    返回最后一个元素的引用。
assign()    用新元素替换原有内容。
push_back()    在序列的尾部添加一个元素。
push_front()    在序列的头部添加一个元素。
pop_back()    移除容器尾部的元素。
pop_front()    移除容器头部的元素。

七、queue 
和 stack 有一些成员函数相似，但在一些情况下，工作方式有些不同：
front()：
back()：
push(const T& obj)：
push(T&& obj)：
pop()：删除 queue 中的第一个元素。
size()：返回 queue 中元素的个数。
empty()：如果 queue 中没有元素的话，返回 true。
emplace()：用传给 emplace() 的参数调用 T 的构造函数，在 queue 的尾部生成对象。
swap(queue<T> &other_q)：

八、 一些计算函数
lower_bound()、upper_bound()、equal_range() 以及 binary_search() 
这 4 个查找函数，它们的底层实现采用的都是二分查找的方式。
int a[5] = { 1,2,3,4,5 };
int *p = lower_bound(a, a + 5, 3);  // 从 a 数组中找到第一个不小于 3 的元素
此时： *p = 3 

九、语法学习总结
多态：在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。
如果对象类型是派生类，就调用派生类的函数；
如果对象类型是基类，就调用基类的函数。

十、常用算法
滑窗
    while ((left < size) && (right < size)) {
        int ans = v[right] - v[left];
        if (ans == gap) {
            answer++;
            right++;
        }
        
        if (ans < gap) {
            right++;
        }
        
        if (ans > gap) {
            left++;
        }
        
        if (left == right) {
            right++;
        }
    }
    
二维数组比较大小：按列从小到大排，如果第一列相等，就按第二列的从大到小排
1 2
3 4
2 10
2 3  
变成
1 2 
2 3 
2 10 
3 4  
static bool cmp(vector<int> &a, vector<int> &b)
{
    if (a[0] != b[0]) {
        return a[0] < b[0];
    } else {
        return a[1] < b[1];
    }
}

二维数组的遍历
vector<vector<int>> matrixTmp(matrix);
int row = matrixTmp.size();
int col = matrixTmp[0].size();
cout << row << " " <<  col << endl;
for (int i = 0; i < row; i++) {
    for (int j = 0; j < col; j++) {
        //
    }
    //
}

for (auto &i : matrix) {
    for (auto &j : i) {
        cout << j << " ";
    }
    cout<< endl;
}

岛屿问题模板
class Solution {
public:
    int dfs(vector<vector<char>>& grid, int i, int j) {
        // 递归中，写出结束条件，例如
        if (i < 0 || j < 0 || i >= grid.size() || j >= grid[0].size() || grid[i][j] == 0) {
            return 0;
        }
        // 定义两个数组，用于访问当前节点的上下左右的四个节点，进行递归调用
        int di[4] = {-1,0,1,0};
        int dj[4] = {0,1,0,-1};
        // 遍历临近四个节点，进行递归调用
        for (int index = 0; index < 4; ++index) {
            int next_i = i + di[index];
            int next_j = j + dj[index];
            // 此处根据题目具体需求进行操作，这里只是给出一个示例
            dfs(grid, next_i,next_j);
        }

        return xxx;
    } 

    int numIslands(vector<vector<char>>& grid) {
        // 遍历每个节点，每个节点都调用 dfs，从 dfs 中获取想要的结果
        for (int i = 0; i < grid.size(); ++i) {
            for (int j = 0; j < grid[0].size(); ++j) {
                dfs(grid, i, j); 
            }
        }
        return xxx;
    }
};