常用的C++ STL

最新推荐文章于 2024-06-29 16:00:10 发布
最新推荐文章于 2024-06-29 16:00:10 发布
阅读量260 收藏 5
点赞数 4
分类专栏： codeforces 文章标签： 数据结构 队列 stl c++ 哈希
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46272108/article/details/113170546
版权

常用的C++ STL及例题

1. 顺序式容器

(1) vector（动态数组）

功能：

  1. 定义整型数组
    ① vector<int> a; 定义一个动态数组a，自动默认初始化为空
    ② vector<int> a(100); 定义一个动态数组a，有100个为0的元素
    ③ vector<int> a(100, 6); 定义一个动态数组，有100个为6的元素

  2. 定义string型数组
    ① vector<string> a(10, "null"); 10个值为null的元素
    ② vector<string> a(100,"hello"); 10个值为hello的元素
    ③ vector<string> b(a.begin(), a.end()); b是a的复制

  3. 定义结构型数组：
    struct point {int x, y;};
    vector<point> a; a是用来存坐标的

  4. 赋值：a.push_back(值); 在尾部添加元素

  5. 统计元素的个数：a.size();

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

  7. a.insert(a.begin() + i, k); 在第i个元素前面插入k

  8. a.insert(a.end(), 10, 5); 在尾部插入10个值为5的元素

  9. a.pop_back(); 删除末尾元素

  10. a.erase(a.begin() + i, a.end() + j); 删除区间[i, j - 1]的元素

  11. a.erase(a.begin()+2); 删除第3个元素

  12. a.resize(n); 将数组大小调为n

  13. a.clear(); 清空

  14. reverse(a.begin(), a.end()); 用函数reverse()翻转数组

  15. sort(a.begin(), a.end()); 排序

vector 例题

圆桌问题
Problem Description
圆桌上围坐着2n个人。其中n个人是好人，另外n个人是坏人。如果从第一个人开始数数，数到第m个人，则立即处死该人；然后从被处死的人之后开始数数，再将数到的第m个人处死……依此方法不断处死围坐在圆桌上的人。试问预先应如何安排这些好人与坏人的座位，能使得在处死n个人之后，圆桌上围坐的剩余的n个人全是好人。

Input
多组数据，每组数据输入：好人和坏人的人数n（<=32767）、步长m（<=32767）；

Output
对于每一组数据，输出2n个大写字母，‘G’表示好人，‘B’表示坏人，50个字母为一行，不允许出现空白字符。相邻数据间留有一空行。

Sample Input

2 3
2 4

Sample Output

GBBG

BGGB

约瑟夫环问题

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<map>
#include<vector>
#include<algorithm>

#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define ll long long
#define int ll
#define INF 0x3f3f3f3f
#define PI acos(-1)
#define MOD 1e9 + 7
#define mem(a, b) memset(a, b, sizeof a)
using namespace std;
int read(){int w = 1, s = 0;char ch = getchar();while (ch < '0' || ch>'9') { if (ch == '-') w = -1; ch = getchar(); }while (ch >= '0' && ch <= '9') { s = s * 10 + ch - '0';ch = getchar(); }return s * w;}
const int N = 70000;
vector<int> v;
bool ans[N];
signed main() {
	int n, m;
	while (~scanf("%lld%lld", &n, &m)) {
		v.clear(); //清空
		for (int i = 1; i <= n + n; i++) {
			v.push_back(i);
			ans[i] = true;//先都初始化为好人,true为好人，false为坏人 
		}
		int cnt = v.size(), cur = 0;
		//当坏人还没杀完，就一直循环 
		while (cnt > n) {
			cur = (cur + m - 1) % cnt;//因为圆桌是一个环，所以要取余 
			ans[v[cur]] = false;//把这个位置记为坏人
			//v.erase(a.begin()+i); 删除第i个元素
			v.erase(v.begin() + cur); //删除第cur个元素	
			cnt--;
		} 
		//输出 
		for (int i = 1; i <= n + n; i++) {
			if (ans[i]) printf("G");
			else printf("B");
			if (i % 50 == 0) printf("\n");
		}
		//这题的格式有点问题 
		if((n << 1) % 50 != 0) 
            printf("\n");
        printf("\n");
	}
	return 0;
}

(2) stack（栈）

栈的相关操作：


#include<stack>               头文件
stack<Type> s;                定义一个栈，Type为数据类型
s.top();                      返回栈顶元素，但不会在栈里删除该元素
s.pop();                      删除栈顶元素，但不会返回。
出栈（两步操作）：先用s.top()获得栈顶元素，再用s.pop()弹栈
s.size();                     返回栈中元素的个数
s.empty();                    判断栈是否为空

栈 —— 简单例题（HDU 1062）

题意：翻转字符串
题解：用栈的先进后出的特点来做

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<map>
#include<vector>
#include<stack> 
#include<algorithm>

#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define ll long long
#define int ll
#define INF 0x3f3f3f3f
#define PI acos(-1)
#define MOD 1e9 + 7
#define mem(a, b) memset(a, b, sizeof a)
#define print(n) printf("%lld\n", n);
using namespace std;
int read(){int w = 1, s = 0;char ch = getchar();while (ch < '0' || ch>'9') { if (ch == '-') w = -1; ch = getchar(); }while (ch >= '0' && ch <= '9') { s = s * 10 + ch - '0';ch = getchar(); }return s * w;}
const int N = 1010;
char str[N];
signed main() {
	int t = read();
	while (t--) {
		char ch;
		stack<char> s;
		while (true) {
			ch = getchar();//每次读入一个字符 
			if (ch == ' ' || ch == '\n' || ch == EOF) {
				while (!s.empty()) {
					printf("%c", s.top());//输出栈顶元素 
					s.pop();//弹栈 
				}
				//结束 
				if (ch == '\n' || ch == EOF) break; 
				printf(" ");
			}
			else s.push(ch);//入栈 
		}
		printf("\n"); 
	}
	return 0;
}

栈较复杂例题（HDU 1237）

简单计算器

Problem Description
读入一个只包含 +, -, *, / 的非负整数计算表达式，计算该表达式的值。

Input
测试输入包含若干测试用例，每个测试用例占一行，每行不超过200个字符，整数和运算符之间用一个空格分隔。没有非法表达式。当一行中只有0时输入结束，相应的结果不要输出。

Output
对每个测试用例输出1行，即该表达式的值，精确到小数点后2位。

Sample Input
1 + 2
4 + 2 * 5 - 7 / 11
0

Sample Output
3.00
13.36

对数字运算进行模拟：
① 如果遇到 ’ + ’ 或 ’ - '，先将相应的数字push入栈（如果是 ’ - ’ 则push数字的相反数）
② 如果遇到优先级大的 ’ * ’ 或 ’ / ’ 先将相应数字与栈顶元素进行运算后将结果push进入
③ 最后将栈中所有元素相加。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<vector>
#include<map>
#include<stack>
#include<algorithm>
 
#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define ll long long
#define int ll
#define INF 0x3f3f3f3f
#define PI acos(-1)
#define MOD 1e9 + 7
using namespace std;
int read()
{
    int w = 1, s = 0;
    char ch = getchar();
    while (ch < '0' || ch>'9') { if (ch == '-') w = -1; ch = getchar(); }
    while (ch >= '0' && ch <= '9') { s = s * 10 + ch - '0';ch = getchar(); }
    return s * w;
}
signed main()
{
    char c, s;
    char s;
    double n;
    //开头特殊处理:0 +'\n'时结束;
    while(~scanf("%lf%c",&n,&c)) {
        if(n == 0 && c=='\n') break;
        stack<double>stk;
        double ans=0;
        while(!stk.empty()) stk.pop();
        stk.push(n);
        while(~scanf("%c %lf",&s,&n)) {
            if (s == '+') stk.push(n);
            if (s == '-') stk.push(-n);
            if (s == '*') {
                double tmp = stk.top() * n;
                stk.pop();
                stk.push(tmp);
            }
            if (s=='/') {
                double tmp = stk.top() * 1.0 / n;
                stk.pop();
                stk.push(tmp);
            }
            c = getchar();
            if (c == '\n') break;
        }
        while (!stk.empty()) {
            ans += stk.top();
            st.pop();
        }
        printf("%.2lf\n",ans);
    }
    return 0;
}

(3) queue（队列）

queue的操作：
#include<queue>         头文件
queue<Type> q;          定义队列
q.push(s);              把s放入队列
q.front();              获取队首元素，但不会删除
q.pop();			    删除队首元素
q.back();			    返回队尾元素
q.size();				返回队列中元素个数
q.empty();				检查队列是否为空

栈和队列的简单例题（HDU 1702）

在这里插入图片描述
题意：模拟栈和队列：
栈是 FILO（先进后出 First In Last Out）
队列是 FIFO（先进先出 First In First Out）

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<map>
#include<vector>
#include<functional>
#include<algorithm>
#include<stack>
#include<queue>
#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define ll long long
#define int ll
#define INF 0x3f3f3f3f
#define PI acos(-1)
#define MOD 1000000007
#define mem(a, b) memset(a, b, sizeof a)
#define print(n) printf("%lld\n", n)
using namespace std;
int read()
{
	int w = 1, s = 0;
	char ch = getchar();
	while (ch < '0' || ch>'9') { if (ch == '-') w = -1; ch = getchar(); }
	while (ch >= '0' && ch <= '9') { s = s * 10 + ch - '0';ch = getchar(); }
	return s * w;
}
signed main() {
	int t = read();
	while (t--) {
		string str;
		queue<int> q;
		stack<int> stk;
		int n = read();
		cin >> str;
		for (int i = 1; i <= n; i++) {
			string s;
			cin >> s;
			//队列 
			if (str == "FIFO") {
				if (s == "IN") {
					int a = read();
					q.push(a);//IN，放进队列 
				} else {
					if (q.empty()) printf("None\n");//如果队列为空，此时还要求输出的话，那么就是None 
					else {
						printf("%lld\n", q.front());//输出队首元素
						q.pop(); //删除队首元素 
					}
				}
			} else {
				if (s == "IN") {
					int a = read();
					stk.push(a);//IN，放入栈中 
				} else {
					if (stk.empty()) printf("None\n");//如果栈为空，此时还要求输出的话，那么就是None 
					else {
						printf("%lld\n", stk.top());//输出栈顶元素 
						stk.pop();//弹栈：删除栈顶元素 
					}
				}
			}
		}
	}
	return 0;
}

2. 关联式容器

(1) set（集合）

  1. set与数组不同的是，在set中每个元素的值都是唯一的。
  2. set插入数据时，能够根据元素的值自动进行排序。
  3. set中数元素的值并不能直接被改变。
set的有关操作：
set<Type> a;            定义一个set
a.insert(x);		    把x放进set
a.erase(x);			    删除元素x
a.clear();              清空set
a.empty(); 			    判断set是否为空
a.size();				返回set中元素个数
a.find(x);				返回一个迭代器，指向键值x
a.lower_bound(x);		返回一个迭代器，指向键值不小于x的第一个元素
a.upper_bound(x);		返回一个迭代器，指向键值不大于x的第一个元素

set 简单例题 （HDU 2094）

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<map>
#include<vector>
#include<functional>
#include<algorithm>
#include<stack>
#include<set>
#include<queue>

#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define ll long long
#define int ll
#define INF 0x3f3f3f3f
#define PI acos(-1)
#define MOD 1000000007
#define mem(a, b) memset(a, b, sizeof a)
#define print(n) printf("%lld\n", n)
using namespace std;
int read()
{
	int w = 1, s = 0;
	char ch = getchar();
	while (ch < '0' || ch>'9') { if (ch == '-') w = -1; ch = getchar(); }
	while (ch >= '0' && ch <= '9') { s = s * 10 + ch - '0';ch = getchar(); }
	return s * w;
}
signed main() {
	int n;
	while (cin >> n && n) {
		string winner, loser;
		set<string> all, lose;
		//利用了set中每个元素的值都是唯一的
		for (int i = 1; i <= n; i++) {
			cin >> winner >> loser;
			//把所有人放入all集合中 
			all.insert(winner);
			all.insert(loser);
			//把输的人放到lose集合中 
			lose.insert(loser);
		}
		//冠军没输过，如果能确定冠军，就是其他人都输过了，那么all.size() - lose.size() == 1 
		if (all.size() - lose.size() == 1) printf("Yes\n");
		else printf("No\n");
		//清空两个集合 
		all.clear();
		lose.clear(); 
	}
	return 0;
}

(2) map（一对一映射）

之所以要用到map，这么一个简单的例子：有n个学生，每个学生有姓名name和学号id，现在给出学生的name，要找对应的id。

那就是要把该学生的 name 和 id 通过一个东西来绑定。

如果没有用map的话，那么可以用结构体

struct Student{
	string name;
	int id;
}s[N];

但是如果用结构体的话，给出 name 来找到 id 就需要线性查找这个时间复杂度是 O ( n ) O(n) O(n) 的。

如果用map的话，可以对这个优化。因为map效率高的原因是它用平衡二叉搜索树来存储和访问。

map的相关操作：
map<string, int> stu;            定义map<Type, Type>;
stu["QYIF"] = 09                 绑定了name为 "QYIF" 的人，它的学号为 9号

用map就可以直接用 stu["QYIF"] 来表示 "QYIF" 这个人的学号。

map + 迭代器的简单例题 （HDU 2648）

在这里插入图片描述
题意：这个叫 Dandelion 的女孩，喜欢购物，她很喜欢这个叫 memory 的商店，临近年关，现在她想知道这家商店每天的价格排名。

题解：给这个memory商店初始化排名为1，用迭代器遍历，如果it->second （其他商店的价格比memory高）那么就rank++；就可以了

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<map>
#include<vector>
#include<functional>
#include<algorithm>
#include<stack>
#include<set>
#include<queue>

#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define ll long long
#define int ll
#define INF 0x3f3f3f3f
#define PI acos(-1)
#define MOD 1000000007
#define mem(a, b) memset(a, b, sizeof a)
#define print(n) printf("%lld\n", n)
using namespace std;
signed main() {
    IOS;
	int n, m, price;
	while (cin >> n) {
		map<string, int> shop;
		string str;
		for (int i = 1; i <= n; i++) cin >> str;
		int m;
		cin >> m;
		while (m--) {
		    for (int i = 1; i <= n; i++) {
		        cin >> price >> str;
		        shop[str] += price;//给商店加上价格
		    }
		    int rank = 1;
		    map<string, int>::iterator it;//迭代器
		    //遍历
		    for (it = shop.begin(); it != shop.end(); it++) {
		        if (it->second > shop["memory"]) rank++;//如果遇到比memory这个商店的价格高就+1
		    }
		    printf("%lld\n" ,rank);
		}
	}
	return 0;
}

3. sort() 排序函数

#include<algorithm>             头文件
sort(a, a + n)                  格式1
sort(a, a + n, cmp)				格式2 （cmp为排序的规则）

拓展用法：
vector<int> a = {3, 2, 4, 6, 7}
sort(a.begin(), a.end()); 				正常用法
sort(a.begin(), a.end(), 4); 			对前4个元素进行排序，输出2 3 4 6 7
sort(a.begin(), a.end(), less<int>); 	从小到大排序
sort(a.begin(), a.end(), greater<int>); 从大到小排序
sort(a.begin(), a.end(), cmp)  			自定义排序，cmp是自定义函数

对结构变量排序：
struct stu{
	string name;
	int id;
};
bool cmp(struct stu* a, struct stu *b) {
	//自定义排序，例如id从小到大排序
	return a->id < b->id;
}
vector<struct Stu*> message; //将学生信息存入message
sort(message.begin(), message.end(), cmp);

4. next_permutation()和prev_permutation()

next_permutation() 下一个排列组合。
prev_permutation() 上一个排列组合。
例如3个字符 a、b、c next_permutation() 能按照字典序返回6个组合，分别是：abc、acb、bac、bca、cab、cba

会划水才能到达彼岸
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++常用的STL
qq_34754747的博客
02-27 409
一、字符串 头文件 #include <string> 1、string类常用的构造函数 string str ("ABC", strlen) // 将"ABC"存到str里,最多存储前strlen个字节 string s("ABC",stridx,strlen) //将"ABC"的stridx位置,做为字符串开头,存到str里.且最多存储strlen个字节. string s(strlen, 'A') //存储strlen个'A'到str里 2、strin.
C++ STL常用操作
Yerkeys的博客
02-11 428
  目录 一、vector 1.vector 的初始化 2.vector对象的常用操作 3.顺序访问vector方式 4.常用算法 二、pair 1、创建和初始化 2、pair对象操作 三、stack 定义stack对象： stack的基本操作： 四、queue 定义queue对象 queue的基本操作 优先队列priority_queue 五、algorithm...
学习STL（动态数组vector）
2201_75723947的博客
11-18 141
一、标准模板库（Standard Template Library，STL）是HP公司开发的一个C++模板库，包含一些常用的数据结构和算法。具有以下的组件：1.容器：容纳包含一组元素的对象。2.迭代器：提供访问容器的方法3.函数对象4.算法二、STL之向量——vectorvector是c++标准库提供的一个变长数组类型，它可以像数组一样进行数据的存储和访问。2.vector会根据需要自动扩展其自身的容量来容纳更多的数据。3.vector的内部存储结构和数组一样，使用的是一段连续的存储空间。
C++中动态与静态数组用法
10-07 2986
在使用c++进行数据处理时，常常会涉及到数组的使用，数组可以分为静态数组与动态数组，其中静态数组长度已被限制，往往无法满足实际需要。现在主要对动态数组的使用，以及返回动态数组的函数的使用进行小结。1、静态数组的声明 如声明长度为10的整数一维数组int array[10]; 其他类型的一维数组声明类似，不再进行详述。注： int array[变量] 程序报错：变量必须是个常量2、动态数组的声明及使用 原理：动态数组是通过云算符new进行创建，而数组变量实际上是个指针，因此利用new符号创建的数组，可以当..
C++中的STL库
最新发布
L_xuansg的博客
06-29 1064
STL（Standard Template Library，标准模板库）是 C++ 中的一个重要部分，提供了丰富的通用模板类和函数模板，用于实现常见的数据结构和算法。它的设计目标是提供高效、灵活和可复用的程序组件，使得开发者可以更加专注于问题的解决而不是数据结构和算法的实现细节。
C++常用STL讲解
折叠伞的博客
02-27 5622
关于STL（标准模板库） Standard Template Library,缩写：STL STL是一个C++软件库，里面包含算法（algorithms)、容器(containers)、函数(functions)、迭代器(iterators) C语言版本 #include<stdio.h> int main(){ int a,b; scanf("%d%d",&a,&b); printf("%d",a+b); return 0; } C++版本 #
c++---STL常用算法
m0_50046535的博客
04-25 3355
概述： 算法主要是由头文件<algorithm><functional><numeric>组成 <algorithm>是所有stl头文件中最大的一个，涉及比较，交换，查找，遍历，复制，修改等操作 <numeric>体积很小，只包括几个在序列上进行简单数学运算的模板函数 <functional>定义了一些类模板，用以声明函数对象 一、常用遍历算法 for_each 遍历容器 transform 搬运容...
C++常用STL
woshihaoren__的博客
03-24 349
include //引用头文件//定义一个int类型的vector容器avector b[100] //定义一个int类型b数组在vector容器的每个空间中//vector的迭代器，与指针相似//定义一个int类型的queue容器qi//定义一个string类型的queue容器qs//定义一个key值为char，value值为int类型数据map是一个关联容器，他提供一对一的hash。
C++ STL教程pdf
05-10
C++ STL，全称为Standard Template Library（标准模板库），是C++编程语言中不可或缺的一部分，它为程序员提供了高效且灵活的编程工具。STL的核心概念包括泛型编程、容器、迭代器、算法和函数对象，这些组件共同构成...
c++ STL模板
11-08
向量vector是一种随机访问的数组类型，提供了对数组元素的快速、随机访问以及在序列尾部快速、随机的插入和删除操作。它是大小可变的向量，在需要是可以改变其大小。 形式：
C++STL手册.rar
09-23
**C++ STL（Standard Template Library）手册** C++ STL 是 C++ 标准库中的一个核心部分，它提供了一组高效、可重用的容器、算法和迭代器模板类。STL 的设计思想源于泛型编程，使得程序员可以编写与数据类型无关的...
C++ STL 参考手册Cpp_STL_ReferenceManual.pdf
12-21
C++ 对模板（Template）支持得很好，STL 就是借助模板把常用的数据结构及其算法都实现了一遍，并且做到了数据结构和算法的分离。例如，vector 的底层为顺序表（数组），list 的底层为双向链表，deque 的底层为循环...
C++标准库STL源码
03-24
它是C++标准库的一个重要实现,对STL的发展和推广产生了重大影响。 SGI STL的源码是开源的,其设计和实现体现了诸多优秀的编程思想和技巧。下面是对SGI STL源码的一些关键特点和描述:泛型编程、算法与容器的分离、...
【C++】常见的STL使用
weixin_57133810的博客
07-12 853
C++中常见的一些STL的使用方法以及注意事项。
C++ STL详解超全总结(快速入门STL)
热门推荐
行码棋
02-24 15万+
C++STL合集，包含vector，stack，queue，map，set，array，tuple，deque，priority_queue等诸多内容，全文上万字。
C++常用基础知识—STL库(1)
weixin_51141489的博客
06-30 1251
本文介绍C++常用的STL库知识，常用的函数及其用法，为备战C++编程比赛的朋友及对STL库函数应用时的快速查找提供方便。 后续还会继续更新，请大家多多支持！！
【C++】 STL详解
m0_56051805的博客
10-01 2万+
【C++】 STL详解
C++ STL汇总
Skynet的博客
07-05 707
C++ STL学习笔记
C++STL深度学习指南
"C++STL开发技术导引" C++ STL（Standard Template Library，标准模板库）是C++编程中一个重要的组成部分，它提供了一组高效、灵活的容器、迭代器、算法和函数对象，极大地简化了数据结构和算法的实现。STL的主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值