常用STL知识点

常用STL知识点

STL 迭代器

迭代器：iterator

用法：

vector<int> a;
for (vector<int>::iterator it = a.begin(); it != a.end(); it ++) cout << *it << ' ';
map<int, int> b;
for (map<int, int>::iterator it = b.begin(); it != b.end(); it ++) printf("%d : %d\n", it->first, it->second);

string用法

初始化

string s;//无参构造
string s = string(n, char);//使用n个字符c初始化 

赋值

str1 = "hello world";//char*类型字符串 赋值给当前的字符串
str2 = str1;//char*类型字符串 赋值给当前的字符串
str3 = 'a';//字符赋值给当前的字符串
str4.assign("hello c++");//把字符串s赋给当前的字符串
str5.assign("hello c++",5);//把字符串s的前n个字符赋给当前的字符串
str6.assign(str5);//把字符串s赋给当前字符串
str7.assign(5, 'x');//用n个字符c赋给当前字符串

字符串拼接

str1 += "爱玩游戏";//重载+=运算符
str1 += ':';//重载+=运算符
str1 += str2;//重载+=运算符
str3.append(" love ");//把字符串s连接到当前字符串结尾
str3.append("game abcde", 4);//把字符串s的前n个字符连接到当前字符串结尾
str3.append(str2);//两个字符串拼接 等价于 s1 += s2
str3.append(str2, 4, 3); // 从下标4位置开始 ，截取3个字符，拼接到字符串末尾

查找

str1.find("de");//从左向右找
str1.rfind("de");//从右向左找
//找到返回字符串第一个字符的位置，找不到则返回-1

替换

str1.replace(1, 3, "1111");//(起点, 长度, 用于替换的字符串)

字符串比较

s1.compare(s2);

遍历

for (int i = 0; i < s.size(); i ++) cout << s[i];
for (int i = 0; i < s.size(); i ++) cout << s.at(i);

修改

s[i] = 'a';
s.at(i) = 'a';

插入

s1.insert(pos, s2);//在pos处插入字符串s2
s1.insert(pos, n, 'c');//在pos处插入n个字符'c'

删除

s.erase(pos, len);//删除从pos开始的长度为len的字符

取子串

s2 = s1.substr(pos, len);//返回从pos开始的长度为len的子串

vector用法

初始化

vector<int> v1; //无参构造
for (int i = 0; i < 10; i++) v1.push_back(i);
vector<int> v2(v1.begin(), v1.end());//将v1[begin(), end())区间中的元素拷贝给本身。
vector<int> v3(10, 100);//构造函数将n个elem拷贝给本身。
vector<int> v4(v3);//拷贝构造函数。

容量和大小

vector<int> a;
a.size();
a.empty();
a.capacity();//容器的容量
a.resize(len);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。
a.resize(len, elem)//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除

插入和删除

//插入和删除
vector<int> v1;
//尾插
v1.push_back(10);
v1.push_back(20);
v1.push_back(30);
v1.push_back(40);
v1.push_back(50);
//尾删
v1.pop_back();//删除最后一个元素
//插入
v1.insert(v1.begin(), 100);//迭代器指向位置pos插入元素elem
v1.insert(v1.begin(), 2, 1000);//迭代器指向位置pos插入count个元素elem
//删除
v1.erase(v1.begin());//删除迭代器指向的元素
//清空
v1.erase(v1.begin(), v1.end());//删除迭代器从start到end之间的元素
v1.clear();//删除容器中所有元素

数据存取

for (int i = 0; i < 10; i++) v1.push_back(i);
for (int i = 0; i < v1.size(); i++) cout << v1.at(i) << " ";
cout << "v1的第一个元素为： " << v1.front() << endl;//返回容器中第一个数据元素
cout << "v1的最后一个元素为： " << v1.back() << endl;//返回容器中最后一个数据元素

预留空间

vector<int> a;
a.reverse(len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。

list用法

queue用法

stack用法

set和multiset

构造和赋值

//set容器插入数据的数据会自动排序
set<int> s1;
s1.insert(10);
//拷贝构造
set<int>s2(s1);
//赋值
set<int>s3;
s3 = s2;

大小

set.size();
set.empty();

插入和删除

//插入
s1.insert(10);//在容器中插入元素
//删除
s1.erase(s1.begin());//删除pos迭代器所指的元素，返回下一个元素的迭代器。
s1.erase(30);//删除容器中值为elem的元素。
//清空
s1.erase(s1.begin(), s1.end());//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
s1.clear();

查找和统计

//查找
set<int>::iterator pos = s1.find(30);//查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
if (pos != s1.end()) cout << "找到了元素 ： " << *pos << endl;
else cout << "未找到元素" << endl;
s1.count(30);//统计key的元素个数

set 和 multiset的区别

• set不可以插入重复数据，而multiset可以
• set插入数据的同时会返回插入结果，表示插入是否成功
• multiset不会检测数据，因此可以插入重复数据

map和unordered_map

map

• map中所有元素都是pair
• pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）
• 所有元素都会根据元素的键值自动排序

map和multimap区别：

• map不允许容器中有重复key值元素
• multimap允许容器中有重复key值元素

构造和赋值

map<int,int>m; //默认构造
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(3, 30));
map<int, int>m2(m); //拷贝构造
map<int, int>m3;
m3 = m2; //赋值

大小和交换

m.size();
m.empty();

插入和删除

//插入
map<int, int> m;
//第一种插入方式
m.insert(pair<int, int>(1, 10));//在容器中插入元素
//第二种插入方式
m.insert(make_pair(2, 20));
//第三种插入方式
m.insert(map<int, int>::value_type(3, 30));
//第四种插入方式
m[4] = 40; 
//删除
m.erase(m.begin());//删除pos迭代器所指的元素，返回下一个元素的迭代器
m.erase(3);//删除容器中值为key的元素
//清空
m.erase(m.begin(),m.end());//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器
m.clear();//清除所有元素

查找和统计

map<int, int>m; 
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(3, 30));
//查找
map<int, int>::iterator pos = m.find(3);
if (pos != m.end()) cout << "找到了元素 key = " << (*pos).first << " value = " << (*pos).second << endl;
else cout << "未找到元素" << endl;
m.count(3);

二分查找：lower_bound( )和upper_bound( )

lower_bound( )和upper_bound( )都是利用二分查找的方法在一个排好序的数组中进行查找的。

在从小到大的排序数组中：

lower_bound(begin, end, num)：从数组的begin位置到end - 1位置二分查找第一个大于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin，得到找到数字在数组中的下标。

upper_bound(begin, end, num)：从数组的begin位置到end - 1位置二分查找第一个大于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin，得到找到数字在数组中的下标。

在从大到小的排序数组中，重载lower_bound()和upper_bound()

lower_bound( begin,end,num,greater() ):从数组的begin位置到end-1位置二分查找第一个小于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

upper_bound( begin,end,num,greater() ):从数组的begin位置到end-1位置二分查找第一个小于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

字典map 和 哈希表unordered_map

#include<map>
#include<unordered_map>

int main()
{
    unordered_map<int, int> hash;

    // unordere_map 遍历
    for (auto prime : primes)
    {
        cout << prime.first << ' ' << prime.second;
    }
}