STL

标签：cin   main   检索   大小   ace   空格   直接   key   间接   

STL

1.输入输出

1.1.C语言的输入输出

    int a;
    scanf("%d\n", a);
    printf("%d", a);

1.2.C++语言的输入输出

    int a,b,c;
    cin>>a>>b>>c;
    cout<<a<<b<<c<<endl;

2.STL与algorithm头文件

2.1.sort()函数

2.1.1.迭代器

迭代器————理解为指针，但是迭代器分为4种：
1) 正向迭代器，定义方法如下：
容器类名::iterator  迭代器名;
2) 常量正向迭代器，定义方法如下：
容器类名::const_iterator  迭代器名;
3) 反向迭代器，定义方法如下：
容器类名::reverse_iterator  迭代器名;
4) 常量反向迭代器，定义方法如下：
容器类名::const_reverse_iterator  迭代器名;

表1：不同容器的迭代器的功能

2.1.2.sort排序实例

sort()函数语法描述：sort(begin,end,cmp),cmp参数可以没有，如果没有默认非降序排序。

• 以int为例的基本数据类型的sort使用
  1. 升序：sort(begin,end,less());
  2. 降序：sort(begin,end,greater());

#include<iostream>
#include<algorithm>

using namespace std;

int main(){
    int a[] = {1,5,4,8,10,6,3};
    sort(a,a+7);
    //sort(a,a+7,less<int>());
    //sort(a,a+7,graeter<int>());
    for(int i = 0; i < 7; i++){
        cout<<a[i]<<" ";
    }
    return 0;
}

运行结果：1 3 4 5 6 8 10

• 引用数据类型string的使用

1.使用迭代器可以完成顺序排序：

#include<iostream>
#include<algorithm>
#include<string>

using namespace std;

int main(){

    string str = "hello world";
    sort(str.begin(),str.end(),less<int>());
    string :: iterator it;
    for(it=str.begin();it!=str.end();it++){
        cout<<*it;
    }
    cout<<endl;
    cout<<str<<endl;
    return 0;
}

运行结果：空格dehllloorw

2.使用反向迭代器可以完成逆向排序

#include<iostream>
#include<algorithm>
#include<string>

using namespace std;

int main()
{
    string str("hello world");
    sort(str.rbegin(),str.rend());
    //sort(str.begin(),str.end(),greater<int>());
    cout<<str;
    return 0;
 }

运行结果：wroolllhde空格

3.以结构体为例的二级排序

#include<iostream>
#include<algorithm>
#include<string>

using namespace std;

struct link{
    int a,b;
};
bool cmp(link x,link y){
    if(x.a == y.a){
        return x.b > y.b;
    }
    return x.a > y.a;
}
int main(){
    link x[4];
    for (int i=0;i<4;i++){
        cin>>x[i].a>>x[i].b;
    }
    sort(x,x+4,cmp);
    for (int i=0;i<4;i++){
        cout<<x[i].a<<" "<<x[i].b<<endl;
    }
    cout<<endl;
    return 0;
}

3.string()

概念：相当于char * 封装，理解为字符串

3.1.简单使用

int main(){
    //C中定义字符串以及打印
    char *ch="sdasfsfjg";
    for(int i = 0;ch[i] !='\0';i++){
    cout<<*(ch + i);
    }
    cout<<endl;
    //C++
    string s = "sadasdsfg";
    cout<<s<<endl;
    return 0;
}

3.2.获得一行字符串

我想获取一行字符串

hello world

C中：

#include<stdio.h>
int main(){
    char ch[100];
    /*
    scanf()不能获取含有空格的字符串，遇到空格就会停止，只能获取一个单词
    */
    gets(ch);//获取一行有空格的字符串
    for(int i = 0; ch[i] != '\0'; i++){
        printf("%s",ch[i]);
    }
    return 0;
}

C++中：

#include<iostream>
#include<string>
using namespace std;

int main(){
    string s;
    getline(cin,s);
    cout<<s;
    return 0;
}

3.3.+=运算符

+=对于字符串，字符有效，数字会转为ascii码 ‘+’是连接符

#include<iostream>
#include<string>
using namespace std;

int main(){
    string s;
    s +="hello";
    s +=" world";
    s += '5';
    s += 10;//10对应的ascii码是换行
    int a=5;
    s +=(a+'0');//s后加入5
    cout<<s;
    return 0;
}

3.4.排序sort()（使用algorithm）

功能：默认进行升序排序

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

int main(){
    string s = "2314546754";
    sort(s.begin(),s.end());
    cout<<s;
    return 0;
}

3.5.erase()函数

功能：删除string的一个字符

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

int main(){
    string s = "2314546754";
    sort(s.begin(),s.end());
    cout<<s;
    return 0;
}

3.6.substr函数

功能：抽取一个子字符串

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

int main(){
    string s = "2314546754";
    s = s.substr(1,3);//取314,取索引为1，往后截取3个
    cout<<s<<endl;//s="314"
    s = s.substr(0,-1);//取314，取索引为0,即第一个开始，-1截到最后
    cout<<s;
    return 0;
}

3.7.循环（3种）

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

int main(){
    string s = "123456";
    cout<<s.size()<<" "<<s.length()<<endl;
    //for循环 
    for(int i=0; i<s.size(); i++){
        cout<<s[i];
    }
    cout<<endl;
    //迭代器 
    for(string :: iterator it = s.begin(); it != s.end(); it++){
        cout<<*it;
    }
    cout<<endl;
    //迭代器简化 
    for(auto it = s.begin(); it != s.end(); it++){
        cout<<*it;
    }
    cout<<endl;
    //利用C++11新特性for循环 
    for(auto x:s){
        cout<<x;
    }
    cout<<endl;
    cout<<s;
    return 0;
}

4.vector()

概念：vector相当于数组，模板类型相当于存放的内容

4.1.vector构造

方式1:

//定义具有10个整型元素的向量（尖括号为元素类型名，它可以是任何合法的数据类型），不具有初值，其值不确定
vector<int>a(10);

方式2:

//定义具有10个整型元素的向量，且给出的每个元素初值为1
vector<int>a(10,1);

方式3:

//用向量b给向量a赋值，a的值完全等价于b的值
vector<int>a(b);

方式4:

//将向量b中从0-2（共三个）的元素赋值给a，a的类型为int型
vector<int>a(b.begin(),b.begin+3);

方式5:

 //从数组中获得初值
int b[7]={1,2,3,4,5,6,7};
vector<int> a(b,b+7）;

实例

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v1;//定义一个空的vector
    vector<int> v2(4);//定义一个4个大小的vector，初始为0
    vector<int> v3(4,6);//定义一个4个大小vector，初始为6
    vector<int> v4{1,2,3,4};//c++11新特性，定义一个vector，数字为1,2,3,4
    vector<int> :: iterator it;
    for(it = v2.begin();it != v2.end(); it++){
        cout<<*it<<' ';
    }
    cout<<endl;
    for(auto x:v2) cout<<x<<' ';
    cout<<endl;
    for(auto x:v3) cout<<x<<' ';
    cout<<endl;
    for(auto x:v4) cout<<x<<' ';
    cout<<endl;
    return 0;
}

运行结果：
0 0 0 0
0 0 0 0
6 6 6 6
1 2 3 4

4.2.用at或者[]获取

    vector<int> v{1,2,3,4};
    cout<<v[1]<<endl;//索引为1，v[1]=2;
    cout<<v.at(1)<<endl;//索引为1，v.at(1)=2；

4.3.方法

• push_back()追加内容

    vector<int> v;
    v.push_back(5);
    v.push_back(4);
    v.push_back(3);
    v.push_back(2);
    v.push_back(1);
    for(auto x:v){
        cout<<x<<' ';
    }

运行结果：
5 4 3 2 1

• resize()进行重置大小

    vector<int> v;
    v.push_back(5);
    v.push_back(4);
    v.push_back(3);
    v.push_back(2);
    v.push_back(1);
    for(auto x:v){
        cout<<x<<' ';
    }
    v.resize(10);//重新更改v的大小，对于多出的部分补0，对于少出的不分直接截取部分
    for(auto x:v){
        cout<<x<<' ';
    }//5 4 3 2 1 0 0 0 0 0
    v.resize(3);
    for(auto x:v){
        cout<<x<<' ';
    }//5 4 3

运行结果：
5 4 3 2 1 0 0 0 0 0
5 4 3

• erase()删除元素，复杂度为O(n)

    vector<int> v;
    v.push_back(5);
    v.push_back(4);
    v.push_back(3);
    v.push_back(2);
    v.push_back(1);
    v.erase(v.begin());//删除第一个元素
    v.erase(--v.end());//删除最后一个元素
    for(auto x:v){
        cout<<x<<' ';
    }

运行结果：
4 3 2

• front(),back()
  功能：front()获取第一个元素，相当于*v.begin();back()获取最后一个元素，相当于*v.end()

    //获取第一个元素
    cout<<v.front();
    cout<<v[0];
    cout<<*v.begin();
    //获取最后一个元素
    cout<<v.back();
    cout<<v[v.size()-1];//size()是获取大小
    cout<<*--v.end();

4.4.排序sort()

第三个参数为比较器，不写默认为less()

int main(){
    vector<int> v;
    v.push_back(5);
    v.push_back(3);
    v.push_back(1);
    v.push_back(4);
    v.push_back(2);
    sort(v.begin(),v.end(),less<int>());//从小到大
    for(auto x:v){
        cout<<x<<' ';
    }
    cout<<endl;
    sort(v.begin(),v.end(),greater<int>());//从大到小
    for(auto x:v){
        cout<<x<<' ';
    }
    return 0;
}

4.5.循环

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int main(){
    vector<int> v;
    v.push_back(5);//在v的尾部加入5
    v.push_back(3);//在v的尾部加入3
    v.push_back(1);
    v.push_back(4);
    v.push_back(2);
    for(int i = 0;i < v.size();i++){
        cout<<v[i]<<' ';//vector支持随机访问
    }
    cout<<endl;
    vector<int>::iterator it;
    for(it = v.begin();it != v.end();it++){
        cout<<*it<<' ';
    }
    cout<<endl;
    for(auto it=v.begin();it != v.end();it++){
        cout<<*it<<' ';
    }
    cout<<endl;
    for(auto x:v){
        cout<<x<<' ';
    }

    return 0;
}

5.stack()

概念：栈，栈是一种后进先出的元素序列，访问和删除都只能对栈顶的元素（即最后一个被加入栈的元素）进行，并且元素也只能被添加到栈顶。栈内的元素不能访问。如果一定要访问栈内的元素，只能将其上方的元素全部从栈中删除，使之变成栈顶元素才可以。
先进后出，栈顶进，栈顶出，pop()从栈顶出一个元素，但是不返回元素。

• 构造

stack<int> s;

• push()、pop()、size()、empty()
  push()入栈一个元素
  pop()出栈一个元素，pop无返回值
  top()取出栈顶元素
  size()查看元素个数
  empty()查看栈是否为空，当栈s为空时，返回1；当栈s不空时，返回0。

#include <iostream>
#include <stack>
using namespace std;

int main(){
    stack<int> s;
    s.push(3);
    s.push(2);
    s.push(1);
    cout<<s.top()<<endl;
    s.pop();
    cout<<s.top()<<endl;
    s.pop();
    cout<<s.top()<<endl;
    s.pop();
    cout<<s.size()<<endl;
    cout<<s.empty();//s空，返回1；s不空，返回0
    return 0;
}

• 进制转化（十进制转二进制）

int itob(int dec){
    stack<int> s;
    int res = 0;
    while(dec != 0){
        s.push(dec%2);
        dec /= 2;
    }
    while(!s.empty()){
        res = res*10+s.top();
        s.pop();
    }
    return res;
}

• 逆序单词（拓展sstream，stoi， itoa）
  输入一行字符串，将字符串逆序打印
  输入：hello world my name is steve yu
  输出：yu steve is name my world hello

#include <sstream>
#include <stack>
using namespace std;

int main(){
    stringstream ss;
    string line;
    stack<string> s;
    getline(cin,line);
    ss<<line;//<<箭头流向哪里，输如到哪里
    while(ss>>line){
        s.push(line);
    }
    while(!s.empty()){
        cout<<s.top();
        s.pop();
        if(s.size() != 0) cout<<' ';//s.size()==0与s.empty()效果一样
    }
    return 0;
}

• 数字转字符串

#include <iostream>
#include <sstream>
using namespace std;

int main(){
    //数字转字符串
    //方法一：
    int a = 1234;
    string out;
    stringstream ss;
    ss<<a;
    ss>>out;
    cout<<out<<endl;
    //方法二：(c++11)
    int b = 12345;
    cout<<to_string(b)<<endl;
    return 0;
}

• 字符串转数字

#include <iostream>
#include <sstream>
using namespace std;

int main(){
    //字符串转数字
    //方法一：
    string s="1234";
    int i;
    stringstream ss;
    ss<<s;
    ss>>i;
    cout<<i<<endl;
    //方法二：(c++11)
    string str = "12345";
    i = stoi(str);
    cout<<i<<endl;
    return 0;
}

6.queue队列

概念：queue 就是“队列”。队列是先进先出的，和排队类似。队头的访问和删除操作只能在队头进行，添加操作只能在队尾进行。不能访问队列中间的元素。

• front()：返回 queue 中第一个元素的引用。如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。
• back()：返回 queue 中最后一个元素的引用。如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。
• push(const T& obj)：在 queue 的尾部添加一个元素的副本。这是通过调用底层容器的成员函数 push_back() 来完成的。
• push(T&& obj)：以移动的方式在 queue 的尾部添加元素。这是通过调用底层容器的具有右值引用参数的成员函数 push_back() 来完成的。
• pop()：删除 queue 中的第一个元素。
• size()：返回 queue 中元素的个数。
• empty()：如果 queue 中没有元素的话，返回 true。
• emplace()：用传给 emplace() 的参数调用 T 的构造函数，在 queue 的尾部生成对象。

• swap(queue &other_q)：将当前 queue 中的元素和参数 queue 中的元素交换。它们需要包含相同类型的元素。也可以调用全局函数模板 swap() 来完成同样的操作。

• 构造与常用方法

#include <iostream>
#include <queue>
using namespace std;

int main(){
    queue<int> q;
    q.push(5);//在队列头加入5
    q.push(6);//在队列头加入6
    cout<<q.front()<<endl;//访问队列头的第一个元素
    q.pop();//弹出队列头的第一个元素
    cout<<q.front()<<endl;//访问队列头的第一个元素
    q.pop();
    cout<<q.size();//size()显示队列的大小
    return 0;
}

7.map、unordered_map、pair

概念：映射（map为树状表，unodered_map为哈希表）

• map
  在map中使用下标访问不存在的元素将导致在map容器中添加一个新的元素

#include <iostream>
#include <map>
using namespace std;

int main(){
    map<int,int> m;//键值有序的，树状结构（底层）
    m[6] = 3;//在map中使用下标访问不存在的元素将导致在map容器中添加一个新的元素
    m.insert(make_pair(3,2));
    m[7] = 9;
    for(auto it = m.begin(); it != m.end(); it++){
        cout<<it->first<<' '<<it->second<<endl;
    }
    for(auto x:m) cout<<x.first<<' '<<x.second<<endl;
    return 0;
}

运行结果：（结果显示键值有序，默认按升序排序）
3 2
6 3
7 9
3 2
6 3
7 9

• undered_map

#include <iostream>
#include <unordered_map>
using namespace std;

int main(){
    unordered_map<int,int> m;//键值无序的，哈希结构（底层）
    m[6] = 3;
    m[3] = 2;
    m[7] = 9;
    for(auto it = m.begin(); it != m.end(); it++){
        cout<<it->first<<' '<<it->second<<endl;
    }
    for(auto x:m) cout<<x.first<<' '<<x.second<<endl;
    return 0;
}

运行结果：（结果显示键值无序）
7 9
3 2
6 3
7 9
3 2
6 3

• pair的用法
  功能：pair将一对值组合成一个值，这一对值可以具有不同的数据类型（T1和T2），两个值可以分别用pair的两个公有函数first和second访问。

1. 定义（构造）：

pair<int ,double> p1;//默认构造函数
pair<int ,double> p2(1, 2.4);//用给定值初始化
pair<int ,double> p3(p2);//拷贝构造函数

1. makepair的用法:
   除了构造函数，标准库还定义了一个make_pair函数，由传递给它的两个实参生成一个新的pair对象

vec.push_back(make_pair(20,30));
vec.push_back(make_pair<int,int>(10,50));

1. 在vector中的pair的使用:

//声明vector：
vector<pair<int,int>>vec
//往vector中插入数据，需要用到make_pair:
vec.push_back(make_pair(20,30));
vec.push_back(make_pair<int,int>(10,50));

1. map转成vector进行排序：

#include <iostream>
#include <unordered_map>
#include <algorithm>
using namespace std;
bool cmp(pair<int,int> a,pair<int,int> b){
    return a.first > b.first;
}
int main(){
    unordered_map<int,int> m;//键值无序的，哈希结构（底层）
    m[6] = 3;
    m[3] = 2;
    m[7] = 9;
    vector <pair<int,int>> v(m.begin(),m.end());
    sort(v.begin(),v.end());
    for(auto it = m.begin(); it != m.end(); it++){
        cout<<it->first<<' '<<it->second<<endl;
    }
    for(auto x:m) cout<<x.first<<' '<<x.second<<endl;
    return 0;
}

8.set（undered_set）集合

概念：集合是一种包含已排序对象的关联容器。set/multiset会根据待定的排序准则，自动将元素排序。两者不同在于前者不允许元素重复，而后者允许。
不能直接改变元素值，因为那样会打乱原本正确的顺序，要改变元素值必须先删除旧元素，则插入新元素
不提供直接存取元素的任何操作函数，只能通过迭代器进行间接存取，而且从迭代器角度来看，元素值是常数
元素比较动作只能用于型别相同的容器(即元素和排序准则必须相同)

• 创建set集合对象

#include<iostream>
#include<set>
using namespace std;
int main()
{
    set<int> s;
    return 0;
}

• 元素的插入和遍历
  采用inset()方法把元素插入到集合中，插入规则在默认的比较规则下，是按元素值从小到大插入，如果自己指定了比较规则函数，则按自定义比较规则函数插入。
  使用前向迭代器对集合中序遍历，结果正好是元素排序后的结果。

#include<iostream>
#include<set>
using namespace std;
int main()
{
    set<int> s;
    s.insert(5); //第一次插入5，可以插入
    s.insert(1);
    s.insert(6);
    s.insert(3);
    s.insert(5); //第二次插入5，重复元素，不会插入
    set<int>::iterator it; //定义前向迭代器
    //中序遍历集合中的所有元素
    for(it = s.begin(); it != s.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
    return 0;
}
//运行结果：1 3 5 6

• 元素的方向遍历
  使用反向迭代器reverse_iterator可以反向遍历集合，输出的结果正好是集合元素的反向排序结果。
  它需要用到rbegin()和rend()两个方法，它们分别给出了反向遍历的开始位置和结束位置。

#include<iostream>
#include<set>
using namespace std;
int main()
{
    set<int> s;
    s.insert(5); //第一次插入5，可以插入
    s.insert(1);
    s.insert(6);
    s.insert(3);
    s.insert(5); //第二次插入5，重复元素，不会插入
    set<int>::reverse_iterator rit; //定义反向迭代器
    //反向遍历集合中的所有元素
    for(rit = s.rbegin(); rit != s.rend(); rit++)
    {
        cout << *rit << " ";
    }
    cout << endl;
    return 0;
}
//运行结果：6 5 3 1

• 元素的删除
  与插入元素的处理一样，集合具有高效的删除处理功能，并自动重新调整内部的红黑树的平衡。
  删除的对象可以是某个迭代器位置上的元素、等于某键值的元素、一个区间上的元素和清空集合。
  erase(iterator),删除定位器iterator指向的值
  erase(first,second),删除定位器first和second之间的值
  erase(key_value),删除键值key_value的值

• 元素的检索
  使用find()方法对集合进行检索，如果找到查找的的键值，则返回该键值的迭代器位置；否则，返回集合最后一个元素后面的一个位置，即end()。
  find()--返回一个指向被查找到元素的迭代器
  count()--返回某个值元素的个数

#include <iostream>
#include <set>
#include <algorithm>
using namespace std;
int main(){
    set<int> s;
    s.insert(5);
    s.insert(1);
    s.insert(6);
    s.insert(3);
    s.insert(5);
    set<int> :: iterator it;
    it = s.find(6);
    if(it != s.end())
        cout<<*it<<endl;
    else
        cout<<"not find it"<<endl;
        it = s.find(20);
    if(it != s.end())
        cout << *it << endl;
    else
        cout << "not find it" << endl;
    if(s.count(6)!= 0)
        cout<<"在集合中"<<endl;
    return 0;
}
运行结果：
6
not find it
在集合中

• 应用计数、去重

#include <iostream>
#include <set>
#include <unordered_set>
using namespace std;
int main(){
    set<int> s;//树状结构，有序
    unordered_set<int> s1;//哈希结构，无序，快
    s.insert(5);
    s.insert(1);
    s.insert(6);
    s.insert(3);
    s.insert(5);
    s.insert(5);
    s.insert(5);
    s.insert(5);
    cout<<s.size()<<endl;
    for(auto x:s)
        cout<<x<<" ";
    cout<<endl;
    set<int> :: iterator it;
    for(it = s.begin();it != s.end();it++)
        cout<<*it<<" ";
    return 0;
}

9.deque

概念：双端队列是一种具有队列和栈的性质的数据结构。双端队列的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。

//a) 构造函数
deque<int> ideq
//b)增加函数
 ideq.push_front(x):双端队列头部增加一个元素X
 ideq.push_back(x):双端队列尾部增加一个元素x
//c)删除函数
ideq.pop_front():删除双端队列中最前一个元素
ideq.pop_back():删除双端队列中最后一个元素
ideq.clear():清空双端队列中元素
//d)判断函数
ideq.empty() :向量是否为空，若true,则向量中无元素
//e)大小函数
ideq.size():返回向量中元素的个数

10.list

概念：双端链表，不能使用下标运算符 [] 访问其中的元素，与向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢。

• list定义与初始化

    list<int>lst1;          //创建空list
    list<int>lst2(5);       //创建含有5个元素的list
    list<int>lst3(3,2);  //创建含有3个元素的list,初始为2
    list<int>lst4(lst2);    //使用lst2初始化lst4
    list<int>lst5(lst2.begin(),lst2.end());  //同lst4

• list常用操作方法

Lst1.assign() 给list赋值
Lst1.back() 返回最后一个元素
Lst1.begin() 返回指向第一个元素的迭代器
Lst1.clear() 删除所有元素
Lst1.empty() 如果list是空的则返回true
Lst1.end() 返回末尾的迭代器
Lst1.erase() 删除一个元素
Lst1.front() 返回第一个元素
Lst1.get_allocator() 返回list的配置器
Lst1.insert() 插入一个元素到list中
Lst1.max_size() 返回list能容纳的最大元素数量
Lst1.merge() 合并两个list
Lst1.pop_back() 删除最后一个元素
Lst1.pop_front() 删除第一个元素
Lst1.push_back() 在list的末尾添加一个元素
Lst1.push_front() 在list的头部添加一个元素
Lst1.rbegin() 返回指向第一个元素的逆向迭代器
Lst1.remove() 从list删除元素
Lst1.remove_if() 按指定条件删除元素
Lst1.rend() 指向list末尾的逆向迭代器
Lst1.resize() 改变list的大小
Lst1.reverse() 把list的元素倒转
Lst1.size() 返回list中的元素个数
Lst1.sort() 给list排序
Lst1.splice() 合并两个list
Lst1.swap() 交换两个list
Lst1.unique() 删除list中重复的元素

1. sort() 函数模板定义在头文件 algorithm 中，要求使用随机访问迭代器。但 list 容器并不提供随机访问迭代器，只提供双向迭代器，因此不能对 list 中的元素使用 sort() 算法。但是，还是可以进行元素排序，因为 list 模板定义了自己的 sort() 函数。sort() 有两个版本：无参 sort() 函数将所有元素升序排列。第二个版本的 sort() 接受一个函数对象或 lambda 表达式作为参数，这两种参数都定义一个断言用来比较两个元素。
2. list 的成员函数 merge() 以另一个具有相同类型元素的 list 容器作为参数。两个容器中的元素都必须是升序。参数 list 容器中的元素会被合并到当前的 list 容器中。

实例：sort()

#include <iostream>
#include <list>
#include <algorithm>
using namespace std;

int main(){
    list<int> li;
    li.push_back(6);
    li.push_front(5);
    li.emplace_front(9);
    li.emplace_back(10);
    li.insert(li.begin()++,2);
    for(auto tmp:li) cout<<tmp<<" ";
    cout<<endl;
    li.sort();
    for(auto it=li.begin();it!=li.end();it++) cout<<*it<<" ";
    return 0;
}
运行结果：
2 9 5 6 10
2 5 6 9 10

STL

标签：cin   main   检索   大小   ace   空格   直接   key   间接   

原文地址：https://www.cnblogs.com/blink-cz/p/12230923.html