vector

初始化及赋值方式

//初始化一个size为0的vector
vector<int> vi;//初始化size,但每个元素值为默认值
vector<int> vi(10);    //初始化了10个默认值为0的元素//初始化size,并且设置初始值
vector<int> vi(10，1);    //初始化了10个值为1的元素int a[5] = {1,2,3,4,5};
//通过数组a的地址初始化，注意地址是从0到5（左闭右开区间）
vector<int> vi(a, a+5);//Make a vector and copy the elements from begin to end.vector<int> vi(5,1);
//通过vi初始化
vector<int> vj(vi);//insert初始化方式将同类型的迭代器对应的始末区间（左闭右开区间）内的值插入到vector中
vector<int> a(6,6);
vecot<int> b;
//将a[0]~a[2]插入到b中，b.size()由0变为3
b.insert(b.begin(), a.begin(), a.begin() + 3);// 初始化一个 二维的matrix, 行M,列N,且值为0
vector<vector<int>> matrix(M,vector<int>(N,0));

vector容器内元素的访问

• 通过下标访问：vi[i]

  • vector在还没有分配任何空间时还不能像数组一样用下标形式去访问vector的（v[0]也不行）！！！否则编译通过但报运行错误runtime error！

  • vector<int> res(size);//如此进行指定空间大小
    

• 通过迭代器访问：

  • vector<int>::iterater it = vi.begin();//返回开始点的迭代器vi.end();//返回最后一个元素的下一个位置的迭代器
    

• 返回第一个或最后一个元素的值：

  • vi.front();//返回第一个元素vi.back();//返回最后一个元素
    

常用函数

• vector在最后添加元素

vi.push_back(val)

• vector通过迭代器在指定位置插入元素

vi.insert(vi.begin()+i,val); //在vi数组的第i个位置插入值为val的元素【会导致vi的长度加1】 

• vector删除最后的元素

vi.pop_back()

• 通过find函数来查找某一个值对应的迭代器

vector<int>::iterator it = find(arr.begin(), arr.end(), val);if(it!=arr.end()) return true; //当查找失败时，返回的时arr.end()

• 获得vector中元素的个数

len = vi.size()

• 清空vector中所有的元素

vi.clear()

• vector内的元素逆置

vector<int> vi ={1,2,3,4,5,6};
reverse(vi.begin(),vi.end());  //vi反转后为6，5，4，3，2，1

• vector容器的swap方法

v1.swap(v2)

• vector容器中找到最大元素的位置

maxPosition = max_element(vi.begin(), vi.end());

• vector删除指定元素的方法

vi.erase(it);

• 对vector内元素进行去重的方法

// 使用 set 进行去重
set<int> st(vi.begin(), vi.end());
vector<int> viNew(st.begin(), st.end());

• 通过迭代器的位置返回值来获取数组位置下标的方法

//distance，它返回的是两个迭代器之间的距离。//使用这个函数，就能完成迭代器与下标之间的转换：下标 = 当前迭代器位置-容器头部//注：在使用过程中，可以结合begin（）和返回的迭代值进行求下标的计算。vector<int>::iterator first = vi.begin();
vector<int>::iterator it = find(arr.begin(), arr.end(), val);
distance(first,it)

set

• set内的元素递增排序
• 自动去重
• 内部用红黑树实现

set容器内元素的访问：

• 访问第一个值【最小值】：*st.begin()

• 访问最后一个值【最大值】：*st.rbegin()

//只能通过枚举的方式访问
for(set<int>::iterator it = st.begin();it!=st.end();it++){cout<<*it<<endl;
}

set常用函数：

• 将x元素插入set中

st.insert(x)

• 在set中查找value，并返回其迭代器

set<int>::iterator it = st.find(value);
cout<<*it<<endl;cout<<*(st.find(value));

• 在set中删除元素

st.erase(it): //删除迭代器为it处的元素 
st.erase(value);//删除set中值为value的元素
st.erase[first,last);//删除[first,last)内所有的元素

• 获得st中元素的个数

st.size();

• 清空set中所有的元素

st.clear();

multiset

• 能时刻保证序列中的数是有序的，而且序列中可以存在重复的数

multiset<int> mst;

unordered_set

• 只去重，不排序
• 速度比set快很多

unordered_set<int> ust;

string

string常用函数：

• str=str1+str2; //直接拼接
• ==、!=、>= //直接比较
• str.length()、str.size() // 返回string的长度
• str.insert(pos,string); //在pos号位置，插入字符串string
• str.clear();
• str.substr(pos,len); //返回从pos位开始，长度为len的子串
• str.find(str2);//返回str2在str中第一次出现的位置，如果不是其子串，返回string::npos
  • string::npos：是一个常数，其本身的值为-1，用来作为find函数失配时的返回值
• str.replace(pos,len,str2);// 把str从pos号位开始，长度为len的子串替换为str2

map

• map中的键是唯一的
• map会以键从小到大的顺序自动排序
• 内部由红黑树实现

map容器内元素的访问：

• 通过下标访问:mp['c']

• 通过迭代器访问：

  • map<typename1,typename2>::iterater it;
    it->first;//访问键
    it->second;//访问值
    

map常用函数：

• 返回键为key的迭代器it

map<char,int>::iterator it = mp.find(key);

• 判断map的键是否已经存在了

mp.count(key)//返回值是一个整数，1表示有这个元素，0表示没有这个元素。

• 查找容器中的元素的个数

mp.size();

• mp.clear();

• map对value进行排序的方法

//先把map装进pair里，然后再放入vector，自定义sort实现排序
vector<pair<int,int>> vi;sort(vi.begin(),vi.end(),[](pair<int,int> p1,pair<int,int> p2){return p1.second>p2.second;
})

multimap

• 一个键可以对应多个值

unordered_map

• 只映射，而不按key排序
• 速度比map快很多

queue

• 使用pop()和front()函数前，需要用empty()函数判断队列是否为空

queue容器内元素的访问：

q.front();//访问队首元素q.back();//访问队尾元素

queue常用函数：

• q.push(x):将x入队
• q.pop():将队首元素出队
• q.empty():检测queue是否为空
• q.size():返回queue内元素的个数

priority_queue【实质是大根堆/小根堆】

• 用堆来实现
• 队首元素是当前队列中优先级最高的元素

定义：

priority_queue<typename> name;

priority_queue容器内元素的访问：

q.top();//只能访问队首元素，相当于访问堆顶元素

priority_queue常用函数：

• q.push(x):将x入队
• q.pop():将队首元素出队
• q.empty():检测优先队列是否为空
• q.size():返回优先队列内元素的个数

priority_queue优先级的设置：

priority_queue<int, vector<int>, less<int> > a; //less:减小，从大到小，是大根堆【默认】   priority_queue<int, vector<int>, greater<int> > s; //greater:增大，从小到大，是小根堆//vector<int>（也就是第二个参数）填写的是来承载底层数据结构堆（heap）的容器，如果第一个参数是 double 型或 char 型，则此处只需要填写 vector<double> 或 vector<char>；

deque

常用函数：

• 在队列尾部添加元素

dq.bush_back()

• 在队列头部添加元素

dq.push_front()

• 删除队列尾部的元素

dq.pop_back()

• 删除队列头部的元素

dq.pop_front()

• 获得头部元素

dq.front()

• 获得队列尾部元素

dq.back()

stack

stack容器内元素的访问：

st.top();//只能访问栈顶元素易错点！在使用st.top()之前，要先判空：st.empty();

stack常用函数：

• st.push(x):将x入栈
• st.pop():将栈顶元素弹出
• st.empty():检测栈是否为空
• st.size():返回栈内元素的个数

pair

• 可以直接用==、!=、<等运算符比较，比较规则：先以first的大小作为标准，当first相等时，再去判别second
• 代替二元结构体机器构造函数，节省编码时间
• 作为map的键值对来进行插入：mp.insert(make_pair("haha",3));

定义

pair<typename1,typename2> name;

在代码中临时构建pair

pair<string,int > ("haha",5);
make_pair("haha",5);

元素访问

pair<int ,int > p;
p.first;
p.second;

algorithm头文件下的常用函数

• fabs(double x)：double型变量取绝对值

• floor(double x)：double型变量向下取整

• ceil(double x)：double型变量向上取整

• pow(double r, double p) ：返回$r^p$

• sqrt(double x)：返回double型变量的算术平方根

• round(double x)：将double型变量四舍五入

• max(x,y)

• swap(x,y)：交换x、y的值

• reverse(arr,arr+n)：将此范围内的元素进行反转

• next_permutation()：给出一个序列在全排列中的下一个序列

  int a[10]={1,2,3};
  do{cout<<a[0]<<a[1]<<a[2]<<endl;
  }while(next_permutation(a,a+3));
  

• fill(arr,arr+n,x)：用于对数组赋予其他的数字

• memset(arr,0,sizeof(arr))：只能用于赋值0或-1

10 10 255 34 0 1 255 8 0 3 255 6 0 5 255 4 0 7 255 2 0 9 255 21