vector/string
#include <algorithm>
#include <iostream>
#include <vector>
#include <unordered_set>
#include <set>
#include <string>
using namespace std;
int main(){
vector<int> vi;
for(int i=1;i<=5;i++){
vi.push_back(i);
}
vector<int>::iterator it = vi.begin();
//取首元素地址
//在STL中使用的和位置有关的返回的都是对应位置的迭代器
for(int i=0;i<5;i++){
cout<<*(it+i)<<endl;
}
set<int> si;
si.insert(1);
si.insert(5);
si.insert(3);
for(set<int>::iterator it=si.begin();it!=si.end();it++){
//这里使用si.end()!=it
//不能比较><啥的
cout<<*it<<" ";
}
cout<<endl;
//会是按照顺序输出的
/*
string 常用部分
(1)遍历访问
(2)常用函数解析
*/
string str;
string str1 = "abcd";
/*
(1)通过下标访问,一般的string通过这种方法即可
(2)通过迭代器访问,一些函数的参数需要iterator类型
(3)和vector一样支持直接使用iterator加减某个数字
*/
for(int i=0;i<str1.size();i++){
cout<<str1[i]<<" ";
}
//可以直接像字符数组那样去访问
//使用c_str()进行字符串和字符数组的转化,使用printf输出
printf("%s",str1.c_str());
cout<<endl;
string::iterator its ;
for(its = str1.begin();its!=str1.end();its++){
printf("%c",*its);
}
cout<<endl;
/*
(1)operator+= 将两个string拼接起来
(2)compare operator
(3)length()/size()
(4)insert()
(5)erase()
(6)clear() 清除
(7)substr()
(8)string::npos
(9)find()
(10)replace()
*/
/*
operator+=/+
*/
string str2 ="efgh";
str2 += str1;
string str3 = str1+str2;
cout<<str2<<" "<<str3<<endl;
/*
compare operator > < == != >= <=
字典序
*/
string s1="a";
string s2 = "aa";
string s3 = "abc";
string s4 = "xyz";
if(s1<s2) cout<<"ok"<<endl;
if(s2<s3) cout<<"ok"<<endl;
/*
length/size
*/
cout<<str2.length()<<" "<<str2.size()<<endl;
/*
insert(pos,string);//在pos位置插入字符串string
insert(it,it2,it3);//it是插入位置,it2和it3是待插入字符的首尾迭代器,包含it2,不包括it3
*/
/*
erase(it);//it为相应位置的迭代器
erase(first,end);//first和end也是迭代器
erase(pos,length);//pos是起始位置,length是删除字符个数
*/
/*
substr(pos,len);返回从pos开始长度为len的子串
*/
cout<<str2.substr(2,2)<<endl;
/*
string::npos是一个常数,本身的值为-1.是unsigned_int类型,认为是unsigned_int类型的最大值
string::npos用以作为find函数失败时的返回值
*/
if(string::npos==-1)
cout<<"-1 is true!"<<endl;
if(string::npos==4294967295)//这个不是了?
cout<<"also true"<<endl;
/*
str1.find(str2);//返回和str2匹配上的第一个位置
str.find(str2,pos);//从pos开始匹配str2
*/
cout<<str2.find("gh")<<endl;//返回的不是迭代器
/*
replace(pos,len,str2);//从pos开始替换为len长的str2
replace(it1,it2,it3);//使用iterator
*/
str2.replace(2, 3, "aaa");
cout<<str2<<endl;
return 0;
}
map
/*
1.map的定义:如果要使用字符串必须用string,不能用char数组
*/
map<string, int> mp;
map<set<int>,int> mp1;//也可以是其他STL容器到其他类型
/*
2.map容器内的元素访问
两种访问方式:
(1)直接使用mp[key]访问
(2)通过迭代器访问map<typename1,typename2>::iterator it;
map的每一对映射都有两个typename,必须使用一个it同时访问key和value
it->first 访问key
it->second 访问value
map会按照键的从小到大进行排序(内部红黑树)
*/
mp["java"]=20;
mp["c++"]=30;
map<string,int>::iterator it;
for(it=mp.begin();it!=mp.end();it++){
cout<<it->first<<" "<<it->second<<endl;
}
/*
常用的函数
(1)find(key); return iterator O(logN)
(2)erase(it); it=iterator O(1)
erase(key); 删除对应key的整条记录 O(logN)
erase(first,last); first->the start iterator / last->the end iterator
(3)size();O(1)
(4)clear();O(N)
*/
/*
map常见用途:
(1)建立字符/字符串与整数之间映射的题目,使用map可以减少代码量
(2)判断大整数或其他类型数据是否存在的题目,可以把map当bool数组使用
(3)字符串和字符串的映射也可能遇到
*/
/*
一个key对应多个value-> multimap
散列代替map内部红黑树实现,只映射不排列->unordered_map
*/
queue
/*
1.定义
*/
queue<int> q;
/*
2. queue容器内元素的访问
front()访问队头元素
back()访问队尾元素
*/
/*
3. 常用函数解析
(1)push()
(2)front()/back()
(3)pop()
(4)empty()判断是否为空
(5)size()判断队列大小
*/
/*
4. 应用
当进行广度优先遍历的时候不用自己实现队列
在使用front / back函数之前必须使用emoty判断队列是否为空
*/
for(int i=1;i<=5;i++){
q.push(i);
}
cout<<q.size()<<endl;
priority_queue
优先队列,内部是用堆实现的,在优先队列中,队首元素一定是当前队列中优先级最高的一个。
可以任何时候往队列中push元素,而优先队列底层的数据结构(heap)会随时调整结构,使得每次的队首元素都是优先级最大的。
设置优先级是关键
#include <queue>
#include <iostream>
using namespace std;
struct fruit{
string name;
int price;
//需要对相应的运算符进行重载
//重载大于号会编译错误,因为在数学上只需要重载小于号即可实现大于号存在的同样功能
friend bool operator < (fruit f1,fruit f2){
return f1.price < f2.price;
}
};
struct fruit1{
string name;
int price;
};
struct cmp{
bool operator () (fruit1 f1,fruit1 f2){
return f1.price>f2.price;
}
};
int main(){
/*
1. 定义
*/
priority_queue<int> q;
/*
2. 元素访问
只能使用top()
*/
q.push(1);
q.push(3);
q.push(10);
q.push(7);
cout<<q.top()<<endl;
/*
3. 常用函数
(1)push();
(2)top();
(3)pop();
(4)empty();
(5)size();
*/
/*
4. priority_queue内部优先级的设置
(1)基本类型 数字的按照数值,字符按照字典序
(2)结构体
*/
priority_queue<int,vector<int>,less<int>> q1;
//vector<int>用来填写底层数据结构heap的容器
//less<int>是用来对第一个参数的比较类,less<int>表示数字大的优先,greater<int>表示数字小的优先
//如果第一个参数是double或者char型不需要第三个参数
priority_queue<fruit> fq;//这样直接定义就会按照里面对于运算符的重载来处理
//也可以把重载部分写在结构体外面
priority_queue<fruit1,vector<fruit1>,cmp> self_q;
//其他基本数据类型或者其他STL容器都可以通过同样的方式来定义优先级
/*
5. 常见用途
(1)可以解决一些贪心问题
(2)对Dijkstra进行优化
*/
return 0;
}
//如果结构体内的数据较为庞大,建议使用饮用&来提高效率
friend bool operator < (const fruit& f1,const fruit& f2){
return f1.price>f2.price;
}
bool operator () (const fruit&f1,const fruit&f2){
return f1.price>f2.price;
}
stack
/*
1. 定义
*/
stack<int> st;
/*
2. 元素访问
只能通过top来访问栈顶元素
*/
for(int i=0;i<5;i++){
st.push(i);
}
while(!st.empty())
{cout<<st.top()<<endl;
st.pop();}
/*
3. 相关函数
(1)push();
(2)top();
(3)pop();
(4)empty();
(5)size();
*/
/*
4. 常见用途
模拟一些递归,防止程序对内存的限制而导致程序出错
*/
pair
pair,当想要将两个元素绑在一起作为一个元素、又不想要因此定义结构时,使用pair可以很方便的作为替代
struct pair{
typename1 first;
typename2 second;
};
/*
1. 定义
*/
pair<string, int> p;
pair<string,int> p0("haha",1);//初始化
//构建pair的两种方法
pair<string,int>("haha",2);
make_pair("haha", 2);
/*
2. pair中元素的访问
按照正常的结构体的方式去访问即可
*/
cout<<p0.first<<p0.second<<endl;
/*
3. 常用函数
(1)比较操作数
== >= <= != < >
比较的标准是先以first的大小为标准,当first相等时再去比较second
*/
/*
4. 常见用途
(1)用来代替二元体结构,可以节省编码时间
(2)作为map的键值对来进行插入
*/
map<string,int> mp;
mp.insert(make_pair("hhaha", 4));
mp.insert(pair<string,int>("haha1",5));
algorithm头文件下常用函数
max(<#const _Tp &__a#>, <#const _Tp &__b#>);
min(<#const _Tp &__a#>, <#const _Tp &__b#>);
abs(<#int#>);//浮点数用math下的fabs
swap(x,y);
reverse(it,it2);//参数是迭代器
next_permutation(it, it2);//返回一个序列在全排列中的下一个序列
//在已经到达全排列的最后一个时会返回false
//注意使用do while还是while,while可能少一个输出
int a[3]={1,2,3};
do{
cout<<a[0]<<a[1]<<a[2]<<endl;
}while (next_permutation(a, a+3));
fill(it, it2, value);//把数组或者容器中的某一区间赋为某个相同的值
//和memset不同,这里的赋值可以是数组类型对应范围中的任意值
fill(a,a+3,2333);
sort(firstaddress,tailaddress+1,compare function);
//实现比较函数cmp
//(1)基本类型
bool cmp(int a,int b){
return a<b;//结果会按照从小到大排列
}
sort(a,a+3,cmp);
//(2)结构体数组
bool cmp(node a,node b){
return a.x < b.x;
}
bool cmp(node a,node b){
if(a.x!=b.x) return a.x > b.x;
else return a.y > b.y;
}
sort(ssd,ssd+3,cmp);
//(3)容器的排序
//在标准STL中只有vector\string\deque可以使用sort
//set、map这种容器都是通过红黑树实现的,元素本身有序,不允许使用sort进行排序
//在对vector进行排序的时候也可以直接使用cmp在sort函数中
//string的排序默认按照字典序,如果想要改成按照字符串长度也可以
bool cmp(string str1,string str2){
return str1.length()<str2.length();
}
sort(str,str+2,cmp);
upper_bound(first,last,val);//在[first,last)范围内寻找第一个值大于等于val元素的位置
lower_bound(first,last,val);//找第一个大于val元素的位置