一些常用的STL容器的函数

总的来说，有

string、

数组（array、vector）、

链表（list）、

哈希表（数组、set、map）

栈与队列（stack、queue）

一、string

0.构造字符串

string str(); // 默认构造函数

string str("adsfa");// 将str初始化为adsfa

string str(20,'a');// 将str初始化为20个a

string str(str1);// 将str初始化为str1

string str(str1,20);// 将str初始化为str1的前20个元素

string str(str1,7,16);// 将str初始化为str1的7-16个元素

1.截取子字符串

str.substr(begin,length); // 表示截取字符串str中其实下标为begin,长度为length的子字符串。

2.查找字符

str.find('a');//  查找字符串str中是否存在字符a，是则返回1，否则返回-1.

3.插入字符串

str.push_back('a');// 在末尾插入字符a

str.insert(pos,str1);// 在pos处（前）插入字符串str1

str.insert(pos,'a');// 在pos处插入字符a

str.insert(pos,str1,n);// 在pos处插入字符串str1的前n个字符

str.insert(pos,str1,a,b);//将str1[a b]之间的字符插入pos前

str.insert(pos,n,'a');// 在pos处插入n个字符a

4.字符串长度

str.size(); // 返回字符串长度

5.删除

str.earse(begin,length);// 将字符串str从begin开始删除，删除长度为length

6.替换字符串

str.replace(begin,length,str1);// 把str中自begin起、长度为length的字符串替换为str1

str.replace(begin,length,n,'a');// 把str中自begin起、长度为length的字符换替换为n个字符a

7.将非string转化为string（使用to_string()）

int a = 123;

string s = a.to_string();

8.将string转化为int（使用stoi()）

string str = "123";

int a = stoi(str);// a为123

9.反转字符串

reverse(str.begin(), str.end());// 反转整个字符串

reverse(str.begin(),str.begin()+n);// 反转str的前n个字符

10.判断是否为空

str.empty();// 判断str是否为空，是则返回1，否则返回0

11. 排序

sort(str.begin(), str.end());//排序

二、vector容器

可变大小数组（容器），随机访问快，尾部之外的位置操作速度慢

1.构造

vector<int> vec;// 一维整型vector

vector<vector<int>> vec1;// 二维整型vector

vector<int> a(n,val);// n个val

2.添加元素

vec.push_back(1);// 将1添加进数组尾部

3.删除元素

vec.pop_back();// 将数组尾部元素弹出，删除最后一个元素

vec.erase(vec.begin()+n);// 使用迭代器，将第n个位置的元素删除

4.查询数组大小

vec.size();// 返回数组大小

5.插入元素

vec.insert(vec.begin()+n,10);// 使用迭代器，将10插入vec的第n个位置（占据第n个位置，其他元素向后推）

6.重新设置大小

vec.resize(length);// 将vec缩放到length长度

删除末尾或者末尾补0.

7.排序（#include<algorithm>）

sort(vec.begin(), vec,end()); // 排序，从小到大

8.查找元素

vector<int>::iterator result = find(a.begin(), a.end(), 4);// 使用迭代器，查询在范围[begin(), end()]之间是否存在元素4.如果查询到了，则指向该元素，否则指向尾后，即a.end()。该函数返回的是迭代器类型。

9.清空

vec.clear();//清空数组

10.查询是否为空

vec.erase();//

三、array数组

固定大小数组，支持快速随机访问

1.初始化

array<int,100> arr;// 长度为100，类型为int的数组。此时初值不为0，而是随机数。

2.赋值

arr.fill(3); // 用3对所有元素进行赋值

3.返回第一个、最后一个元素的应用

arr.front() = 666;/ 将666赋给数组的第一个元素

arr.back() = 666;// 将666赋给数组的最后一个元素

4.arr.empty();// 判断是否为空

5.arr.size();// 返回大小

6.swap(arr,arr10);// 交换，两个数组的大小和类型必须相同

7.迭代器

begin() 、 end()

四、list

单链表的定义：

struct ListNode{
    int val;
    LiseNode* next;
    ListNode(int x):val(x),next(NULL){}// 节点的构造函数
};

构造  ListNode* head = new ListNode(5);// 构造一个头结点

该结构体（ListNode）为自定义的数据结构，需要自己定义添加节点、删除节点、搜索节点等功能。

而STL里的list为双向链表，内置了许多接口，可以方便的执行插入、删除、排序、查找等功能。

1.构造函数

list<int> l1;//构造一个空list

list<int> l2(n,val);// 构造n个值为val的双链表

list<int> l3(l2.begin(), l2.end());// 使用迭代器，将l2赋进去[begin(), end() ) 左闭右开

list<int> l4(arr, arr+5);// 可以使用数组进行初始化。 和vector一样，但是多了使用数组进行初始化的方法

2.插入  list的迭代器不能使用加号+！！！！

list.push_front();// 往前面插入

list.push_back();// 往后面插入

list.insert(l1.end(), val);// 往迭代器处插入val

list.insert(l1.end(), n, val);// 往迭代器处插入n个val

list.insert(l1.end(), l1.begin(), l1.end()); // 向指定迭代器位置插入一段

3.删除

list.pop_front();// 从前面删除

list.pop_back();// 从后面删除

list.erase(a.begin());// 删除迭代器处的元素

4.元素的获取

l1.front();// 获取第一个

l1.back();//获取最后一个

list<int>::iterator it = l1.begin();// 通过迭代器访问元素

cout<< *it << endl;

it++;

cout<< *it << endl;

5.list的容量

l1.size();//大小

6.修改大小

l1.resize(n, val); // 将l1缩放到大小为n,不够用val补。

7.清空和判断是否为空

l1.clear();

l1.empty();

8.排序

l1.sort();// 从小到大

9.拼接

l1.splice(l1.begin(), l2,l2.begin()); // 将l2在begin()处的元素拼接到l1.begin()

10.删除重复元素

l1.unique();

11.删除所有值为val的元素

l1.remove(val);

12.对两个有序list进行融合

l1.merge(l2); // l1 l2一定是有序的，否则会报错

13.反转

l1.reverse();

14.重新赋值

l1.assign(n,val);//

l1.assign(l2.begin(), l2.end());// 使用迭代器

15.交换两个list的值

l1.swap(l2);//

五、set

set中的元素是有序的，不允许重复元素，底层是通过红黑树（平衡二叉搜索树）来实现的（除了unordered_set，它是通过哈希表实现的）。set中的元素按照一定的顺序排列，且放入一个元素就会调整这个元素的位置，把它放入到合适的位置，所以set中只有一个insert的插入操作。

1.初始化及插入

set<int> a;//

set<int> a({1,2,3,4,5});

a.isert(6);

2.删除

a.erase(2);

3.查找某个制定元素的迭代器

a.find(val);

4.swap size empty 等

unordered_set为无序的，且也不允许重复元素.

六、map

以<key, value>的形式存在，可以存储任意类型的数据。

自动以key升序进行排列。

unordered_map无序。

1.定义

map<typename, typename> mp;

map<char, int> mp;

2. 访问元素

mp['a'];// 通过下标进行访问

map<char, int>:: iterator it = mp.begin();//使用迭代器进行访问

cout<< it -> first << " " << it -> second << endl;

3.查找元素

mp.find(key); // 返回键为key为映射的迭代器，时间复杂度为O(logN)

cout << it -> secend << endl;

4.删除元素

mp.erase(it); // 通过迭代器进行删除。

mp.erase(it, mp.end());// 通过迭代器删除一个区间（it到结尾）的元素。

mp.erase(key);// 通过key值进行删除

5.获取大小

mp.size();

6.清理

mp.clear();

七、stack

栈，先进后出。不提供迭代器。

1.初始化

stack<int> st;

2.常用成员函数

st.push(val);///将val压入栈

st.top();//读取栈顶元素

st.pop();//将栈顶元素弹出

st.size();// 返回栈的大小

st.empty();//判断栈是否为空

swap(st1, st2);// 交换两个栈的元素

八、queue

线性表，先进先出。不提供迭代器。

1.初始化

queue<int> que;

2.常用成员函数

que.push(val);// 将val放入队列中

que.frount();// 返回当前queue容器起始元素的引用

que.back();// 返回当前queue容器末尾元素的引用

que.pop();// 删除

que.size();// 返回大小

que.empty();// 返回是否为空

优先队列。保证元素出队列的顺序是基于优先级的，这个优先级是自己定义的。