1、string
1.1 定义和初始化
string s1; // 默认初始化,s1是一个空字符串
string s2 = s1; // s2是s1的副本,注意s2只是与s1的值相同,并不指向同一段地址
string s3 = "hiya"; // s3是该字符串字面值的副本
string s4(10, 'c'); // s4的内容是 "cccccccccc"
1.2 string的一些常用操作
1.2.1 string的读写
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s1, s2;
cin >> s1 >> s2;
cout << s1 << s2 << endl;
return 0;
}
注意:不能用printf直接输出string,需要写成:printf(“%s”, s.c_str());
1.2.2 使用getline读取一整行
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s;
getline(cin, s);
cout << s << endl;
return 0;
}
1.2.3 string的empty和size操作
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s1, s2 = "abc";
cout << s1.empty() << endl; // 判断是否为空字符串
cout << s2.empty() << endl;
cout << s2.size() << endl; // 返回字符串的大小
return 0;
}
注意size是无符号整数,因此 s.size() <= -1 一定成立。这里会先将 -1 转换为无符号整数 4294967295
1.2.4 string的比较
支持 >, <, >=, <=, ==, !=等所有比较操作,按字典序进行比较。
1.2.5 为string对象赋值
string s1(10, 'c'), s2; // s1的内容是 cccccccccc;s2是一个空字符串
s1 = s2; // 赋值:用s2的副本替换s1的副本
// 此时s1和s2都是空字符串
1.2.6 两个string对象相加
string s1 = "hello, "", s2 = "world\n";
string s3 = s1 + s2; // s3的内容是 hello, world\n
s1 += s2; // s1 = s1 + s2
1.2.7 字面值和string对象相加
做加法运算时,字面值和字符都会被转化成string对象,因此直接相加就是将这些字面值串联起来:
string s1 = "hello", s2 = "world"; // 在s1和s2中都没有标点符号
string s3 = s1 + ", " + s2 + '\n';
当把string对象和字符字面值及字符串字面值混在一条语句中使用时,必须确保每个加法运算符的两侧的运算对象至少有一个是string:
string s4 = s1 + ", "; // 正确:把一个string对象和有一个字面值相加
string s5 = "hello" + ", "; // 错误:两个运算对象都不是string
string s6 = s1 + ", " + "world"; // 正确,每个加法运算都有一个运算符是string
string s7 = "hello" + ", " + s2; // 错误:不能把字面值直接相加,运算是从左到右进行的
1.2.8 find() 与 rfind() (如果找不到,返回 -1)
- rfind(str)是从字符串右侧开始匹配str,并返回在字符串中的位置(下标);
# include<string>
# include<iostream>
using namespace std;
int main()
{
string str = "123456123456123456";
cout<<str<<endl<<"0123456789ABCDEFGHJ"<<endl;//方便查看上面字符串的下标
int pos = str.rfind("123");
cout<<pos<<endl;;
return 0;
}
- rfind(str,pos)是从pos开始,向前查找符合条件的字符串;
# include<string>
# include<iostream>
using namespace std;
int main()
{
string str = "123456123456123456";
cout<<str<<endl<<"0123456789ABCDEFGHJ"<<endl;//方便查看上面字符串的下标
int pos = str.rfind("456",12);
cout<<pos<<endl;;
return 0;
}
- find(str) 与 find(str, pos) 的用法与rfind相似,略。
1.2.9 求子串: s.substr(pos, len)
返回值:包含s中从pos开始的len个字符的拷贝(pos的默认值是0,len的默认值是s.size() - pos,即不加参数会默认拷贝整个s
异常 :若pos的值超过了string的大小,则substr函数会抛出一个out_of_range异常;若pos+n的值超过了string的大小,则substr会调整n的值,只拷贝到string的末尾
1.3 处理string对象中的字符
可以将string对象当成字符数组来处理
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s = "hello world";
for (int i = 0; i < s.size(); i ++ )
cout << s[i] << endl;
return 0;
}
或者使用基于范围的for语句
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s = "hello world";
for (char c: s) cout << c << endl;
for (char& c: s) c = 'a';
cout << s << endl;
return 0;
}
2、vetcor
vector 是变长数组,支持随机访问,不支持在任意位置 O(1)O(1) 插入。为了保证效率,元素的增删一般应该在末尾进行。
2.1 声明
#include <vector> // 头文件
vector<int> a; // 相当于一个长度动态变化的int数组
vector<int> b[233]; // 相当于第一维长233,第二位长度动态变化的int数组
struct rec{…};
vector<rec> c; // 自定义的结构体类型也可以保存在vector中
2.2 常用操作
2.2.1 size/empty
size函数返回vector的实际长度(包含的元素个数),empty函数返回一个bool类型,表明vector是否为空。二者的时间复杂度都是 O(1)O(1)。
所有的STL容器都支持这两个方法,含义也相同。
2.2.2 clear
clear函数把vector清空。
2.2.3 迭代器
迭代器就像STL容器的“指针”,可以用星号*操作符解除引用。
一个保存int的vector的迭代器声明方法为:
vector<int>::iterator it;
vector的迭代器是“随机访问迭代器”,可以把vector的迭代器与一个整数相加减,其行为和指针的移动类似。可以把vector的两个迭代器相减,其结果也和指针相减类似,得到两个迭代器对应下标之间的距离。
2.2.4 begin/end
begin函数返回指向vector中第一个元素的迭代器。例如a是一个非空的vector,则*a.begin()与a[0]的作用相同。
所有的容器都可以视作一个“前闭后开”的结构,end函数返回vector的尾部,即第n 个元素再往后的“边界”。*a.end()与a[n]都是越界访问,其中n = a.size()。
下面两份代码都遍历了vector a,并输出它的所有元素。
for (int i = 0; i < a.size(); i ++)
cout << a[i] << endl;
for (vector<int>::iterator it = a.begin(); it != a.end(); it ++)
cout << *it << endl;
2.2.5 front/back
front函数返回vector的第一个元素,等价于*a.begin()和a[0] 。
back函数返回vector的最后一个元素,等价于*–a.end()和a[a.size() – 1]。
2.2.6 push_back()和pop_back()
a.push_back(x)把元素x插入到vector a的尾部。
b.pop_back()删除vector a的最后一个元素。
3、队列:queue
3.1 声明
queue<int> q;
struct rec{…}; queue<rec> q; //结构体rec中必须定义小于号
priority_queue<int> q; // 大根堆
priority_queue<int, vector<int>, greater<int>> q; // 小根堆
priority_queue<pair<int, int>>q;
3.2 循环队列queue
push // 从队尾插入
pop // 从队头弹出
front // 返回队头元素
back // 返回队尾元素
3.3 优先队列priority_queue
push // 把元素插入堆
pop // 删除堆顶元素
top // 查询堆顶元素(最大值)
4、栈:stack
push // 向栈顶插入
pop // 弹出栈顶元素
5、双端队列:deque
双端队列deque是一个支持在两端高效插入或删除元素的连续线性存储空间。它就像是vector和queue的结合。与vector相比,deque在头部增删元素仅需要 O(1)O(1) 的时间;与queue相比,deque像数组一样支持随机访问。
[] // 随机访问
begin/end // 返回deque的头/尾迭代器
front/back // 队头/队尾元素
push_back // 从队尾入队
push_front // 从队头入队
pop_back // 从队尾出队
pop_front // 从队头出队
clear // 清空队列
6、有序集合set 与 无序集合multiset
头文件set主要包括set和multiset两个容器,分别是“有序集合”和“有序多重集合”,即前者的元素不能重复,而后者可以包含若干个相等的元素。set和multiset的内部实现是一棵红黑树,它们支持的函数基本相同。
6.1 声明
set<int> s;
struct rec{…}; set<rec> s; // 结构体rec中必须定义小于号
multiset<double> s;
6.2 常用操作
6.2.1 size/empty/clear
6.2.2 迭代器
set和multiset的迭代器称为“双向访问迭代器”,不支持“随机访问”,支持星号*解除引用,仅支持++和–两个与算术相关的操作。
设it是一个迭代器,例如set::iterator it;
若把it ++,则it会指向“下一个”元素。这里的“下一个”元素是指在元素从小到大排序的结果中,排在it下一名的元素。同理,若把it --,则it将会指向排在“上一个”的元素。
6.2.3 begin/end
返回集合的首、尾迭代器,时间复杂度均为 O(1)。
s.begin()是指向集合中最小元素的迭代器。
s.end()是指向集合中最大元素的下一个位置的迭代器。换言之,就像vector一样,是一个“前闭后开”的形式。因此-- s.end()是指向集合中最大元素的迭代器。
6.2.4 insert
s.insert(x)把一个元素x插入到集合s中,时间复杂度为 O(logn)。
在set中,若元素已存在,则不会重复插入该元素,对集合的状态无影响。
6.2.5 find
s.find(x)在集合s中查找等于x的元素,并返回指向该元素的迭代器。若不存在,则返回s.end()。时间复杂度为 O(logn)。
6.2.6 lower_bound/upper_bound
这两个函数的用法与find类似,但查找的条件略有不同,时间复杂度为 O(logn)。
s.lower_bound(x)查找大于等于x的元素中最小的一个,并返回指向该元素的迭代器。
s.upper_bound(x)查找大于x的元素中最小的一个,并返回指向该元素的迭代器。
6.2.7 erase
设it是一个迭代器,s.erase(it)从s中删除迭代器it指向的元素,时间复杂度为 O(logn)。
设x是一个元素,s.erase(x)从s中删除所有等于x的元素,时间复杂度为 O(k+logn),其中 k 是被删除的元素个数。
6.2.8 count
s.count(x)返回集合s中等于x的元素个数,时间复杂度为 O(k+logn),其中 k 为元素x的个数。
7、map
map容器是一个键值对key-value的映射,其内部实现是一棵以key为关键码的红黑树。Map的key和value可以是任意类型,其中key必须定义小于号运算符。
7.1 声明
map<key_type, value_type> name;
//例如:
map<long, long, bool> vis;
map<string, int> hash;
map<pair<int, int>, vector<int>> test;
7.2 常用操作
7.2.1 size/empty/clear/begin/end
7.2.2 insert/erase
与set类似,但其参数均是 pair<key_type, value_type>
。
7.2.3 find
h.find(x)在变量名为h的map中查找key为x的二元组。
7.2.4 []操作符
h[key]返回key映射的value的引用,时间复杂度为 O(logn)。
[]操作符是map最吸引人的地方。我们可以很方便地通过h[key]来得到key对应的value,还可以对h[key]进行赋值操作,改变key对应的value,就向数组一样!