目录
vector
初始化
函数方法
访问
stack
初始化
函数方法
queue
初始化
函数方法
deque
初始化
函数方法
priority_queue
初始化
函数方法
设置优先级
基本数据类型的优先级
高级数据类型(结构体)优先级
存储特殊类型的优先级
存储pair类型
map
初始化
函数方法
访问元素
set
初始化
函数方法
访问
重载<运算符
基础数据类型
高级数据类型（结构体）
pair
初始化
访问
string
初始化
访问
读入
函数方法
vector
初始化
vector <int> v1;
vector <double> v2;
vector <int> v1 (n); // 定义一个长度为n的数组，初始值默认为0，下标范围[0, n - 1]
vector <int> v2 (n, 1); // v[0] 到 v[n - 1]所有的元素初始值均为1
vector <int> v1 [n]; // 定义可变长二维数组，n行（固定），列长度可变
vector < vector <int> > v2; // 定义一个行和列长度均可变的二维数组
vector <int> v1 [n]; // 定义可变长二维数组，n行（固定），列长度可变
vector < vector <int> > v2; // 定义一个行和列长度均可变的二维数组
vector < vector <int> > v (n, vector <int> (m, 0)); // 行列长度均固定n行m列,初始值为0
函数方法
| v.front () | 返回第一个数据 |
| v.back () | 返回数组中的最后一个数据 |
| v.pop_back () | 删除最后一个数据 |
| v.push_back (element) | 在尾部加一个数据 |
| v.size () | 返回实际数据个数 |
| v.clear () | 清除元素 |
| v.resize (n, x) | 改变数组大小为n，每个值赋值为x（默认赋值为0） |
| v.insert (it, x) | 向任意迭代器it插入一个元素x |
| v.erase (first,last) | 删除[first,last)的所有元素 |
| v.begin () | 返回首元素的迭代器（地址） |
| v.end () | 返回最后一个元素后一个位置的迭代器（地址） |
| v.empty () | 判断是否为空 |
| sort (v.begin (), v.end ()) | 对[begin, end]区间进行从小到大排序 |
vector <int> v;
int n = 10, x = 2;
for (int i = 0; i < n; ++ i)
{
v.push_back (i); // 在尾部加一个数据
}
cout << v.front () << endl; // 返回第一个数据
cout << v.back () << endl; // 返回数组中的最后一个数据
v.pop_back (); // 删除最后一个数据
cout << v.size () << endl; // 返回实际数据个数
v.clear (); // 清除元素个数O
v.resize (n, x); // 改变数组大小为n，每个值赋值为x（默认赋值为0）
v.insert (v.begin () + 1, 1); // 将1插入c[1]的位置
v.erase (v.begin (), v.begin () + 5); // 删除[v.begin (),v.begin () + 5)的所有元素
cout << v.empty () << endl; // 判断是否为空
sort (v.begin (), v.end ()); // 对[begin, end]区间进行从小到大排序
访问
// 下标访问
for (int i = 0; i < n; ++ i)
{
cout << v[i] << " ";
}
// 迭代器访问
vector <int> :: iterator it1 = v.begin ();
for (int i = 0; i < n; ++ i)
{
cout << * (it1 + i) << " ";
}
cout << endl;
vector <int> :: iterator it2;
for (it2 = v.begin (); it2 != v.end (); it2 ++)
{
cout << *it2 << " ";
}
stack
初始化
stack <int> s1;
stack <double> s2;
函数方法
| s.push (element) | 元素element入栈，增加元素 |
| s.top () | 取得栈顶元素 |
| s.size () | 返回栈内元素的个数 |
| s.pop () | 移除栈顶元素 |
| s.empty () | 检测栈内是否为空 |
stack <int> s;
s.push (element); // 元素element入栈，增加元素
cout << s.top () << endl; // 取得栈顶元素
cout << s.size () << endl; // 返回栈内元素的个数
s.pop (); // 移除栈顶元素
cout << s.empty () << endl; // 检测栈内是否为空
queue
初始化
queue <int> q1;
queue <double> q2;
函数方法
| q.push (element) | 尾部添加一个元素element进队 |
| q.front () | 返回队首元素 |
| q.back () | 返回队尾元素 |
| q.size () | 返回队列中元素个数 |
| q.empty () | 判断是否为空 |
| q.pop () | 删除第一个元素 |
queue <int> q;
int element = 1;
q.push (element); // 尾部添加一个元素element进队
cout << q.front () << endl; // 返回队首元素
cout << q.back () << endl; // 返回队尾元素
cout << q.size () << endl; // 返回队列中元素个数
cout << q.empty () << endl; // 判断是否为空
q.pop (); // 删除第一个元素
deque
初始化
deque <int> q1;
deque <double> q2;
函数方法
| q.push_back (element); | 把element插入队尾后 |
| q.push_front (element); | 把element插入队首 |
| q.back () | 返回队尾元素 |
| q.front () | 返回队首元素 |
| q.pop_back () | 删除队尾元素 |
| q.pop_front () | 删除队首元素 |
| q.erase (iterator it) | 删除双端队列中的某一个元素 |
| q.erase (iterator first, iterator last) | 删除双端队列中[first,last)中的元素 |
| q.empty () | 判断是否为空 |
| q.size () | 返回元素数量 |
| q.clear () | 清空 |
int element = 1;
deque <int> q;
q.push_back (element); // 把element插入队尾后
q.push_front (element); // 把element插入队首
cout << q.back () << endl; // 返回队尾元素
cout << q.front () << endl; // 返回队首元素
q.pop_back (); // 删除队尾元素
q.pop_front (); // 删除队首元素
q.erase (q.begin()); // 删除双端队列中的某一个元素
q.erase (q.begin(), q.end()); // 删除双端队列中[first,last)中的元素
cout << q.empty () << endl; // 判断是否为空
cout << q.size () << endl; // 返回元素数量
q.clear (); // 清空
priority_queue
初始化
priority_queue <int> q1;
priority_queue <double> q2;
函数方法
| q.push (element) | 入队 |
| q.top () | 访问队首元素 |
| q.size () | 队列元素个数 |
| q.empty () | 是否为空 |
| q.pop () | 堆顶（队首）元素出队 |
priority_queue <int> q;
// 函数方法
int element = 1;
q.push (element); // 入队
cout << q.top () << endl; // 访问队首元素
cout << q.size () << endl; // 队列元素个数
cout << q.empty () << endl; // 是否为空
q.pop (); // 堆顶（队首）元素出队
设置优先级
基本数据类型的优先级
priority_queue <int> q1; // 默认大根堆, 即每次取出的元素是队列中的最大值
priority_queue <int, vector <int>, less <int> > q2; // 大根堆, 每次取出的元素是队列中的最大值
priority_queue <int, vector <int>, greater <int> > q3; // 小根堆, 每次取出的元素是队列中的最小值
高级数据类型(结构体)优先级
struct node
{
int x, y;
bool operator < (const node & u) const
{
return x < u.x;
}
};
priority_queue <node> q4;
存储特殊类型的优先级
存储pair类型
排序规则：
默认先对pair的first进行降序排序，然后再对second降序排序
对first先排序，大的排在前面，如果first元素相同，再对second元素排序，保持大的在前面。
priority_queue < pair <int, int> > q5;
q5.push ({10, 20});
q5.push ({10, 30});
q5.push (make_pair(20, 30));
while (!q5.empty ())
{
cout << q5.top ().first << " " << q5.top ().second << endl;
q5.pop ();
}
map
初始化
map <string, string> mp1;
map <string, int> mp2;
map <int, string> mp3;
map特性：map会按照键的顺序从小到大自动排序，键的类型必须可以比较大小
函数方法
| mp.find(key) | 返回键为key的映射的迭代器
注意：用find函数来定位数据出现位置，它返回一个迭代器。
当数据存在时，返回数据所在位置的迭代器，数据不存在时，返回mp.end( ) |
| mp.erase(it) | 删除迭代器对应的键和值 |
| mp.erase(key) | 根据映射的键删除键和值 |
| mp.erase(first,last) | 删除左闭右开区间迭代器对应的键和值 |
| mp.size() | 返回映射的对数 |
| mp.clear() | 清空map中的所有元素 |
| mp.insert() | 插入元素，插入时要构造键值对 |
| mp.empty() | 如果map为空，返回true，否则返回false |
| mp.begin() | 返回指向map第一个元素的迭代器（地址） |
| mp.end() | 返回指向map尾部的迭代器（最后一个元素的下一个地址） |
| mp.rbegin() | 返回指向map最后一个元素的迭代器（地址） |
| mp.rend() | 返回指向map第一个元素前面(上一个）的逆向迭代器（地址） |
| mp.count(key) | 查看元素是否存在，因为map中键是唯一的，所以存在返回1，不存在返回0 |
| mp.lower_bound() | 返回一个迭代器，指向键值>= key的第一个元素 |
| mp.upper_bound() | 返回一个迭代器，指向键值> key的第一个元素 |
map <int, int> mp;
mp[1] = 10;
cout << mp.find (1) -> first << endl;
cout << mp.find (1) -> second << endl;
//返回键为key的映射的迭代器
//注意：用find函数来定位数据出现位置，它返回一个迭代器。
//当数据存在时，返回数据所在位置的迭代器，数据不存在时，返回mp.end( )
mp.erase (mp.begin ()); // 删除迭代器对应的键和值O ( 1 ) O(1)
mp.erase (1); // 根据映射的键删除键和值
mp[1] = 10;
mp[2] = 20;
mp.erase (mp.begin (), mp.end ()); // 删除左闭右开区间迭代器对应的键和值
cout << mp.size () << endl; // 返回映射的对数
mp.clear (); // 清空map中的所有元素
mp.insert ({1, 10}); // 插入元素，插入时要构造键值对
cout << mp.empty () << endl; // 如果map为空，返回true，否则返回false
cout << mp.count (1) << endl; // 查看元素是否存在，因为map中键是唯一的，所以存在返回1，不存在返回0
// 正向遍历
mp[1] = 10;
mp[2] = 20;
mp[3] = 30;
map <int, int> :: iterator it = mp.begin ();
while (it != mp.end ())
{
cout << it -> first << " " << it -> second << endl;
it ++;
}
// 二分查找
map <int, int> :: iterator it1 = mp.lower_bound (2);
cout << it1 -> first << endl;
map <int, int> :: iterator it2 = mp.upper_bound (2);
cout << it2 -> first << endl;
// 添加元素
map <string, string> mp4;
mp4["1"] = "10";
mp4["2"] = "20";
mp4.insert ({"3", "30"});
mp4.insert (make_pair("5", "50"));
mp4.insert (pair<string, string>("4", "40"));
访问元素
// 下标访问
map <int, int> mp5;
mp5[1] = 10;
cout << mp5[1] << endl;
//遍历访问
map <int, int> :: iterator it3;
for (it3 = mp5.begin (); it3 != mp5.end (); ++ it3)
{
cout << it3 -> first << " " << it3 -> second << endl;
}
map <int, int> :: iterator it4 = mp5.find (1);
cout << it4 -> first << " " << it4 -> second << endl;
set
初始化
set容器中的元素不会重复，set容器里的元素自动从小到大排序。
set <int> s;
函数方法
| s.begin () | 返回set容器的第一个元素的地址（迭代器） |
| s.end() | 返回set容器的最后一个元素的下一个地址（迭代器） |
| s.rbegin() | 返回逆序迭代器，指向容器元素最后一个位置 |
| s.rend() | 返回逆序迭代器，指向容器第一个元素前面的位置 |
| s.clear() | 删除set容器中的所有的元素 |
| s.empty() | 判断set容器是否为空 |
| s.insert() | 插入一个元素 |
| s.size() | 返回当前set容器中的元素个数 |
| erase(iterator) | 删除定位器iterator指向的值 |
| erase(first,second） | 删除定位器first和second之间的值 |
| erase(key_value) | 删除键值key_value的值 |
| s.find(element) | 查找set中的某一元素，有则返回该元素对应的迭代器，无则返回结束迭代器 |
| s.count(element) | 查找set中的元素出现的个数，由于set中元素唯一，此函数相当于查询element是否出现 |
| s.lower_bound(k) | 返回大于等于k的第一个元素的迭代器 |
| s.upper_bound(k) | 返回大于k的第一个元素的迭代器 |
set <int> s;
s.clear (); // 删除set容器中的所有的元素
cout << s.empty () << endl; // 判断set容器是否为空
s.insert (1); // 插入一个元素
cout << s.size () << endl; // 返回当前set容器中的元素个数
s.erase (s.begin ()); // 删除定位器iterator指向的值
s.erase (s.begin (), s.end ()); // 删除定位器first和second之间的值
s.insert (10);
s.erase (10); // 删除键值key_value的值
s.insert (10);
s.insert (20);
set <int> :: iterator it1 = s.find (10); // 查找set中的某一元素，有则返回该元素对应的迭代器，无则返回结束迭代器
cout << s.count (10) << endl; // 查找set中的元素出现的个数，由于set中元素唯一，此函数相当于查询element是否出现
set <int> :: iterator it2 = s.lower_bound (10); // 返回大于等于10的第一个元素的迭代器
set <int> :: iterator it3 = s.upper_bound (10); // 返回大于10的第一个元素的迭代器
访问
// 迭代器访问
set <int> :: iterator it4;
for (it4 = s.begin (); it4 != s.end (); ++ it4)
{
cout << *it4 << " ";
}
cout << endl;
// 访问最后一个元素
cout << *s.rbegin () << endl;
set <int> :: iterator it5 = s.end ();
iter --;
cout << (*it5) << endl;
cout << * (-- s.end ()) << endl;
重载<运算符
基础数据类型
// 基础数据类型
set <int> s1;
set <int, greater <int> > s2;
高级数据类型（结构体）
struct node
{
int x, y;
bool operator < (const node & u) const
{
if (x != u.x)
return x < u.x;
return y < u.y;
}
};
set <node> s3;
for (int i = 1; i <= 5; ++ i)
{
int x, y;
cin >> x >> y;
s3.insert ({x, y});
}
set <node> :: iterator it6;
for (it6 = s3.begin (); it6 != s3.end (); it6 ++)
{
cout << it6 -> x << " " << it6 -> y << endl;
}
pair
初始化
pair <string, int> p1 ("s1", 1);
pair <string, int> p2;
pair <string, int> p;
p = {"s2", 2};
p = make_pair ("s3", 3);
p = pair <string, int> ("s4", 4);
访问
// 访问
pair <int, int> p3 [10];
for (int i = 0; i < 10; ++ i)
{
p3 [i] = {i, i};
cout << p3[i].first << " " << p3[i].second << endl;
}
string
初始化
string s1; // 生成空字符串
string s2 ("12345"); // 生成"12345"的复制品
string s3 ("12345", 0, 3); // //结果为"123"，从0位置开始，长度为3
string s4 ("123456", 5); // 结果为"12345" ，长度为5
string s5 (5, '1'); // 结果为"11111"
string s6 (s2, 2); // 结果为"345"，截取第三个元素（2对应第三位）到最后
访问
string s = "12345";
for (int i = 0; i < s.size (); ++ i)
{
cout << s[i] << " ";
}
cout << endl;
string ss [10];
for (int i = 0; i < 10; ++ i)
{
ss[i] = "#";
cout << ss[i] << i << endl;
}
读入
// 读入
string s;
cin >> s; // 读入字符串，遇空格，回车结束
getline (cin, s); // 读入一行字符串（包括空格），遇回车结束
// 注意: getline(cin, s)会获取前一个输入的换行符，需要在前面添加读取换行符的语句。
// 如：getchar() 或 cin.get()
int n;
cin >> n;
cin.get ();
getline (cin, s);
函数方法
| s.size() | 返回string对象的字符个数 |
| s.length() | 返回string对象的字符个数 |
| s.push_back() | 在末尾插入 |
| s.insert(pos,element) | 在pos位置插入element |
| s.append(str) | 在s字符串结尾添加str字符串 |
| s.erase(iterator p) | 删除字符串中p所指的字符 |
| s.erase(iterator first, iterator last) | 删除字符串中迭代器区间[first,last)上所有字符 |
| s.erase(pos, len) | 删除字符串中从索引位置pos开始的len个字符 |
| s.clear() | 删除字符串中所有字符 |
| s.replace(pos,n,str) | 把当前字符串从索引pos开始的n个字符替换为str |
| s.replace(l,r,str) | 把当前字符串[l,r)区间替换为str (l ,r为迭代器) |
| s.tolower(s[i]) | 转换为小写 |
| s.toupper(s[i]) | 转换为大写 |
| s.substr(pos,n) | 截取从pos索引开始的n个字符 |
| s.find (str, pos) | 在当前字符串的pos索引位置（默认为0）开始，查找子串str，返回找到的位置索引，-1表示查找不到子串 |
| s.find (c, pos) | 在当前字符串的pos索引位置（默认为0）开始，查找字符c，返回找到的位置索引，-1表示查找不到字符 |
| sort(s.begin(),s.end()); | 排序 |
string s = "12345";
cout << s.size () << endl; // 返回string对象的字符个数
s.push_back ('6'); // 在末尾插入
cout << s << endl;
s.insert (s.end (), '7'); // 在pos位置插入element
cout << s << endl;
s.append ("8"); // 在s字符串结尾添加str字符串
cout << s << endl;
s.erase (s.end () - 1); // 删除字符串中p所指的字符
cout << s << endl;
s.erase (s.begin (), s.end ()); // 删除字符串中迭代器区间[first,last)上所有字符
cout << s << endl;
s = "123";
s.erase (0, 3); // 删除字符串中从索引位置0开始的3个字符
cout << s << endl;
s.clear (); // 删除字符串中所有字符
s = "ABC";
s[0] = tolower (s[0]); // 转换为小写
cout << s << endl;
s = "abc";
s[0] = toupper (s[0]); // 转换为大写
cout << s << endl;
s = "12345";
cout << s.substr (0, 5) << endl; // 截取从0索引开始的5个字符
if (s.find ("12345", 0) != string :: npos)
cout << "true\n";
if (s.find ('1', 0) != string :: npos)
cout << "true\n";
sort (s.begin (), s.end ());
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
