栈 ：FILO
栈（stack）又名堆栈，它是一种线性表，是一个后进先出的数据结构。
使用时须加上头文件：#include<stack>
允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。
stack的基本操作有：
- l 入栈：如s.push(x);
- l 出栈：如s.pop()。注意出栈操作就是删除栈顶元素；
- l 访问栈顶：如s.top();
- l 判断栈空：如s.empty()。当栈空时返回true;
- l 访问栈中的元素个数。如s.size()；
栈代码示例：
#include<iostream> #include<cstdio> #include<string> #include<cstring> #include<stack> //栈的头文件 using namespace std; int main () { stack<int> s1; //定义整型栈对象 stack<string>s2; // 定义字符型栈对象 s1.push(2); // 入栈2，就是插入数据2 s1.push(168); //入栈168 s1.push(888);//入栈888,现在栈中元素有{888,168,2} cout<<s1.top()<<endl; //访问栈顶元素，输出888 cout<<s1.size()<<endl; //访问栈中元素个数，输出3 s1.pop(); //出栈，出栈的元素是888 s1.push(233); // 入栈233，现在栈中元素应该是{233,168,2} int a=s1.size(); for(int i=1;i<=a;i++) { s1.pop(); if(s1.empty()) cout<<"空栈"; //如果是空栈(s1.empty()返回true) ,输出空栈 } return 0; }
队列
1、队列和优先队列的头文件都是<queue>
2、队列(FIFO)：先进先出的数据结构
3、queue<int>p; 定义一个变量名为p的队列
4 、入队： p.push(x) 将x从队列p最后面插入
出队： p.pop() 弹出（删除）p队列的第一个元素，注意并不会返回被弹出的元素的值
访问队首元素： p.front() 访问最早被压入队列的元素，即队首
访问队尾元素： p.back() 访问最晚被压入队列的元素 ，即队尾
判断队列空： p.empty() 当队列为空时，返回true
访问队列元素个数： p.size() 访问队列中元素的个数
清空队列： 可以p.pop()依次弹出（删除），p.clear()方法不行，是错误的
队列示例代码：
#include<iostream> #include<cstdio> #include<string> #include<cstring> #include<queue> //队列和优先队列的头文件 using namespace std; int h[10]; int main() { queue<int>p;//声明一个普通队列，普通队列先进先出 int i,n; cin>>n; for(i=1;i<=n;i++) { cin>>h[i]; //输入n个整数 p.push(h[i]); //把输入的数依次压入队列p cout<<p.back()<<" "; //back()总是访问队列的最后一个元素（最后进的元素） } cout<<endl<<endl; //队列 示例 for(i=1;i<=n;i++) { cout<<p.front()<<" "; //front()总是访问队列的第一个元素 （最先进的元素）， p.pop(); // 将其弹出 ，注意pop()总是弹出队列中的第一个元素 if(p.empty()) cout<<endl<<"空的队列"; //p.empty()为true时队列为空。 } return 0;
动态数组vector:
C++的STL动态数组使用<vector>头文件
vector的基本操作有：
- l 构造vector: vector<T> vec。其中T是数据类型，可以是int、double等。
- l 插入x元素: vec.push_back(x)
- l 获取动态数组大小：vec.size()
- l 访问动态数组元素：vec[i],和数组一样操作
- l 修改动态数组元素：比如vec[1]=233,和数组一样操作
- l 清空动态数组：vec.clear()
示例代码：
#include<iostream> #include<cstdio> #include<algorithm> #include<vector> //动态数组头文件 using namespace std; int main() { vector<int> vec; //声明一个int类型的动态数组vec，注意现在动态数组是空的 vec.push_back(3); //通过push_back()方法在动态数组最后面插入一个新的元素3 vec.push_back(2); //...................................................2 vec.push_back(1); //...................................................1 vec.push_back(10); //...................................................10 for(int i=0;i<vec.size();i++) //vec.size()是获得动态数组vec的长度 { cout<<vec[i]<<endl; } vec[0]=10; //修改元素的值，跟正常数组没区别 ，注意第一个元素下标也是0 vec[1]=9; vec[2]=8; vec[3]=7; cout<<endl; for(int i=0;i<vec.size();++i) //vec.size()是获得动态数组vec的长度 { cout<<vec[i]<<endl; } cout<<endl<<"sort排序后"<<endl; sort(vec.begin(),vec.end()); for(int i=0;i<vec.size();++i) //vec.size()是获得动态数组vec的长度 { cout<<vec[i]<<endl; } cout<<endl; vec.clear(); //清空动态数组 cout<<vec.size(); return 0; }
快速排序sort
C++中排序函数sort，在头文件<algorithm>中
Sort函数有三个参数：
（1）第一个是要排序的数组的起始下标。
（2）第二个是要排序的数组的结束下标
（3）第三个参数是排序的方法，可以是从大到小也可是从小到大，
Sortt函数的第三个参数可以用这样的语句告诉程序你所采用的排序原则
- less<数据类型>() 从小到大排序 如：sort(a,a+n,less<int>())
- greater<数据类型>() 从大到小排序 如：sort(a,a+n,greater<int>())
还可以不写第三个参数，此时默认的排序方法是从小到大排序。如：sort(a,a+n)
sort可以对任何线性数据排序（比如数组，vector...）
sort除了能对int、double等基础数据类型排序以外，
还能对自定义数据类型进行排序，比如结构体类型。请看后面的示例。
示例代码如下：
#include<iostream> #include<cstdio> #include<algorithm> #include<vector> using namespace std; int a[10]={9,6,3,8,5,2,7,4,1,0},n=9; vector<int> v;//定义一个动态数组v struct PPtest//定义一个结构体 { int x,y; }p[4]={{1,2},{1,0},{2,1},{0,1}} ; //现在我们想对P[4]按照x值从小到大进行排序。 //我们定义一个比较函数int cmp(PPtest a,PPtest b) //并把这个函数作为参数传递给sort int cmp(PPtest a,PPtest b) //自定义数据类型排序 { if(a.x==b.x) return a.y<b.y; //如果x值相等，就按照y的值从大到小排序 return a.x<b.x; // 按照x的值从大到小排序 } int main() { for(int i=0;i<=n;i++) cout<<a[i]<<" "; //数组a排序前 cout<<endl; sort(a,a+n); //也可写成sort(a+0,a+n),表示对数组a的下标区间(0,n)进行排序 //默认从小到大排序，排序区间是(a+0,a+10) //下标0 ,其实也可以这样写 sort(a,a+n，less<int>()) for(int i=0;i<=n;i++) cout<<a[i]<<" ";//数组a排序后 cout<<endl; sort(a,a+n,greater<int>()); //加入第三个参数greater<int>()后 ，实现从大到小排序。 for(int i=0;i<=n;i++) cout<<a[i]<<" ";//数组a排序后 cout<<endl; sort(p,p+4,cmp);//自定义排序，按照p.x的值从大到小排序 for(int i=0;i<=3;i++) cout<<p[i].x<<" "<<p[i].y<<endl;//排序后的输出为 {0，1}，{1,2},{1,0},{2,1} cout<<endl; v.push_back(5);//动态数据测试 v.push_back(8); v.push_back(6); v.push_back(3); sort(v.begin(),v.end()); //对动态数组v[ ]进行排序 for(int i=0;i<=v.size()-1;i++) cout<<v[i]<<" ";//动态数组排序后 cout<<endl; return 0; }
优先队列：
l 优先队列的头文件是<queue>
l 优先队列： 先进的并不一定先出，先出的是最大(或者最小)的数值
l 从严格意义上来说：优先队列并不是队列,因为它并不遵循队列的FIFO(先进先出的原则)。
l 优先队列的时间复杂度为O（logn）。
优先队列可以按照自定义的一种方式（数据的优先级）来对队列中的数据进行动态的排序
每次的push和pop操作，队列都会动态的调整。以达到我们预期的方式来存储。
（比如说从小到大或从大到小）
例如：我们常用的操作就是对数据排序，优先队列默认的是数据大的优先级高
所以我们无论按照什么顺序push一堆数，最终在优先队列里总是top出最大的元素。
1、priority_queue <int> q; 定义一个变量名为q的优先队列 ，队内元素优先级是默认从大到小
2、priority_queue <int，vector<int>, greater<int> >q;
定义一个变量名为q的优先队列 ，队内元素优先级是从小到大 (感觉跟sort相似？)
3、自定义优先级：priority_queue<int>,vector<int>,cmp>q;
第一个参数是队列类型，第二个参数为容器类型。第三个参数为比较函数。（又跟sort相似？）
cmp为比较函数 。请看模板：在最后面。（比sort复杂一点，有重载运算什么之类的）目前可以不研究
- l 入队： q.push(x) 从队列q中加入x元素，x自己会在优先队列中找到自己的位置（从大到小或从小到大）
- l 出队： q.pop() 弹出（删除）q队列的最大或最小的一个元素，注意并不会返回被弹出的元素的值
- l 访问队首元素： q.top() 访问队首（最大或最小）的元素，不是最早被压入队列的元素
- l 访问队尾元素： ........ 优先队列没这个方法
- l 判断队列空： q.empty() 当优先队列为空时，返回true
- l 访问队列元素个数：q.size() 访问优先队列中元素的个数
- l 清空队列： 可以q.pop()依次弹出（删除），
q.clear()方法不行，是错误的
示例代码一：
#include<iostream> #include<cstdio> #include<queue> //队列和优先队列的头文件 using namespace std; int main() { priority_queue<int>q; //声明一个优先队列 ，注意：优先队列的元素排序默认是从大到小（int） priority_queue <int, vector<int>, greater<int> >q1; //从小到大，注意的是greater<int> >,两个>之间一定有要空格。 int i,n; cin>>n; for(i=1;i<=n;i++) { cin>>h[i]; //输入n个整数 q.push(h[i]); //把输入的数依次加入到优先队列q，动态调整 q1.push(h[i]); //把输入的数依次加入到优先队列q1，动态调整 } cout<<endl<<endl; //优先队列从大到小（默认） for(i=1;i<=n;i++) { cout<<q.top()<<" "; //top()总是访问队首元素（最大）, q.pop(); // 将其弹出 ，注意pop()总是弹出优先队列中优先级最高的元素 （最大） if(q.empty()) cout<<endl<<"队列已为空"; } cout<<endl<<endl; //优先队列从小到大 for(i=1;i<=n;i++) { cout<<q1.top()<<" "; //top()总是访问队首元素（最小）, q1.pop(); //将其弹出 ，注意pop()总是弹出优先队列中优先级最高的元素 （最小） if(q1.empty()) cout<<endl<<"队列已为空"; } cout<<endl<<endl; return 0; }
示例代码二：自定义数据类型
//下面介绍自定义数据类型优先级的操作： #include <iostream> #include <cstdio> #include <queue> using namespace std; int n; struct Node//跟sort自定义有点相同，这里分为两个结构体来写，后面还有个cmp， { int x; int y; }dis[10]; struct cmp//Node优先级规则 { int operator()(Node a,Node b)//注意写法，跟sort不同 ，照着写，我也不明白operator { return a.x>b.x;//小的优先级高 , 一定要记住，跟sort相反 } }; //----------------------------------------------------------------- struct cmp1 //结构体优先级规则 { bool operator ()(int x, int y) //注意写法，跟sort不同 ，照着写，我也不明白operator { return x > y;//小的优先级高 , 一定要记住，跟sort相反 } }; priority_queue<Node,vector<Node>,cmp> d; //自定义结构体优先级 priority_queue<int>q1; //默认，大的优先级高 priority_queue<int, vector<int>, cmp1>q2; //小的优先级高 //priority_queue <int, vector<int>, greater<int> >q2; //也是小的优先级高，可以替代上面。 int main() { int i=0; cin>>n; for(int i=0;i<n;i++) //请输入数据3组，{1，2}，{3，1}，{2，5}用来测试 { cin>>dis[i].x>>dis[i].y; d.push(dis[i]); //插入数据 } cout << endl; while(!d.empty()) //逐步输出优先级大的 { cout<<d.top().x <<" "<<d.top().y<<endl; d.pop(); } cout << endl; for(int i=0;i<n;i++) //请输入测试数据 3个，依次是3 7 1 { int b=0; cin>>b; q1.push(b);//从q1 队列 插入b q2.push(b); } cout<<"q1优先队列"<<endl; while(!q1.empty()) //访问q1队顶元素并输出队顶元素 { cout<<q1.top() <<endl; q1.pop(); } cout << endl; cout<<"q2优先队列"<<endl; while(!q2.empty()) //访问q1队顶元素并输出队顶元素 { cout<<q2.top() <<endl; q2.pop(); } cout << endl; return 0; } /* 第一组 3 1 2 3 1 2 5 第二组： 3 7 1 */
集合set
c++ set集合 参考文章https://www.cnblogs.com/zyxStar/p/4542835.html
集合是数学中的一个基本概念，通俗地理解，集合是由一些不重复的数据组成的。
比如{1,2,3}就是一个有1,2,3三个元素的集合。
c++的STL支持集合的高效插入、删除和查询操作，其时间复杂度都是O(logn)。
如果用数组，虽然插入的时间复杂度是O(1)，但是删除和查询都是O(n),时间效率低。
c++ set的基本操作：
- l #include<set>//集合头文件
- l 定义一个集合s: 比如set<int> s;定义一个整型集合s
- l 返回set集合s中的第一个元素： s.begin()
- l 返回set集合s中的最后一个元素： s.end()
- l 查找set集合s中的指定元素的个数： s.count(30),查找元素30有多少个？
- l 查找set集合s中的指定元素： s.find(20)，查找指定元素20
- l 删除set集合s中的所有元素： s.clear()
- l 判断set集合s是否为空： s.empty() 为空时返回true
- l 从set集合s中插入一个元素： s.insert()
- l 从set集合s中删除一个元素： s.erase()
- l 返回set集合s中元素的个数： s.size()
示例代码：
#include<iostream> #include<cstdio> #include<string> #include<set>//集合头文件 using namespace std; int main() { set<int> s; // 声明一个整型s集合,初始是空的 s.insert(20); //{2} 用insert()方法向集合中插入一个新的元素。 s.insert(10); //{1,2} 插入元素1后集合会自动有序。 s.insert(30); //{1,2,3},每次插入元素后集合都会自动有序 s.insert(10); //{1,2,3}第二次插入1，重复元素，不会插入 //c++通过迭代器::iterator可以访问集合中的每个元素，可以不懂，记住用法就行了 set<int>::iterator it;//遍历之前先定义一个(::iterator)迭代器it for(it = s.begin(); it != s.end(); it++)//遍历集合中的元素 { cout<<(*it)<<" ";//实际上it就是个指针变量。*it是 获取it 指想某个变量的值。 } cout<<endl; s.erase(30);//{1,2} 删除指定元素 30 cout<<endl<<"删除30以后"<<endl; for(it = s.begin();it != s.end();++it) cout<<(*it)<<" ";//实际上it就是个指针变量。*it是 获取it 指想某个变量的值。 cout<<endl<<endl; cout<<"查找指定元素20"<<endl; //遍历查找元素20 it = s.find(20); //查找键指定元素20 if (it != s.end()) //找到 cout << *it << endl; else //未找到 cout << "未找到"<<endl; cout<<endl<<"查找有多少个30这样的元素"<<endl;// if(s.count(30)) //可以用count()方法查找集合中的指定元素的个数。 cout<<s.count(30)<<endl; else cout<<"没有30这个元素"<<endl<<endl; cout<<s.size()<<" "<<s.max_size()<<endl; //输出集合中所有元素的个数及集合可以容纳最大的元素上限 s.clear();//清空集合 cout<<"清空集合后,集合中的元素为"<<" "; cout<<s.size()<<endl; return 0; }
C++中的STL中map用法详解 映射
参考文章：https://www.cnblogs.com/fnlingnzb-learner/p/5833051.html
注意：文章中像数组一样遍历好像不行。
https://www.cnblogs.com/qigaohua/p/5803629.html
map映射是指两个集合之间的元素的相互对应关系。通俗地说，就是一个元素对应另外一个元素。
众所周知，在定义数组时（如int array[100]），其实是定义了一个从int型到int型的映射，比如array[1]=28、array[3]=66就分别是将1映射到28、将3映射到66。一个double型数组则是将int映射到double型，例如db[0]=6.12，db[1]=10.02。但是，无论是什么类型，它总是将int型映射到其他类型。这似乎表现出一个弊端：当需要以其他类型作为关键字来映射时，会显得很不方便。例如有一本字典，上面提供了很多字符串和对应的页码，如果要用数组来表示“字符串-->页码”这样的对应关系，就会感觉不太好操作。这时，就可以用到map，因为map可以将任何基本类型映射到任何基本类型，也就可以建立string型到int型的映射。
比如有一个姓名集合{"Tom","Jone","Mary"},班级集合{1,2}。
姓名与班级之间可以有如下的映射关系：
class("Tom")=1, class("Jone")=2, class("Mary")=1。
我们称其中的姓名集合为 关键字集合(key)，班级集合为 值集合 (value)。
map的基本操作函数（常用）：
begin() 返回指向map头部的迭代器 end() 返回指向map末尾的迭代器
rbegin() 返回指向map尾部的反向迭代器 rend() 返回指向map头部的反向迭代器
clear(） 删除所有元素 empty() 如果map为空则返回true
count() 返回指定元素是否出现 find() 查找一个指定元素
insert() 插入元素 erase() 删除一个元素
size() 返回map中元素的个数 max_size() 返回可以容纳的最大元素个数
swap() 交换两个map，使用方法m1.swap(map2) ;m1和m2两个映射交换，而不是映射中的两个元素交换
代码示例：
#include<iostream> #include<cstdio> #include<string> #include<map>//集合头文件 using namespace std; int main () { //数据的插入--第一种：用insert函数插入pair数据 map <int,string> mapStudent;//{}初始是空映射 mapStudent.insert(pair<int, string>(3, "student_three")); mapStudent.insert(pair<int, string>(1, "student_one")); //插入新的映射,映射会根据关键字key自动升序排序 mapStudent.insert(pair<int, string>(2, "student_two")); mapStudent.insert(pair<int, string>(2, "student_2")); //如果关键字key已经有了，就是无效插入,就算值value不同。 //但是如果是数组的方式插入，就会覆盖原来的 //遍历map,第一种方法，使用前向迭代器 ，就是顺序遍历 map<int, string>::iterator iter;//定义一个前向迭代器iter，不明白没关系，记住使用方法 //map<元素类型,元素类型>::iterator 变量 for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++) cout<<iter->first<<" "<<iter->second<<endl; //first对应map关键字key，second对应map的值value cout<<endl<<"映射mapStudeng的大小为："<<mapStudent.size()<<endl<<endl; //查询映射的大小 //数据的插入--第二种：像数组一样使用 map <string,int> DICT;//{} DICT["Tom"]=1;//还可以像访问数组一样访问映射。 DICT["Jone"]=2; DICT["Mary"]=1; DICT["Tom"]=2;//就算已有关键字Tom,也会完全覆盖原有的映射 DICT["Test"];//如果这个映射不存在，自动建立一个新映射，默认Key值0 //输出测试 cout<<"测试映射的值是什么"<<endl; cout<<DICT["Mary"]<<endl;//输出Mary的值1 cout<<DICT["Test"]<<endl;//输出Test的值0 cout<<endl<<endl; //遍历map,第二种方法，使用反向迭代器 ，就是反向遍历 map<string,int>::reverse_iterator it; //map<元素类型,元素类型>::reverse_iterator 变量 for(it = DICT.rbegin();it != DICT.rend();++it) //反向遍历map，注意不是begin()和end(),而是rbegin()和rend() cout<<it->first<<"在班级 "<<it->second<<endl; //first对应map关键字key，second对应map的值value //删除映射，两种方法 //1、可以用关键字删除，比如m.erase(1), //2、也可以成片的删除，如m.erase(m.begin(),m.end()); DICT.erase("Tom");//单独删除Tom关键字 cout<<endl<<"删除后Tom映射不见了"<<endl; for(it = DICT.rbegin();it != DICT.rend();++it) //反向遍历map，注意不是begin()和end(),而是rbegin()和rend() cout<<it->first<<"在班级 "<<it->second<<endl; //first对应map关键字key，second对应map的值value cout<<endl<<"全部删除所有映射"<<endl; DICT.erase(DICT.begin(),DICT.end()) ;//成片删除 跟DICT.clear效果一样DICT.clear(); cout<<DICT.size()<<endl; /*查找并获取map中的元素（包括判定这个关键字是否在map中出现）： 有两种：1、用m.count() 用2、m.find() 第一种：用count函数来判定关键字是否出现，其缺点是无法定位数据出现位置, count函数的返回值只有两个，要么是0，要么是1，出现的情况，当然是返回1了 */ cout<<endl<<"count查找...."<<endl; map <string,int> m;//{} m["Tom"]=2; m["Jone"]=5; m["Mary"]=3; if(m.count("Tom"))//如果Tom出现 cout<<m.count("Tom")<<endl;//返回1 /*第二种：用find函数来定位数据出现位置，它返回的一个迭代器，当数据出现时， 它返回数据所在位置的迭代器，如果map中没有要查找的数据， 它返回的迭代器等于end函数返回的迭代器 */ map<string,int>::iterator TEST;//定义一个迭代器TEST cout<<endl<<"前向遍历"<<endl; for(TEST=m.begin();TEST!=m.end();TEST++)//前向遍历 cout<<TEST->first<<" "<<TEST->second<<endl; cout<<endl<<"find()查找...."<<endl; TEST=m.find("Tom"); if(TEST!=m.end())//判断是否找到Tom，记住判断方法 { cout<<"找到了，他的值是 "<<TEST->second<<endl; m.erase(TEST); //测试用，删除Tom } else cout<<"没找到"<<endl; //排序 map中的sort问题 ，略................. return 0; }