C++标准模板库(STL)

C++标准模板库(STL)

vector

Introduction

vector:长度根据需要而自动改变的数组。

定义:

vector<typename> name;
vector<typename> Arrayname[arraySize];

如果typename也是一个STL容器,定义时需要记得在>>符号之间加上空格。

如:vector<vector > name;

vector容器内元素的访问

通过下标访问

vector vi;

直接通过vi[index]访问。

通过迭代器访问

实例:

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

int main(){
    vector<int> vi;
    for (int i = 1; i <= 5;++i)
        vi.push_back(i);
    //vi.begin()为取vi的首元素地址,而it指向这个地址
    //vi.end()是尾元素地址的下一个地址
    vector<int>::iterator it = vi.begin();
    //方式一:vi[i]与*(vi.begin()+i)等价
    for (int i = 0; i < 5;i++)
        cout << *(it + i);
    cout << endl;
    //方式二
    for (vector<int>::iterator it = vi.begin(); it != vi.end();it++)
        cout << *it;
    return 0;
}

输出结果:12345

vector常用函数

push_back()

push_back(x)就是在vector后面添加一个元素x,时间复杂度O(n)。

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

int main(){
    vector<int> vi;
    for (int i = 1; i <= 3;++i)
        vi.push_back(i);//将1、2、3依次插入vi末尾
    for (int i = 0; i < vi.size();++i)//size()函数给出vi元素个数
        cout << vi[i]; 
    return 0;
}

输出结果:123

pop_back()

删除vector的尾元素,时间复杂度为O(1)。

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

int main(){
    vector<int> vi;
    for (int i = 1; i <= 3;++i)
        vi.push_back(i); //将1、2、3依次插入vi末尾
    vi.pop_back();      //删除vi的尾元素3
    for (int i = 0; i < vi.size();++i)//size()函数给出vi元素个数
        cout << vi[i]; 
    return 0;
}

输出结果:12

size()

用来获取vector中元素个数,时间复杂度O(1)。

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

int main(){
    vector<int> vi;
    for (int i = 1; i <= 3;++i)
        vi.push_back(i); //将1、2、3依次插入vi末尾
    cout << vi.size();
    return 0;
}

输出结果:3

clear()

清空vector中所有元素,时间复杂度O(N),其中N为vector中元素的个数。

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

int main(){
    vector<int> vi;
    for (int i = 1; i <= 3;++i)
        vi.push_back(i); //将1、2、3依次插入vi末尾
    vi.clear();
    cout << vi.size();
    return 0;
}

输出结果:0

insert()

insert(it,x)用来向vector的任意迭代器it处插入一个元素x,时间复杂度O(N)。

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

int main(){
    vector<int> vi;
    for (int i = 1; i <= 5;++i)
        vi.push_back(i); //将1、2、3、4、5依次插入vi末尾
    for (int i = 0; i < vi.size();++i)
        cout << vi[i];
    cout << endl;
    vi.insert(vi.begin() + 2, 0);//将0插入vi[2]的位置
    for (int i = 0; i < vi.size();++i)
        cout << vi[i];
    return 0;
}

输出结果:

12345
120345
erase()
删除单个元素

erase(it):删除迭代器为it处的元素。

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

int main(){
    vector<int> vi;
    for (int i = 1; i <= 5;++i)
        vi.push_back(i); //将1、2、3、4、5依次插入vi末尾
    for (int i = 0; i < vi.size();++i)
        cout << vi[i];
    cout << endl;
    vi.erase(vi.begin() + 3);//删除vi[3]即删除4
    for (int i = 0; i < vi.size();++i)
        cout << vi[i];
    return 0;
}

输出结果:

12345
1235
删除一个区间内所有元素

erase(first,last):删除[first,last)内所有元素。

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

int main(){
    vector<int> vi;
    for (int i = 1; i <= 5;++i)
        vi.push_back(i); //将1、2、3、4、5依次插入vi末尾
    for (int i = 0; i < vi.size();++i)
        cout << vi[i];
    cout << endl;
    vi.erase(vi.begin()+1,vi.begin()+4);//删除vi[1]、vi[2]、vi[3]
    for (int i = 0; i < vi.size();++i)
        cout << vi[i];
    return 0;
}

输出结果:

12345
15

set

Introduction

set:集合,是一个内部自动有序且不含重复元素的容器。

定义:

set<typename> name;
set<typename> Arrayname[arraySize];

set容器内元素的访问

set只能通过迭代器iterator访问。

set<typename>::iterator it;

只有vector和string支持(it+i)的访问方式。*

实例:

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

int main(){
    set<int> st;
    st.insert(5);
    st.insert(2);
    st.insert(4);
    st.insert(1);
    st.insert(3);
    //set不支持it<st.end()的写法
    for (set<int>::iterator it = st.begin(); it != st.end();it++)
        cout << *it;
    return 0;
}

输出结果:12345

set常用函数

insert()

insert(x)将x插入set容器中,并自动递增排序和去重,时间复杂度O(logN),其中N为set内的元素个数。实例如上“set容器内元素的访问”。

find()

find(value)返回set中对应值为value的迭代器,时间复杂度O(logN),N为set中元素个数。

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

int main(){
    set<int> st;
    for (int i = 1; i <= 3;++i)
        st.insert(i);
    set<int>::iterator it = st.find(2);//在set中查找2,返回其迭代器
    cout << *it;
    //也可以写成cout<<*(st.find(2));
    return 0;
}
size()

size()用来获得set内元素的个数,时间复杂度为O(1)。

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

int main(){
    set<int> st;
    st.insert(2);//插入2 5 4
    st.insert(5);
    st.insert(4);
    cout << st.size();
    return 0;
}

输出结果:3

clear()

clear()清空set中的所有元素,时间复杂度O(N),N为set内元素个数。

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

int main(){
    set<int> st;
    st.insert(2);//插入2 5 4
    st.insert(5);
    st.insert(4);
    st.clear();
    cout << st.size();
    return 0;
}

输出结果:0

erase()
删除单个元素

st.erase(it),it为所需要删除元素的迭代器。时间复杂度O(1),可以结合find()函数使用。

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

int main(){
    set<int> st;
    for (int i = 1; i <=5;++i)
        st.insert(i);
    st.erase(st.find(3));//利用find()函数找到3,然后用erase删除它
    for (set<int>::iterator it = st.begin(); it != st.end();it++)
        cout << *it;
    return 0;
}

输出结果:1245

删除一个区间里所有元素

st.erase(first,last):删除一个区间里所有元素,其中first为所需要删除区间的其实迭代器,last为所需要删除区间的末尾迭代器的下一个地址,即删除[first,last)。时间复杂度O(last-first)。

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

int main(){
    set<int> st;
    for (int i = 1; i <=5;++i)
        st.insert(i);
    st.erase(st.find(3), st.end());//删除元素3到末尾之间的元素,即删除3~5。
    for (set<int>::iterator it = st.begin(); it != st.end();it++)
        cout << *it;
    return 0;
}

输出结果:12

string

Introduction

定义方式与基本数据类型相同,只需要在string后面跟上变量名。

string str;
string str="abcd";//给变量复制初始化

string中内容的访问

通过下表访问
#include<iostream>
#include<string>
using namespace std;

int main(){
    string str = "abcd";
    for (int i = 0; i < str.length();i++)
        cout << str[i];
    return 0;
}

输出结果:abcd

通过迭代器访问

string不像其他STL容器那样需要参数,可以直接定义:

string::iterator it;

实例:

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

int main(){
    string str = "abcd";
    for (string::iterator it = str.begin(); it != str.end();it++)
        cout << *it;
    return 0;
}

输出结果:abcd

string常用函数

operator+=

string加法:可以将两个string直接拼接起来。

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

int main(){
    string str1 = "abc", str2 = "xyz", str3;
    str3 = str1 + str2;//str1与str2拼接,赋值给str3
    str1 += str2;//将str2直接拼接到str1上
    cout << str1 << endl;
    cout << str2 << endl;
    cout << str3 << endl;
    return 0;
}

输出结果:

abcxyz
xyz
abcxyz
compare operator

两个string类型可以直接使用==,!=,<, <=, >, >=比较大小,比较规则是字典序。

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

int main(){
    string str1 = "aa", str2 = "aaa", str3="abc",str4="xyz";
    if(str1<str2)
        cout << "str1<str2" << endl;
    if(str1!=str3)
        cout << "str1!=str3" << endl;
    if(str4>=str3)
        cout << "str4>=str3" << endl;
    return 0;
}

输出结果:

str1<str2
str1!=str3
str4>=str3
length()和size()

leng()返回string的长度,即存放的字符数,时间复杂度O(1)。

string str="abc";
cout<<str.length<<" "<<str.size()<<endl;

输出结果:3 3

insert()
  • insert(pos,string):在pos号位置插入字符串string。

  • insert(it,it2,it3),it为原字符串欲插入位置,it2和it3为待插字符串的首位迭代器,用来表示串[it2,it3)将被插在it的位置上。

    #include<iostream>
    #include<string>
    using namespace std;
    
    int main(){
        string str = "abcxyz", str2 = "opq";//str是原字符串,str2是待插字符串
        //方式一:往str[3]处插入opq
        // str.insert(3, str2);
        //方式二:
        str.insert(str.begin() + 3, str2.begin(), str2.end());
        cout << str << endl;
        return 0;
    }
    

    输出结果:abcopqxyz

clear()

clear()清空string中的数据,时间复杂度O(1)。

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

int main(){
    string str = "abcd";
    str.clear();
    cout << str.length();
    return 0;
}

输出结果:0

erase()

有删除单个元素、删除一个区间里所有元素两种方式。时间复杂度均为O(N)。

删除单个元素
#include<iostream>
#include<string>
using namespace std;

int main(){
    string str = "abcdefg";
    str.erase(str.begin() + 4);//删除4号位(e)
    cout << str;
    return 0;
}

输出结果:abcdfg

删除一个区间内所有元素
  • str.erase(first,last):删除[first,last).
#include<iostream>
#include<string>
using namespace std;

int main(){
    string str = "abcdefg";
    //删除在[str.begin()+2,str.end()]内的元素,即cdefg
    str.erase(str.begin() + 2, str.end());
    cout << str;
    return 0;
}

输出结果:ab

  • str.erase(pos,length),其中pos为需要开始删除的其实位置,length为删除的串长度。
#include<iostream>
#include<string>
using namespace std;

int main(){
    string str = "abcdefg";
    //删除从3号位开始的2个字符,即de
    str.erase(3, 2);
    cout << str;
    return 0;
}

输出结果:abcfg

substr()

substr(pos,len):返回从pos号位开始、长度为len的子串。时间复杂度O(len)。

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

int main(){
    string str = "abcdefg";
    cout << str.substr(0,3);
    return 0;
}

输出结果:abc

string::npos

string::npos是一个常数,本身值为-1,npos用来表示不存在的位置。

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

int main(){
    if(string::npos==-1)
        cout << "-1 is true"<<endl;
    if(string::npos==18446744073709551615)
        cout << "18446744073709551615 is also true";
    return 0;
}

输出结果:

-1 is true
18446744073709551615 is also true
find()

str.find(str2),当str2是str的子串时,返回其在str中第一次出现的位置;如果str2不是str的子串,那么返回string::pos。

str.find(str2,pos):从str的pos号位开始匹配str2,返回值与上相同。

时间复杂度O(mn),n,m分别为str和str2的长度。

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

int main(){
    string str = "Thank you";
    string str2 = "you";
    string str3 = "like";
    cout << str.find(str2) << endl;
    cout << str.find(str3) << endl;
    return 0;
}

输出结果:

6
18446744073709551615
replace()

str.replace(pos,len,str2):把str从pos号位开始、长度为len的子串替换为str2。

str.replace(it1,it2,str2):把str的迭代器[it1,it2)范围的子串替换为str2。

时间复杂度O(str.length())

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

int main(){
    string str = "Thank you for your love";
    string str2 = "her";
    string str3 = "enthusiasm";
    cout << str.replace(14, 4, str2) << endl;
    cout << str.replace(str.end()-4, str.end(), str3);
    return 0;
}

输出结果:

Thank you for her love
Thank you for her enthusiasm

map

Introduction

map:可以将任何基本类型(包括STL容器)映射到任何基本类型(包括STL容器)。

定义:

map<typename1,typename2> mp;//第一个是健的类型,第二个是值的类型。
map<string,int> mp; //字符串到整型的映射,必须使用string而不是char
map<set<int>,string> mp;

map容器内元素的访问

通过下标访问

map中的健是唯一的。

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

int main(){
    map<char, int> mp;
    mp['c'] = 20;
    mp['c'] = 30;//20被覆盖
    cout << mp['c'];
    return 0;
}

输出结果:30

通过迭代器访问

定义:

map<typename1,typename2>::iterator it;

map使用it->first来访问健,it->second来访问值。

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

int main(){
    map<char, int> mp;
    mp['m'] = 20;
    mp['r'] = 30;
    mp['a'] = 40;
    for (map<char, int>::iterator it = mp.begin(); it != mp.end();it++)
        cout << it->first << " " << it->second << endl;
    return 0;
}

输出结果:map会以健从小到大的顺序自动排序。

a 40
m 20
r 30

map常用函数

find()

find(key):返回键为key的映射的迭代器,时间复杂度O(logN),N为map中映射的个数。

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

int main(){
    map<char, int> mp;
    mp['a'] = 1;
    mp['b'] = 2;
    mp['c'] = 3;
    map<char, int>::iterator it = mp.find('b');
    cout << it->first << " " << it->second;
    return 0;
}

输出结果:b 2

erase()
删除单个元素

mp.erase(it):it为需要删除的元素的迭代器。时间复杂度O(N)。

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

int main(){
    map<char, int> mp;
    mp['a'] = 1;
    mp['b'] = 2;
    mp['c'] = 3;
    map<char, int>::iterator it = mp.find('b');//令it指向健为b的映射
    mp.erase(it);
    //mp.erase('b');删除健为b的映射,即b 2
    for (map<char, int>::iterator it = mp.begin(); it != mp.end();it++)
        cout << it->first << " " << it->second << endl;
    return 0;
}

输出结果:

a 1
c 3
删除一个区间内的所有元素

mp.erase(first,last):删除左闭右开的区间[first,last)。时间复杂度O(last-first)。

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

int main(){
    map<char, int> mp;
    mp['a'] = 1;
    mp['b'] = 2;
    mp['c'] = 3;
    map<char, int>::iterator it = mp.find('b');
    mp.erase(it,mp.end());
    for (map<char, int>::iterator it = mp.begin(); it != mp.end();it++)
        cout << it->first << " " << it->second << endl;
    return 0;
}

输出结果:a 1

size()

用来获得map中映射的对数,时间复杂度O(1)。

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

int main(){
    map<char, int> mp;
    mp['a'] = 1;
    mp['b'] = 2;
    mp['c'] = 3;
    cout << mp.size();
    return 0;
}

输出结果:3

clear()

用来清空map中所有元素,时间复杂度O(N),N为map中元素的个数。

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

int main(){
    map<char, int> mp;
    mp['a'] = 1;
    mp['b'] = 2;
    mp['c'] = 3;
    mp.clear();
    cout << mp.size();
    return 0;
}

输出结果:0

queue

Introduction

定义:

queue<typename> name;

queue容器内元素的访问

在STL中只能通过front()来访问队首元素,或是通过back()来访问队尾元素。

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

int main(){
    queue<int> q;
    for (int i = 1; i <= 5;i++)
        q.push(i);//将i压入队列,依次入队1 2 3 4 5
    cout << q.front() << " " << q.back() << endl;
    return 0;
}

输出结果:1 5

queue常用函数实例解析

push()

push(x)将x进行入队,时间复杂度O(1)。

front()、back()

分别获得队首元素和队尾元素,时间复杂度O(1)。

pop()

令队首元素出队,时间复杂度O(1)。

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

int main(){
    queue<int> q;
    for (int i = 1; i <= 5;i++)
        q.push(i);//将i压入队列,依次入队1 2 3 4 5
    for (int i = 1; i <= 3;++i){
        q.pop();//出队1 2 3
    }
    cout << q.front();
    return 0;
}

输出结果:4

empty()
#include<iostream>
#include<queue>
using namespace std;

int main(){
    queue<int> q;
    if(q.empty()==true)//一开始队列中没有元素,所以是空
        cout << "Empty" << endl;
    else
        cout << "Not Empty" << endl;
    q.push(1);
    if(q.empty()==true)//入队后,队列非空
        cout << "Empty" << endl;
    else
        cout << "Not Empty" << endl;
    return 0;
}

输出结果:

Empty
Not Empty
size()
#include<iostream>
#include<queue>
using namespace std;

int main(){
    queue<int> q;
    for (int i = 1; i <= 5;++i)
        q.push(i);
    cout << q.size() << endl;
    return 0;
}

输出结果:5

priority_queue

Introduction

priority_queue称为优先队列,底层是用堆来实现的。在优先队列中,队首元素一定是当前队列中优先级最高的那一个。

定义:

priority_queue<typename> name;

priority_queue容器内元素的访问

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

int main(){
    priority_queue<int> q;
    q.push(3);
    q.push(4);
    q.push(1);
    cout << q.top();
    return 0;
}

输出结果:4

priority_queue常用函数

push()

push(x)令x入队,时间复杂度O(logN),其中N为当前优先队列中的元素个数。

top()

top()可以获得队首元素,时间复杂度O(1)。

pop()

pop()令队首元素出队,时间复杂度O(logN),其中N为当前优先队列中的元素个数。

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

int main(){
    priority_queue<int> q;
    q.push(3);
    q.push(4);
    q.push(1);
    cout << q.top()<<endl;
    q.pop();
    cout << q.top()<<endl;
    return 0;
}

输出结果:

4

3

empty()

检测优先队列是否为空,返回true则空,返回false则非空。时间复杂度O(1)。

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

int main(){
    priority_queue<int> q;
    if(q.empty()==true)
        cout << "Empty" << endl;
    else
        cout << "Not Empty" << endl;
    q.push(1);
    if(q.empty()==true)
        cout << "Empty" << endl;
    else
        cout << "Not Empty" << endl;
    return 0;
}

输出结果:

Empty
Not Empty
size()
#include<iostream>
#include<queue>
using namespace std;

int main(){
    priority_queue<int> q;
    q.push(3);
    q.push(4);
    q.push(1);
    cout << q.size();//优先队列中有3个元素
    return 0;
}

输出结果:3

priority_queue内元素优先级的设置

基本数据类型的设置

此处的基本数据类型就是int型、double 型、char型等可以直接使用的数据类型,一般是数字大的优先级越高。

priority_queue<int> q;
priority_queue<int, vector<int>,less<int> > q;
priority_queue<int, vector<int>,greater<int> > q;

第一个参数如果是double或char型,则需要填写vector或vector;第二个参数填写的是来承载底层数据结构堆(heap)的容器**。第三个参数less则是对第一个参数的比较类,less表示数字大的优先级越大,而greater表示数字小的优先级越大。**

实例:

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

int main(){
    priority_queue<int,vector<int>,greater<int> > q;
    q.push(3);
    q.push(4);
    q.push(1);
    cout << q.top();
    return 0;
}

输出结果:1

结构体优先级的设置

实例:

#include<iostream>
#include<queue>
using namespace std;
struct fruit{
    string name;
    int price;
    friend bool operator<(fruit f1,fruit f2){
        return f1.price > f2.price;
    }
} f1, f2, f3;
int main(){
    priority_queue<fruit> q;
    f1.name = "桃子";
    f1.price = 3;
    f2.name = "梨子";
    f2.price = 4;
    f3.name = "苹果";
    f3.price = 1;
    q.push(f1);
    q.push(f2);
    q.push(f3);
    cout << q.top().name << " " << q.top().price << endl;
    return 0;
}

输出结果:苹果 1

可以看到:优先队列的这个函数与sort中的cmp函数是相反的。

于是,可以将cmp函数写到结构体外面:

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
struct fruit{
    string name;
    int price;
} f1, f2, f3;
struct cmp{
    bool operator() (fruit f1,fruit f2){
        return f1.price > f2.price;
    }
};
int main(){
    priority_queue<fruit,vector<fruit>,cmp> q;
    f1.name = "桃子";
    f1.price = 3;
    f2.name = "梨子";
    f2.price = 4;
    f3.name = "苹果";
    f3.price = 1;
    q.push(f1);
    q.push(f2);
    q.push(f3);
    cout << q.top().name << " " << q.top().price << endl;
    return 0;
}

输出结果:苹果 1

stack

Introdction

定义:

stack<typename> name;

stack容器内元素的访问

在STL中的stack只能通过top()来访问宅顶元素。

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

int main(){
    stack<int> st;
    for (int i = 1; i <= 5;++i)
        st.push(i);//依次入栈1、2、3、4、5
    cout << st.top();//取栈顶元素
    return 0;
}

输出结果:5

stack常用函数

push()

push(x)将x入栈,时间复杂度O(1)。

top()

top()获得栈顶元素,时间复杂度O(1)。

pop()

pop()弹出栈顶元素,时间复杂度O(1)。

实例:

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

int main(){
    stack<int> st;
    for (int i = 1; i <= 5;++i)
        st.push(i);//依次入栈1、2、3、4、5
    for (int i = 1; i <= 3;++i)
        st.pop();//将5 4 3依次出栈
    cout << st.top(); //取栈顶元素
    return 0;
}

输出结果:2

empty()

检测stack是否为空,为空则返回true,不为空返回false;

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

int main(){
    stack<int> st;
    if(st.empty()==true)
        cout << "Empty" << endl;
    else
        cout << "Not Empty" << endl;
    st.push(1);
    if(st.empty()==true)
        cout << "Empty" << endl;
    else
        cout << "Not Empty" << endl;
    return 0;
}

输出结果:

Empty
Not Empty
size()

返回stack内元素个数,时间复杂度O(1)。

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

int main(){
    stack<int> st;
    for (int i = 1; i <= 5;++i)
        st.push(i);
    cout << st.size() << endl;
    return 0;
}

输出结果:5

pair

Introduction

pair可以看作一个内部有两个元素的结构体,其这两个元素的类型是可以指定的。

struct pair{
	typeName1 first;
	typeName2 second;
}

头文件:

#include<utility>

定义:

pair<typeName1,typeName2> name;
pair<string,int> p;
pair<string,int> p("haha",3);
make_pair("haha",5);//使用自带的make_pair函数定义

pair中元素的访问

#include<iostream> 
#include<utility>
#include<string>
using namespace std;
int main(){
    pair<string, int> p;
    p.first = "haha";
    p.second = 5;
    cout << p.first << " " << p.second << endl;
    p = make_pair("xixi", 55);
    cout << p.first << " " << p.second << endl;
    p = pair<string, int>("heihei", 555);
    cout << p.first << " " << p.second << endl;
    return 0;
}

输出结果:

haha 5
xixi 55
heihei 555

pair常用函数

比较操作符:先以first的大小作为标准,只有当first相等时才去判别second的大小。

#include<iostream> 
#include<utility>
#include<string>
using namespace std;
int main(){
    pair<int, int> p1(5, 10);
    pair<int, int> p2(5, 15);
    pair<int, int> p3(10, 5);
    if(p1<p3)
        cout << "p1<p3" << endl;
    if(p1<=p3)
        cout << "p1<=p3" << endl;
    if(p1<p2)
        cout << "p1<p2" << endl;
    return 0;
}

输出结果:

p1<p3
p1<=p3
p1<p2

作为map的健值对来进行插入

#include<iostream> 
#include<map>
#include<utility>
#include<string>
using namespace std;
int main(){
    map<string, int> mp;
    mp.insert(make_pair("heihei", 5));
    mp.insert(pair<string, int>("hahai", 10));
    for (map<string, int>::iterator it = mp.begin(); it !=mp.end();it++)
        cout << it->first << " " << it->second << endl;
    return 0;
}

输出结果:

hahai 10
heihei 5

alogrithm头文件下常用函数

max()、min()、abs()

#include<iostream>
#include<algorithm>
using namespace std;
int main(){
    int x = -1, y = -2;
    cout << max(x, y) << " " << min(x, y) << endl;
    cout << abs(x) << endl;
    return 0;
}

输出结果:

-1 -2
1

swap()

#include<iostream>
#include<algorithm>
using namespace std;
int main(){
    int x = -1, y = -2;
    swap(x, y);
    cout << x << " " << y << endl;
    return 0;
}

输出结果:-2 -1

reverse()

reverse(it,it2)可以将数组指针在[it,it2)之间的元素或容器的迭代器在[it,it2)范围内的元素进行反转。

    #include<iostream>
    #include<algorithm>
    using namespace std;
    int main(){
        int a[10] = {10, 11, 12, 13, 14, 15};
        reverse(a, a + 4);
        for (int i = 0; i < 6;++i)
            cout << a[i] << " ";
        return 0;
    }

输出结果:13 12 11 10 14 15

对容器中的元素进行反转:

    #include<iostream>
    #include<algorithm>
    #include<string>
    using namespace std;
    int main(){
        string str = "abcdefghi";
        reverse(str.begin() + 2, str.begin() + 6);//对str[2]~str[5]反转
        for (int i = 0; i < str.length();++i)
            cout << str[i];
        return 0;
    }

输出结果:abfedcghi

next_permutation()

给出一个序列在全排列中的下一个序列。

    #include<iostream>
    #include<algorithm>
    #include<string>
    using namespace std;
    int main(){
        int a[10] = {1, 2, 3};
        do{
            cout << a[0] << a[1] << a[2] << endl;
        }while(next_permutation(a,a+3));
        return 0;
    }

输出结果:

123
132
213
231
312
321

fill()

fill()可以把数组或容器中的某一段区间赋为某个相同的值。这里的赋值可以是数组类型对应范围中的任意值。

    #include<iostream>
    #include<algorithm>
    #include<string>
    using namespace std;
    int main(){
        int a[5] = {1, 2, 3, 4, 5};
        fill(a, a + 5, 233);//将a[0]~a[4]均赋值为233
        for (int i = 0; i < 5;++i)
            cout << a[i]<<" ";
        return 0;
    }

输出结果:233 233 233 233 233

sort()

sort(首元素地址(必填),尾元素地址的下一个地址(必填),比较函数(非必填))

不写比较函数,则默认递增排序。

基本类型的排序
    #include<iostream>
    #include<algorithm>
    #include<string>
    using namespace std;
    bool cmp(int a,int b){
        return a > b;//a>b时把a放在b前面
    }
    int main(){
        int a[] = {3, 1, 4, 2};
        sort(a, a + 4, cmp);
        for (int i = 0; i < 4;++i)
            cout << a[i] << " ";
        return 0;
    }

输出结果:4 3 2 1

结构体数组的排序
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x, y;
} ssd[10];
bool cmp(node a,node b){
    if(a.x!=b.x)
        return a.x > b.x;//x不等时按照x从大到小排序
    else
        return a.y < b.y;//x相等时按照y从小到大排序
}
int main(){
    ssd[0].x = 2;//{2,2}
    ssd[0].y = 2;
    ssd[1].x = 1;//{1,3}
    ssd[1].y = 3;
    ssd[2].x = 2;//{2,1}
    ssd[2].y = 1;
    sort(ssd, ssd + 3, cmp);
    for (int i = 0; i < 3;++i)
        cout << ssd[i].x << " " << ssd[i].y << endl;
    return 0;
}

输出结果:

2 1
2 2
1 3
容器的排序

只有vector、string、deque是可以使用sort的。

#include<iostream>
#include<algorithm>
using namespace std;
bool cmp(string str1,string str2){
    return str1.length() < str2.length();
}
int main(){
    string str[3] = {"aaaa", "bbb", "ccccc"};
    sort(str, str + 3, cmp);
    for (int i = 0; i < 3;++i)
        cout << str[i] << " ";
    return 0;
}

输出结果:bbb aaaa ccccc

lower_bound()和upper_bound()

lower_bound(first,last,val):用来寻找在数组或容器内[first,last)范围内第一个大于等于val的元素的位置。

lower_bound(first,last,val):用来寻找在数组或容器内[first,last)范围内第一个大于val的元素的位置。

时间复杂度均为O(log(last-first))。

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

int main(){
    int a[10] = {1, 2, 2, 3, 3, 3, 5, 5, 5, 5};
    //寻找3
    //直接令返回值减去数组首地址
    cout << lower_bound(a, a + 10, 3) - a << " " << upper_bound(a, a + 10, 3) - a;
    return 0;
}

输出结果:4 3 2 1

结构体数组的排序
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x, y;
} ssd[10];
bool cmp(node a,node b){
    if(a.x!=b.x)
        return a.x > b.x;//x不等时按照x从大到小排序
    else
        return a.y < b.y;//x相等时按照y从小到大排序
}
int main(){
    ssd[0].x = 2;//{2,2}
    ssd[0].y = 2;
    ssd[1].x = 1;//{1,3}
    ssd[1].y = 3;
    ssd[2].x = 2;//{2,1}
    ssd[2].y = 1;
    sort(ssd, ssd + 3, cmp);
    for (int i = 0; i < 3;++i)
        cout << ssd[i].x << " " << ssd[i].y << endl;
    return 0;
}

输出结果:

2 1
2 2
1 3
容器的排序

只有vector、string、deque是可以使用sort的。

#include<iostream>
#include<algorithm>
using namespace std;
bool cmp(string str1,string str2){
    return str1.length() < str2.length();
}
int main(){
    string str[3] = {"aaaa", "bbb", "ccccc"};
    sort(str, str + 3, cmp);
    for (int i = 0; i < 3;++i)
        cout << str[i] << " ";
    return 0;
}

输出结果:bbb aaaa ccccc

lower_bound()和upper_bound()

lower_bound(first,last,val):用来寻找在数组或容器内[first,last)范围内第一个大于等于val的元素的位置。

lower_bound(first,last,val):用来寻找在数组或容器内[first,last)范围内第一个大于val的元素的位置。

时间复杂度均为O(log(last-first))。

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

int main(){
    int a[10] = {1, 2, 2, 3, 3, 3, 5, 5, 5, 5};
    //寻找3
    //直接令返回值减去数组首地址
    cout << lower_bound(a, a + 10, 3) - a << " " << upper_bound(a, a + 10, 3) - a;
    return 0;
}

输出结果:3 6

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

1100dp

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值