C++标准模板库(STL)笔记与示例
2024-04-20 22:26:17
C++标准模板库知识点：
/*一、主要内容：
sort //必会！
next_permutation() //记住怎么调用
list //
stack //调用类库
queue //调用类库
vector //是一个容器，主要用于树和图的存储
set
迭代器 //以上两个主要用于处理集合，判重，排序
map //是一个映射，处理某些映射关系
dequedu //双端队列
priority_queue //优先队列（堆排）
*//*二、C++标准模板库（Standard Template Library）含有很多常用的算法与数据结构，使用时只需要一行代码调用出来实现各种操作即可，不需要自己写很长的代码。能极大地简化编程减少BUG。例如：①最大值最小值（别看简单，c语言自身却没有这个）template<class_Tp>_Tp min(_Tp a,_Tp b)template<class_Tp>_Tp max(_Tp a,_Tp b)②快速排序：sort(a,a+10);③数据交换：swap(a,b);④求下一个排列：next_permutation⑤顺序式容器：vector 不限制长度的数组list 链表deque 双向队列queue 队列priority_queue 优先队列stack 栈⑥关联式容器：set 集合（一种较高效率的平衡二叉树）（可判重）multiset （不判重）map 映射（通过键值来建立的平衡二叉树）multimap
*//*2.1 sort:（见eg1、eg2）
STL排序函数sort():是最常用的函数之一
定义有两种：void sort(RandomAccessIterator first,RandomAccessIterator last);void sort(RandomAccessIterator first,RandomAccessIterator last,Compare comp);
返回值：无。
复杂度：O(nlogn)。
它排序的范围是[first,last),包括first,不包括last。
sort可以用自定义的比较函数进行过排序，也可以用系统的四种排序：less(升序)、greater(降序)、less_equal、greater_equal。
缺省情况下，程序按从小到大的顺序排序，less可以不写。
*/
//综合表达：
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector> //注：本电脑不支持万能头文件#include <bits/stdc++.h>，需要记住其他几个头文件
using namespace std;
bool my_less(int i, int j) {return (i < j);}
bool my_greater(int i,int j){return (i > j);}
int main(){vector<int> a = {3,7,2,5,6,8,5,4};sort(a.begin(),a.begin()+4); //对前4个排序，输出2 3 5 7 6 8 5 4// sort(a.begin(),a.end()); //从小到大排序，输出2 3 4 5 5 6 7 8// sort(a.begin(),a.end(),less<int>()); //输出2 3 4 5 5 6 7 8// sort(a.begin(),a.end(),my_less); //自定义排序，输出2 3 4 5 5 6 7 8// sort(a.begin(),a.end(),greater<int>()); //从大到小排序，输出8 7 6 5 5 4 3 2// sort(a.begin(),a.end(),my_greater); //输出8 7 6 5 5 4 3 2for(int i=0;i<a.size();i++){ //输出cout<<a[i]<<" ";}cout<<endl;return 0;
}/*2.2 next_permutation()：(见eg3)
next_permutation()：求“下一个”排列组合(全排列)。
例如三个字符{a,b,c}组成的序列，next_permutation()能按字典序返回6个组合：
abc,acb,bac,bca,cab,cba。
*//*2.3 链表和list:（见eg4）
STL的list:双向链表。它的内存空间不必连续，通过指针来进行数的访问，高效率地在任意地方删除和插入，
插入和删除操作是常数时间。
list和vector的优缺点正好相反，它们的应用场景不同：（1）vector:插入和删除操作少，随机访问元素频繁；（2）list:插入和删除频繁，随机访问较少。
*//*2.4 stack:（见eg5）
例子 说明
a.push_back(100); 定义栈，Type为数据类型，如int、float、char等。
s.push(item); 把item放到栈顶（入栈）。
s.top(); 返回栈顶的元素，但不会删除。
s.pop(); 删除栈顶的元素，但不会返回（出栈）。
s.size(); 返回栈中元素的个数。
s.empty(); 检查栈是否为空，如果为空返回true,否则返回false。
*//*2.5 queue:(见eg7)
例子 说明
queue<Type>q; 定义栈，Type为数据类型，如int,float,char等
q.push(item); 把item放进队列
q.front(); 返回队首元素，但不会删除
q.pop(); 删除队首元素
q.back(); 返回队尾元素
q.size(); 返回元素个数
q.empty(); 检查队列是否为空
*//*2.6 vector:
①首先是最基础的数据访问功能：top()back()
②其次是简单的数据操作：erase(int index,int size) 删除insert(int index,int size) 插入 push_back(int value) 添加到数据后面pop_back() 弹出最后一个数据
③还有一些自身属性操作：数据大小size()重新整理内存单元resize(int size)
④最后是整体的操作：clear() 清空empty() 是否为空功能 例子 说明
定义int型数字 vector<int>a; 默认初始化，a为空vector<int>b(a); 用a定义bvector<int>a(100); a有100个值为0的元素vector<int>a(100,6); 100个值为6的元素
定义string型数组 vector<string>a(10,"null"); 10个值为null的元素vector<string>vec(10,"hello"); 10个值为hello的元素vector<string>b(a.begin(),a.end()); b是a的复制
定义结构型数组 struct point {int x,y;}; vector<point>a; a用来存坐标功能 例子 说明
赋值 a.push_back(100); 在尾部添加元素
元素个数 int size = a.size(); 元素个数
是否为空 bool isEmpty = a.empty(); 判断是否为空
打印 cout<<a[0]<<endl; 打印第一个元素
中间插入 a.insert(a.begin()+i,k); 在第i个元素前面插入k
尾部插入 a.insert(a.end(),10,5); 尾部插入10个值为5的元素
尾部插入 a.push_back(8); 尾部插入值为8的元素
删除尾部 a.pop_back(); 删除末尾元素
删除区间 a.erase(a.begin()+i,a.begin()+j); 删除区间[i,j-1]的元素
删除元素 a.erase(a.begin()+2); 删除第3个元素
调整大小 a.resize(n); 数组大小变为n
清空 a.clear();
翻转 reverse(a.begin(),a.end()); 用函数reverse翻转数组
排序 sort(a.begin(),a.end()); 用函数sort排序，从小到大
*//*2.7 set:（见eg8）
set(集合)用二叉搜索树实现，集合中的每个元素只出现一次，且是排好序的。访问元素的时间复杂度是O（logn）的。
set和map在竞赛题中应用很广泛。特别是需要用二叉搜索树处理数据的题目，如果用set或map实现，能极大地简化代码。例子 说明
set<Type>A; 定义
A.insert(item); 把item放进set
A.erase(item); 删除元素item
A.clear(); 清空set
A.empty(); 判断是否为空
A.size(); 返回元素个数
A.find(k); 返回一个迭代器，指向键值k
A.lower_bound(K); 返回一个迭代器，指向键值不小于k的第一个元素
A.upper_bound(); 返回一个迭代器，指向键值大于k的第一个元素
*//*2.8 迭代器：（见eg9）
定位：既能像指针一样访问数据，又能保证整体工程的稳定性。
实际作用：用于访问一个容器内的数据的指针。
具体实现：返回第一个元素的迭代器begin()返回容器末尾的迭代器end() 遵循左开右闭原则
*//*2.9 map:（见eg10）
map:关联容器，实现从键（key）到值（value）的映射。
map效率高的原因：用平衡二叉搜索树来存储和访问。
例如：有n个学生，每人有姓名name和学号id。给定一个学生的name,要求查找他的id。简单的做法是：定义string name[n]和int id[n](可以放在一个结构体中)存储信息，然后在name[]中查找这个学生，找到后输出他的id。这样做的缺点是，需要搜索所有的name[],复杂度是O(n)，效率很低。
利用STL中的map容器，可以快速地实现这个查找，复杂度是O(logn)。
*//*2.10 双端队列：
dequeue<int> q
访问队首元素，如例：q.front(),即最早被压入队列的元素。
访问队尾元素，如例：q.back(),即最后被压入队列的元素。
*//*2.11 优先队列：（见eg11）
priority_queue< > q[]; //<>中放的是所插入的数据类型，[]中放的是优先队列的维数即需要放入几个优先队列。
q.top(); //返回具有最高优先级的元素值，但不删除该元素
q.pop(); //删除最高优先级元素
q.push(item); //插入新元素
STL中，优先队列是用二叉堆来实现的，往队列中push入一个数或pop一个数，复杂度是O(logn)。
图论的Dijkstra算法的程序实现，用STL的优先队列能极大地简化代码。
*/eg1. sort数组排序
/*A - 例1 sort数组排序
Description
给你n个整数，请按从大到小的顺序输出其中前m大的数。
Input
每组测试数据有两行，第一行有两个数n,m(0<n,m<1000000)，第二行包含n个各不相同，且都处于
区间[-500000,500000]的整数。 //[注]：scanf速度是cin的十倍，对于很大的数在程序限时的情况下要用scanf
Output
对每组测试数据按从大到小的顺序输出前m大的数。
Sample Input
5 3
3 -35 92 213 -644
Sample Output
213 92 3
*/#include <iostream>
#include <algorithm>
#include <cstdio>
//#include <bits/stdc++.h> //万能头文件
using namespace std;
bool cmp(int a,int b){ //定义一个排序规则函数return a>b;
}
int a[1000010]; //①数组一定要适当开大，防止越界；②特别注意：大数组要定义为全局变量，不能定义在函数内。全局变量在静态存储区分配内存，局部变量是在栈上分配内存空间的。（c语言程序在运行时会动态创建一个堆栈段，里面存放着调用栈，保存着函数的调用关系和局部变量。）如果数组太大，可能会造成栈溢出。（定义在函数外的为全局变量，定义在函数内的为局部变量）
int main(){int num1,num2;while(cin>>num1>>num2){ for(int i=0;i<num1;i++){scanf("%d",&a[i]);}sort(a,a+num1,cmp); //如果之前不定义一个判断函数cmp，sort()是默认按照升序排列的for(int j=0;j<num2;j++){cout<<a[j]<<" ";}cout<<endl;}return 0;
}eg2. sort结构体排序
/*B - 例2 sort结构体排序
Description
将气球按照权值的从大到小进行排序
Input
第一行是一个整数T,表示用例号。
对于每种情况，第一行是一个整数n，这是问题的个数。
接下来有n行，每一行都有一个字符串和一个整数，在第i行中，字符串表示第i个问题的气球的颜色，
整数表示气球的权值。 //此时就需要用一个结构体同时记录颜色和权值，进行一个捆绑式的排序。
Output
对于每种情况，都需要输出一行。
一行中应该有n个字符串表示你选择的解决顺序。
请确保每两个字符串之间只有一个空格，没有多余的空格。Sample Input
3
3
red 1
green 2
yellow 3
1
blue 83
2
red 2
white 1Sample Output
yellow green red
blue
red white
*/#include <iostream>
#include <string>
#include <algorithm>
#include <cstdio>
using namespace std;
struct ss{string color;int value;
}num[555];
bool cmp(ss a,ss b){ //定义排序规则return a.value>b.value;/*if(a.value==b.value){return a.color>b.color;}else{return a.value>b.value;}*/
}
int main(){int t;cin>>t;while(t--){int n;cin>>n;getchar();for(int i=0;i<n;i++){cin>>num[i].color;cin>>num[i].value;}sort(num,num+n,cmp);for(int i=0;i<n-1;i++){ //此处循环设置i<n-1，等最后输出num[n-1].color是为了最后一个颜色输出后不再输出一个空格。//num[i].color;cout<<num[i].color<<" ";}cout<<num[n-1].color<<endl;//cout<<endl;}return 0;
}eg3. 用next_permutation()输出“下一个”排列组合
/*C - 例3 用next_permutation()输出“下一个”排列组合 //法二：深度优先搜索。但需自己写代码。
Description
给定n个数字，从1到n,要求输出第m小的序列。
Input
由数字n和m组成，1 <= n <= 1000,1 <= m <= 10000.
Output
输出第m小的序列。Sample Input
6 4
11 8
Sample Output
1 2 3 5 6 4
1 2 3 4 5 6 7 9 8 11 10
*/#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int main(){int n,m;while(cin>>n>>m){int a[2000];for(int i=0;i<n;i++){a[i]=i+1;}int p;p=0;do{p++;if(p==m){for(int i=0;i<n-1;i++){cout<<a[i]<<" ";}cout<<a[n-1]<<endl;break;}}while(next_permutation(a,a+n));}return 0;
}eg4.链表应用
/*D - 例4
Description
某部队进行新兵队列训练，将新兵从一开始按顺序依次编号，并排成一行横队，训练的规则如下：
从头开始一至二报数，凡报到二的出列，剩下的向小序号方向靠拢，再从头开始进行一至三报数，凡报到三
的出列，剩下的向小序号方向靠拢，继续从头开始进行一至二报数...，以后从头开始轮流进行一至二报数、
一至三报数直到剩下的人数不超过三人为止。 //注意报数是按一至二全部报完一遍再从头一至三全部报完一遍...
Input
本题有多个测试数据组，第一行为组数N，接着为N行新兵人数，新兵人数不超过5000。
Output
共有N行，分别对应输入的新兵人数，每行输出剩下的新兵最初的编号，编号之间有一个空格。
Sample Input
2
20
40
Sample Output
1 7 19
1 19 37
*/#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <string>
#include <cmath>
#include <list>
using namespace std;
int main(){int t,n;cin>>t;while(t--){cin>>n;int k;k=2;list<int >blist;list<int >::iterator it; //定义链表迭代器for(int i=1;i<=n;i++){blist.push_back(i);}while(blist.size()>3){int num;num=1;for(it=blist.begin();it!=blist.end();){if(num++%k==0){it=blist.erase(it);}else{it++;}}if(k==2){k=3;continue;}else{k=2;continue;}//k==2?k=3:k=2;}for(it=blist.begin();it!=blist.end();it++){if(it!=blist.begin()){cout<<" ";}cout<<*it;}cout<<endl;}return 0;
}eg5. 栈的应用
/*E - 例5 栈的应用
Description
输入测试例子数量t，然后输入t行字符串，将每一行的每一个单词逆序后输出该行的语句（字符串）Sample Input
3
olleh !dlrow
m'I morf .udh
I ekil .mcaSample Output
hello world！
I'm from hdu.
I like acm.
*/#include <iostream>
#include <stack>
#include <string>
#include <cstdio>
#include <algorithm>
using namespace std;
int main(){string s;int t;cin>>t;getchar();while(t--){getline(cin,s);int len;len=(int )s.size();stack<char >st;for(int i=0;i<len;i++){if(s[i]!=' '){st.push(s[i]);}if(s[i]==' '||i==len-1){while(!st.empty()){printf("%c",st.top());st.pop();}if(s[i]==' '){cout<<" ";}}}cout<<endl;}return 0;
}eg7. 栈和队列的应用
/*G - 例7 栈和队列的应用
Description
第一行是整数N(命令数)，以及单词“FIFO”或“FILO”，FIFO表示“先进先出”，FILO表示“先进后出”
随后的N行，每行是“IN M”或“OUT”，对于每一个“OUT”输出对应的数值，没有数值输出“None”Sample Input
4
4 FIFO
IN 1
IN 2
OUT
OUT
4 FILO
IN 1
IN 2
OUT
OUT
5 FIFO
IN 1
IN 2
OUT
OUT
OUT
5 FILO
IN 1
IN 2
OUT
IN 3
OUTSample Input
1
2
2
1
1
2
None
2
3
*/#include <iostream>
#include <cstdio>
#include <queue>
#include <stack>
#include <string>
#include <algorithm>
using namespace std;
int main(){int t;cin>>t;while(t--){int n;cin>>n;string s1,s2;cin>>s1;if(s1=="FIFO"){queue<int>qu;while(n--){cin>>s2;if(s2=="IN"){int num;cin>>num;qu.push(num);}else{if(qu.empty()){cout<<"None"<<endl;}else{cout<<qu.front()<<endl;qu.pop();}}}}else{stack<int>st;while(n--){cin>>s2;if(s2=="IN"){int num;cin>>num;st.push(num);}else{if(st.empty()){cout<<"None"<<endl;}else{cout<<st.top()<<endl;st.pop();}}}}}return 0;
}eg8. 产生冠军（集合set的应用）
/*H - 例8 产生冠军（集合set的应用）
Description
有一群人，打乒乓球比赛，两两捉对撕杀，每两个人之间最多打一场比赛。
球赛的规则如下：
如果A打败了B，B又打败了C，而A与C之间没有进行过比赛，那么就认定，A一定能打败C。
如果A打败了B，B又打败了C，而且，C又打败了A，那么A、B、C三者都不可能成为冠军。
根据这个规则，无需循环较量，或许就能确定冠军。你的任务就是面对一群比赛选手，在经过了若干场撕杀
之后，确定是否已经实际上产生了冠军。
Input
输入含有一些选手群，每群选手都以一个整数n(n<1000)开头，后跟n对选手的比赛结果，比赛结果以一对
选手名字（中间隔一空格）表示，前者战胜后者。如果n为0，则表示输入结束。
Output
对于每个选手群，若你判断出产生了冠军，则在一行中输出“Yes”，否则在一行中输出“No”。 Sample Input
3
Alice Bob
Smith John
Alice Smith
5
a c
c d
d e
b e
a d
0
Sample Output
Yes
No
*/#include <iostream>
#include <string>
#include <set>
using namespace std;
int main(){int t;while(cin>>t){if(t==0){break;}set<string>st1,st2;string s1,s2;while(t--){cin>>s1>>s2;st1.insert(s1);st1.insert(s2);st2.insert(s2);}if(st1.size()-st2.size()!=1){cout<<"No"<<endl;}else{cout<<"Yes"<<endl;}}return 0;
}eg9. 迭代器应用
/*I - 例9 迭代器应用
Description
参加过上个月月赛的同学一定还记得其中的一个最简单的题目，就是{A}+{B}，那个题目求的是两个集合的
并集，今天我们这个A-B求的是两个集合的差，就是做集合的减法运算。（当然，大家都知道集合的定义，
就是同一个集合中不会有两个相同的元素，这里还是提醒大家一下）
Input
每组输入数据占1行,每行数据的开始是2个整数n(0<=n<=100)和m(0<=m<=100),分别表示集合A和集合B的
元素个数，然后紧跟着n+m个元素，前面n个元素属于集合A，其余的属于集合B. 每个元素为不超出int范围
的整数,元素之间有一个空格隔开.
如果n=0并且m=0表示输入的结束，不做处理。
Output
针对每组数据输出一行数据,表示A-B的结果,如果结果为空集合，则输出“NULL”,否则从小到大输出结果,
为了简化问题，每个元素后面跟一个空格. Sample Input
3 3 1 2 3 1 4 7
3 7 2 5 8 2 3 4 5 6 7 8
0 0
Sample Output
2 3
NULL
*/#include <iostream>
#include <set>
using namespace std;
int main(){int num1,num2;while(cin>>num1>>num2){if(num1==num2&&num1==0){break;}int num;set<int>st;for(int i=0;i<num1;i++){cin>>num;st.insert(num);}for(int i=0;i<num2;i++){cin>>num;if(st.find(num)!=st.end()){st.erase(num);}}if(st.size()==0){cout<<"NULL"<<endl;continue;}set<int >::iterator it;for(it=st.begin();it!=st.end();it++){cout<<*it<<" ";}cout<<endl;}return 0;
}eg10.
/*J - 例10
Description
女孩dandelion经常去购物，她特别喜欢一家叫“memory”的商店。由于春节快到了，所有商店的价格每天都在上涨。她想知道这家商店每天的价格排名。
Input
第一行是数字n（n <= 10000）,代表商店的数量。
后面n行，每行有一个字符串（长度小于31，只包含小写字母和大写字母）表示商店的名称。
然后一行是数字m（1 <= m <= 50）,表示天数。
后面有m部分，每部分有n行，每行是数字s和一个字符串p，表示商店p在这一天涨价s。
Output
包含m行，第i行显示第i天后店铺“memory”的排名。排名的定义为：如果有t个商店的价格高于“memory”,
那么它的排名是t+1。Sample Input
3
memory
kfc
wind
2
49 memory
49 kfc
48 wind
80 kfc
85 wind
83 memorySample Output
1
2
*/#include <iostream>
#include <string>
#include <map>
using namespace std;
int main(){int t;while(cin>>t){for(int i=0;i<t;i++){string s;cin>>s;}int n;cin>>n;map<string,int>shop;while(n--){for(int i=0;i<t;i++){string na;int p;cin>>p;cin>>na;shop[na]+=p;}map<string, int>::iterator it;int ans;ans=1;for(it=shop.begin();it!=shop.end();it++){if(it->second>shop["memory"]){ans++;}}cout<<ans<<endl;}}return 0;
}eg11.
/*K - 例11
Description
看病要排队这个是地球人都知道的常识。
不过经过细心的0068的观察，他发现了医院里排队还是有讲究的。0068所去的医院有三个医生同时看病。
而看病的人病情有轻重，所以不能根据简单的先来先服务的原则。所以医院对每种病情规定了10种不同的
优先级。级别为10的优先权最高，级别为1的优先权最低。医生在看病时，则会在他的队伍里面选择一个
优先权最高的人进行诊治。如果遇到两个优先权一样的病人的话，则选择最早来排队的病人。
现在就请你帮助医院模拟这个看病过程。
Input
输入数据包含多组测试，请处理到文件结束。
每组数据第一行有一个正整数N(0<N<2000)表示发生事件的数目。
接下来有N行分别表示发生的事件。
一共有两种事件： 1:"IN A B",表示有一个拥有优先级B的病人要求医生A诊治。(0<A<=3,0<B<=10) 2:"OUT A",表示医生A进行了一次诊治，诊治完毕后，病人出院。(0<A<=3)
Output
对于每个"OUT A"事件，请在一行里面输出被诊治人的编号ID。如果该事件时无病人需要诊治，则输出"EMPTY"。
诊治人的编号ID的定义为：在一组测试中，"IN A B"事件发生第K次时，进来的病人ID即为K。从1开始编号。 Sample Input
7
IN 1 1
IN 1 2
OUT 1
OUT 2
IN 2 1
OUT 2
OUT 1
2
IN 1 1
OUT 1Sample Output
2
EMPTY
3
1
1
*/#include <iostream>
#include <queue>
#include <algorithm>
#include <cstdio>
#include <string>
using namespace std;
struct node{int value,id;bool operator <(const node &b)const{if(value==b.value){return id>b.id;}else{return value<b.value;}}
};
int main(){int t;while(cin>>t){node pep;priority_queue<node >q[10];int timt;timt=1;string s;while(t--){cin>>s;if(s=="IN"){int a;cin>>a>>pep.value;pep.id=timt;timt++;q[a-1].push(pep);}else{int a;cin>>a;if(q[a-1].empty()){cout<<"EMPTY"<<endl;}else{cout<<q[a-1].top().id<<endl;q[a-1].pop();}}}}return 0;
}C++标准模板库(STL)笔记与示例相关推荐
- 蓝桥杯算法竞赛系列第0章——蓝桥必考点及标准模板库STL（上）（万字博文，建议抱走）
欢迎来到:遇见蓝桥遇见你,不负代码不负卿! 目录 一.蓝桥必考点剖析 二.什么是STL 三.vector的常见用法详解 1.vector的定义 2.vector容器内元素的访问 (1).通过下标访 ...
- 标准模板库STL(Standard Template Library)
标准模板库STL(Standard Template Library)指南 /*刘振飞liuzf@pku.org.cn 1999-10-20*/ / *版权所有 (C) 1999-2004 刘振飞li ...
- C++ 标准模板库 STL 概述
泛型程序设计 C++ 的特点: C++ 的核心优势之一就是便于软件重用,而软件的重用在 C++ 中主要体现在以下两个方面: 面向对象的思想:继承.多态和标准类库 泛型程序设计的思想:模板机制和标准 ...
- C++ 标准模板库 STL 容器适配器
C++ 标准模板库 STL 容器适配器 容器 数据结构 时间复杂度 顺序性 重复性 stack deque / list 顶部插入.顶部删除 O(1) 无序 可重复 queue deque / lis ...
- C++ 标准模板库(STL)
C++ 标准模板库(STL) C++ STL (Standard Template Library标准模板库) 是通用类模板和算法的集合,它提供给程序员一些标准的数据结构的实现如 queues(队列) ...
- c++标准模板库STL【快速查找】【最全】【常用】【语法】
c++标准模板库STL[快速查找][最全][常用][语法] c标准模板库STL快速查找最全常用语法 vector- 变长数组 set-内部自动有序且不含重复元素 ...
- c语言stl模板,c/c++开发分享C++ 标准模板库 STL 顺序容器详解
c++ 标准模板库 stl 顺序容器 容器 顺序性 重复性 支持迭代器 vector 动态数组 无序 可重复 随机访问迭代器 deque 双向队列 无序 可重复 随机访问迭代器 list 双向链表 无 ...
- 13 标准模板库STL【C++】
13 标准模板库STL 13- 判断题 单选题 填空题 程序填空题 函数题 7-1 .查找电话号码 7-2 姓名排序 7-3 Score Processing 13+ 编程题 7-1 查找成绩并折算后 ...
- 第十章 标准模板库STL
第十章 标准模板库STL 因为是在复习时重写的,无法在PTA上验证,编程题格式可能有误. 判断题 1.可以通过下标随机访问向量vector中的元素.(T) 2.当向量对象的内存用完之后,就会产生越界错 ...
最新文章
- ssl握手过程和ca证书验证
- HDU 4267 线段树 离散点区间更新， 自叶子节点至根单点查询
- SELECT 语句与其子句的详解
- javaScript中的事件对象event是怎样
- js浮点数精度丢失问题及如何解决js中浮点数计算不精准
- Redis的主从搭建
- H3C-IMC 自动发现功能如何使用
- 台湾SDN/NFV联盟：集合产业内各部分力量，共同推进NFV技术发展
- 国内IDC成立SOC安全运营中心
- 回顾︱时间序列预测与分解有哪些模型？（一）
- Win10(Server)与Ubuntu18.04(Client)使用Synergy--键盘鼠标共享
- AIO、NIO、BIO
- sqluldr2导出过blob字段_转载：利用sqluldr2导出数据和sqlldr导入数据的方法
- 自定义启动 android_什么是自定义Android启动器，以及为什么可能要使用一个
- 让人喷血的92条个性签名!!!
- 《万人如海一身藏》书摘
- 【mysql】 Windows下使用DOS命令进入MySQL数据库
- 用树莓派连电脑显示屏
- 数据库+jdbc实现学生教师管理
- Chrome version must be 70 and 73