c++ STL库(stack,queue,vector,list,lower_bound,set,map,priority_queue)

stack

先进后出

#include <stack>
using namespace std;
int mian(){
  stack<int> S;
  S.size()//返回栈的元素数
  S.top()//返回栈顶元素
  S.pop()//从栈中取出并删除元素
  S.push(3)//向栈中添加元素x
  S.empty()//在栈为空时返回true
  //时间复杂度均为O(1)
}

queue

先进先出

#include <queue>
using namespace std;
int main(){
  queue<int> q;
  q.size();//返回队列的元素数
  q.front();//返回队头的元素
  q.pop();//从队列中取出并删除元素
  q.push(x);//从队列中添加元素x
  q.empty();//在队列为空时返回true
}

vector

又叫动态数组

#include <vector>
using namespace std;
int main(){
  vector<int> v;
  v.size();//返回向量的元素数     O(1)
  v.push_back(x);//在向量末尾添加元素x     O(1)
  v.pop_back();//删除向量的最后一个元素     O(1)
  v.begin();//返回指向向量开头的迭代器     O(1)
  v.end();//返回指向向量末尾（最后一个元素的后一个位置）     O(1)
  v.insert(v.begin()+p,x);//在向量的位置p处插入元素x     O(n)
  v.erase(v.begin()+p);//删除向量中位置p的元素     O(n)
  v.clear();//删除向量中所有元素     O(n)
}

list

双向链表

#include <list>
using namespace std;
int main(){
  list<int> l;
  l.size();
  l.begin();
  l.end();
  l.push_front(x);
  l.push_back(x);
  l.pop_front();
  l.pop_back();
  l.insert(p,x);
  l.erase();
  l.clear();
  return 0;
}

lower_bound 二分查找

#include <iostream>
#include <algorithm>
using namespace std;
int main(){
  int A[14]={1,1,2,2,2,4,5,5,6,8,8,8,10,15};
  int *pos;
  int idx;
  pos=lower_bound(A,A+14,3);
  idx=distance(A,pos);
  cout<<"A["<<idx<<"]="<<*pos<<endl;//A[5]=4;
  pos=lower_bound(A,A+14,2);
  idx=distance(A,pos);
  cout<<"A["<<idx<<"]="<<*pos<<endl;//A[2]=2;
  return 0;
}

set

根据元素值进行排序的集合，所插入的元素在集合中唯一，不存在重复的元素

#include <iostream>
#include <set>
using namespace std;
void print(set<int> s){
  cout<<s.size()<<":";
  for(set<int>::iterator it=s.begin();it!=s.end();it++){
    cout<<" "<<(*it);
  }
  cout<<endl;
}
int main(){
  set<int> s;
  s.insert(8);
  s.insert(1);
  s.insert(7);
  s.insert(4);
  s.insert(8);
  s.insert(4);

  print(s);//4: 1 4 7 8
  s.erase(7);
  print(s);//3: 1 4 8
  s.insert(2);
  print(s);//4: 1 2 4 8
  return 0;
}
// size()
// clear()
// begin()
// end()
// insert(key) 向set中添加元素key
// erase(key) 删除含key的元素
// find(key) 搜索与key一致的元素，并返回指向该元素的迭代器::若没有，则返回末尾end()

map

map集合以键与值的组合为元素，一个元素拥有一个键和一个值，集合中各元素唯一，不存在重复

#include <iostream>
#include <map>
#include <string>
using namespace std;
void print(map<string, int> T){
  map<string, int>::iterator it;
  cout<<T.size()<<endl;
  for(it=T.begin();it!=T.end();it++){
    pair<string, int> itam=*it;
    cout<<itam.first<<"-->"<<itam.second<<endl;
  }
}
int main(){
  map<string, int> T;
  T["red"] = 32;
  T["blue"] = 688;
  T["yellow"] = 122;
  T["blue"] = 312;
  print(T);//3
          //blue-->312
          //red-->32
          //yellow-->122

  T.insert(make_pair("zebra", 101010));
  T.insert(make_pair("white", 0));
  T.erase("yellow");
  print(T);//4
          //blue-->312
          //red-->32
          //white-->0
          //zebra-->101010
  pair<string, int> target = *T.find("red");
  cout<<target.first<<"-->"<<target.second<<endl;
}
//size()
//clear()
//begin()
//end()
//insert(key,vel)//向map中插入元素（key， val）
//erase(key)//删除含有key的元素
//find(key)//搜索与key一致的元素，并返回该元素的迭代器，没有一致的元素，则返回末尾end（）

priority_queue

优先队列

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
struct cmp{
  bool operator()(int x,int y){
    return x>y;
  }
};
struct node{
	int x,y;
	friend bool operator<(node a,node b)
	{
		return a.x>b.x;//按x从小到大排 
	}
};
int main(){
  priority_queue<int> p;//默认最大的元素优先级最高
  priority_queue<int, vector<int>, cmp> q;    //定义方法
  priority_queue<node> q_node;
  return 0;
}
//empty() 　　   
//pop()　　　　
//push() 　　    
//size() 
//top()