c++中std::set自定义去重和排序函数,stdset

  c++中的std::set,是基于红黑树的平衡二叉树的数据结构达成的一种容器,因为里面所包涵的要素的值是有一无二的,因而根本用以去重和排序。那篇文章的意在研讨和享受什么正确行使std::set达成去重和排序作用。

c++中std::set自定义去重和排序函数,stdset

  c++中的std::set,是依据红黑树的平衡二叉树的数据结构落成的一种容器,因为里面所包蕴的要素的值是天下无双的,由此根本用以去重和排序。那篇小说的意在斟酌和享受怎么样科学行使std::set达成去重和排序功用。

  1.方法一:使用std::set内置的less比较函数(直接定义内置类型的set对象)

   这种方式适用于:1)相比较int、char等内置类型。2)只好针对某一个放权类型去重和排序:纵然想透过id(int)去重,并因而hot(int)排序,该种方法就束手无策了。代码如下:

 1 #include <iostream>
 2 #include <set>
 3 using namespace std;
 4 void main()
 5 {
 6     std::set<int> mySet;    // 直接定义内置类型set集合
 7     mySet.insert(10);       // 默认比较函数为less
 8     mySet.insert(20);       // 从小到大排序
 9     for(auto it:mySet)    
10     {
11         std::cout<<it<<std::endl;
12     }
13     std::cout<<"end"<<std::endl;
14 
15 }

结果如下:
output:
            10
            20
            end

  2.办法二:自定义类(结构体)相比函数

    前文提到:间接定义内置类型的set对象,即接纳std::set内置的默许的less相比较函数,只怕否满足大家的骨子里须求。举个例子:未来有一堆结构体对象,须要将其插入set群集,并依据id去重,依照热度hot实行排序。这年,就必要重新自定义比较函数了。有三种方法能够自定义比较函数:

  2.1 重载<操作符

    为甚么要重载<运算符呢?能或不能够重载”<=”也许”>=”运算符?答案是不能够。差相当少全体的主意或容器都亟待排序来满意数学意义上的标准严刻弱序化,否则那一个方法或容器的一颦一笑将不可预感。假使f(x,y)是二个相比函数。
要是该函数满意如下条件则它是严俊弱序化的。

      1.f(x,x) = false; 

    2. if f(x,y) then !f(y,x)

    3.if f(x,y) and f(y,z) then f(x,z)

    4. if !f(x,y)&&!f(y,x) then x==y; if x==y and y==z then x==z;

看上去某个晕乎,不过不用顾虑,只要你的对比艺术能够满意对相等成分永久再次来到false(记住二个法则:恒久让相比函数对同样成分再次来到false),那您的措施就满意要求了。

    其实,set容器在认清已有成分a和新插入元素b是或不是等于时,是那般做的:1)将a作为左操作数,b作为有操作数,调用相比函数,并重临比较值 
2)将b作为左操作数,a作为有操作数,再调用一回比较函数,并回到相比较值。假使1、2两步的再次来到值都以false,则感到a、b是十分的,则b不会被插入set容器中;如若1、2两步的重临值都是true,则大概发生不明不白行为,由此,记住七个法规:永久让比较函数对一样成分重回false。

#include <iostream>
#include <set>
using namespace std;
struct song
{
    int m_id;
    int m_hot;
    song(int id,int hot)
    {

        this->m_id = id;
        this->m_hot = hot;
    }
    bool operator<(const struct song & right)const   //重载<运算符
    {
        if(this->m_id == right.m_id)     //根据id去重
            return false;
        else
        {
            if(this->m_hot != right.m_hot)
            {
                return this->m_hot > right.m_hot;      //降序
            }
            else
            {
                return this->m_id > right.m_id;     
            }
        }
    }
};
void main()
{
    std::set<song> mySet;
    song s1(10,100);
    song s2(20,200);
    song s3(20,300);
    song s4(30,200);
    mySet.insert(s1);    //插入s1
    mySet.insert(s2);    //插入s2
    mySet.insert(s3);    //s3和s2的id相同,不插入
    mySet.insert(s4);    //插入s4
    for(auto it:mySet)
    {
        std::cout<<"id:"<<it.m_id<<",hot:"<<it.m_hot<<std::endl;
    }
    std::cout<<"end"<<std::endl;
};

结果如下:
id:30,hot : 200
id:20,hot : 200
id:10,hot : 100
end

         2.2 重载()运算符

     具体代码如下:

 1 #include <iostream>
 2 #include <set>
 3 using namespace std;
 4 struct song
 5 {
 6     int m_id;
 7     int m_hot;
 8     song(int id,int hot)
 9     {
10 
11         this->m_id = id;
12         this->m_hot = hot;
13     }
14     /*
15     bool operator<(const struct song & right)const   //重载<运算符
16     {
17         if(this->m_id == right.m_id)     //根据id去重
18             return false;
19         else
20         {
21             if(this->m_hot != right.m_hot)
22             {
23                 return this->m_hot > right.m_hot;      //降序
24             }
25             else
26             {
27                 return this->m_id > right.m_id;     
28             }
29         }
30     }
31     */
32 };
33 struct comp   
34 {
35     bool operator()(struct song left,struct song  right)  //重载()运算符
36     {
37 
38         if(left.m_id == right.m_id)     //根据id去重
39             return false;
40         else
41         {
42             if(left.m_hot != right.m_hot)
43             {
44                 return left.m_hot > right.m_hot;      //降序
45             }
46             else
47             {
48                 return left.m_id > right.m_id;     
49             }
50 
51         }
52     }
53 
54 };
55 void main()
56 {
57     std::set<song,comp> mySet;      //写法和2.1中的的区别
58     song s1(10,100);
59     song s2(20,200);
60     song s3(20,300);
61     song s4(30,200);
62     mySet.insert(s1);    //插入s1
63     mySet.insert(s2);    //插入s2
64     mySet.insert(s3);    //s3和s2的id相同,不插入
65     mySet.insert(s4);    //插入s4
66     for(auto it:mySet)
67     {
68         std::cout<<"id:"<<it.m_id<<",hot:"<<it.m_hot<<std::endl;
69     }
70     std::cout<<"end"<<std::endl;
71 };

结果如下:
id:30,hot : 200
id:20,hot : 200
id:10,hot : 100
end

    

 

c++中的std::set,是凭借红黑树的平衡二叉树的数据结构达成的一种容器,因为内部所包蕴的因素的…

C++STL

本文主要内容如下:

1.vector

1.1vector的定义

1.2vector容器内成分的拜谒

1.3vector常用函数

2.set

2.1 set的定义

2.2set容器内成分的看望

2.3set常用函数

3.string

3.1 string 的定义

3.2string容器内成分的拜望

3.3string 常用函数

4.map

4.1 map的定义

4.2 map容器内成分的访问

4.3 map常用函数

  1. queue

5.1 queue的定义

5.2 queue 容器内成分的拜见

5.3 queue 常用函数

5.4 queue常见用途

6.priority_queue

6.1 priority_queue的定义

6.2 priority_queue 容器内成分的探问

6.3 priority_queue 常用函数

6.4 priority_queue内成分优先级的装置

  1. stack

7.1stack的定义

7.2stack容器内成分的拜访

  1. pair

8.1 pair的定义

8.2 pair桐月素的拜望

8.3 pair常用函数

8.4 pair常见用途

  1. algorithm头文件

 

  1.形式一:使用std::set内置的less相比函数(直接定义内置类型的set对象)

1.vector

向量,长度可变的数组

头文件

#include<vector>

   这种方法适用于:1)比较int、char等内置类型。2)只可以针对某二个平放类型去重和排序:若是想通过id(int)去重,并通过hot(int)排序,该种方法就心有余而力不足了。代码如下:

1.1vector的定义

vector<typename> name;

例如:

vector<int> name;

如果typename是vector

vector<vector<int>>name;

相当于二维数组

vector<typename> ArrayName[arraySize];

例如:

vector<int> vi[100];

 

 1 #include <iostream>
 2 #include <set>
 3 using namespace std;
 4 void main()
 5 {
 6     std::set<int> mySet;    // 直接定义内置类型set集合
 7     mySet.insert(10);       // 默认比较函数为less
 8     mySet.insert(20);       // 从小到大排序
 9     for(auto it:mySet)    
10     {
11         std::cout<<it<<std::endl;
12     }
13     std::cout<<"end"<<std::endl;
14 
15 }

结果如下:
output:
            10
            20
            end

1.2vector容器内元素的拜见

(1)通过下标访谈

vi[index];

(2)通过迭代器访谈

vector<typename>::iterator  it;

例如:

vector<int>::iterator  it;

有上下文意况时,能够直接用
auto it=vi.begin();

例如:

for(auto it=vi.begin();it!=vi.end();it++)

printf(“%d”,*it);

注:vi.begin()和vi.end()左闭右开。

 

  2.措施二:自定义类(结构体)相比函数

1.3vector常用函数

(1)push_back()

在最终增加一个成分。

vi.push_back(i);

(2)pop_back()

去除二个尾成分。

  vi.pop_back();

(3)size()

回到vector成分的个数,注意是unsigned类型。

vi.size();

(4)clear()

清空vector中具有的成分。

vi.clear();

(5)insert()

insert(it,x)在迭代器it前插入三个成分x。

vi: 1 2 3 4 5

vi.insert(vi.begin()+2,-1);

vi:1 2 -1 3 4 5

(6)erase()

1.去除单个元素

vi:5 6 7 8 9

vi.erase(vi.begin()+3)

vi:5 6 7 9

2.删减三个区间内的具备因素

erase[first,last); 左闭右开

vi:5 6 7 8 9

vi.erase(vi.begin()+1,vi.begin+4)

vi:5 9

    前文提到:直接定义内置类型的set对象,即利用std::set内置的暗许的less相比函数,大概或不可能满足我们的实际供给。比如:现在有一堆结构体对象,要求将其插入set群集,并根据id去重,依据热度hot进行排序。那一年,就须要再行自定义相比函数了。有二种艺术能够自定义相比函数:

2.set

聚拢,二个内部自行有序且不含重复成分的容器

头文件

#include<set>

  2.1 重载<操作符

2.1 set的定义

set<typename> name;

例如:

set<int> name;

set数组

set<typename>ArrayName[arraySize];

例如:

set<int> a[100];

    为甚么要重载<运算符呢?能否重载”<=”或然”>=”运算符?答案是不得以。差不离具有的措施或器皿都供给排序来满足数学意义上的正儿八经严谨弱序化,否则那些主意或器皿的一言一行将不可预言。假诺f(x,y)是一个相比函数。
借使该函数知足如下条件则它是严峻弱序化的。

2.2set容器内 成分的访问

set只能用迭代器访问

set<typename>::iterator it;

例如:

set<int>::iterator it;

set<int> st;

for(auto it=st.begin();it!=st.end();it++)

print(“%d”,*it);

 

st:2 3 5

set成分自动递增排序,且自动删除重复元素。

 

注意:不能用it<st.end();

除开vector和string容器外无法用*(it+i)

 

      1.f(x,x) = false; 

2.3set常用函数

(1)insert()

insert(x)将x插入set容器中,并自动递增排序和去重。

st.insert(x)

(2)find()

find(value)重回set中对应值为value的迭代器。

set<int>::iterator it = st.find(2);

(3)erase()

1.去除单个成分

st.erase(it); //it 为迭代器

st.erase(find(100));

st.erase(value),value 为所要删除成分的值。

st.erase(100);

2.删减区间内具有因素

erase[first,last); 左闭右开

st.erase(first,last);

st.erase(it,st.end());

(4)size()

回去set内成分的个数,unsigned类型

(5)clear()

清空set内装有的要素

 

    2. if f(x,y) then !f(y,x)

3.string

字符串数组

    3.if f(x,y) and f(y,z) then f(x,z)

3.1 string 的定义

string str=”abcd”;

    4. if !f(x,y)&&!f(y,x) then x==y; if x==y and y==z then x==z;

3.2string容器内成分的走访

(1)通过下标访谈

str[index];

输出str

cout<<str;

printf(“%s”,str.c_str());

(2)通过迭代器访谈

string迭代器不需求参数

string::iterator it;

for(it=str.begin();it!=str.end();it++)

printf(“%c”,*it);

 

看上去某个晕乎,可是并不是忧虑,只要你的相比较艺术能够满意对相等成分恒久再次来到false(记住三个章法:长久让相比函数对同一成分重临false),那您的措施就满意须要了。

3.3string 常用函数

(1)operator+=

str1+=str2;

(2)compare operator

可一向采取 ==
,!=,<=,<,>,>=十分大小,比较准绳是字典序

(3)length()/size()

回去字符串长度,两个基本一样。

(4)insert()

1.insert(pos.string);

在pos号地方插入字符串string

string str1=”abcxyz”;

string str2=”opq”;

str1.insert(3,str2);

str1:abcopqxyz

2.insert(it,it2,it3);
//it为原字符串待插入地方,it2,it3位待插入字符串首尾迭代器。[it2,it3)
左开右闭

string str1=”abcxyz”;

string str2=”opq”;

str1.insert(str1.begin()+3,str2.begin(),str2.end())

str1:abcopqxyz

(5)erase()

1.去除单个元素

str.erase(it) //it为所要删除元素地点的迭代器

2.去除叁个间距内的具有因素

(1)str.erase(first,last); [first,last)左开右闭

string str=”abcdefg”;

str.erase(str.begin()+2,str.end()-1);

str:abg

(2)str.erase(pos,length);

pos为发端地方,删除前边长度为length的字符串。

string str=”abcdefg”;

str.erase(3,2);

str:abcfg

(6)clear()

str.clear(); 清空字符串

(7)substr()

substr(pos,len); 再次回到从pos号位开首、长度为len的子串。

string str=”Thank you for your smile”;

str.substr(0,5);

Thank

str.substr(14,4);

your

str.substr(19,5);

smile

(8)string::npos

 string::npos是一个常数,其自个儿值为-1,unsigned_int类型,作为find函数失配时的再次来到值。

(9)find()

str1.find(str2);
当str2是str1的子串时,再次来到str2在str第11中学第1回出现的岗位;假如str2不是str1的子串,重返string::npos。

str1.find(str2,pos); 从str1的pos号位开始相配str2,重回值与上文同样。

string str1=”Thank you for your smile”;

string str2=”you”;

string str3=”me”;

cout<<str1.find(str2);

6

cout<<str1.find(str2,7);

14

(10)replace()

1.str1.replace(pos,len,str2);
 把str1从pos号位开首、长度为len的子串替换为str2.

2.str1.replace(it1,it2,str2);
 把str1的迭代器[it1,it2)范围的子串替换来str2.

 

string str1=”Maybe you will turn around”;

string str2=”will not”;

striing str3=”surely”;

 

cout<<str1.replace(10,4,str2);

Maybe you will not turn around

cout<<str1.replace(str1.begin(),str1.begin()+5,str3);

surely you will not turn around

 

    其实,set容器在认清已有成分a和新插入成分b是不是等于时,是这么做的:1)将a作为左操作数,b作为有操作数,调用相比较函数,并再次来到相比值 
2)将b作为左操作数,a作为有操作数,再调用贰遍相比较函数,并回到比较值。假如1、2两步的再次回到值都以false,则以为a、b是十三分的,则b不会被插入set容器中;如果1、2两步的重返值都以true,则大概爆发不明不白行为,因而,记住一个章法:恒久让比较函数对同样成分再次来到false。

4.map

照耀,map能够将别的基本类型(蕴涵STL容器)映射到另外基本项目(包括STL容器)。

例如:

字符串–>页码。

头文件

#include<map>

 

#include <iostream>
#include <set>
using namespace std;
struct song
{
    int m_id;
    int m_hot;
    song(int id,int hot)
    {

        this->m_id = id;
        this->m_hot = hot;
    }
    bool operator<(const struct song & right)const   //重载<运算符
    {
        if(this->m_id == right.m_id)     //根据id去重
            return false;
        else
        {
            if(this->m_hot != right.m_hot)
            {
                return this->m_hot > right.m_hot;      //降序
            }
            else
            {
                return this->m_id > right.m_id;     
            }
        }
    }
};
void main()
{
    std::set<song> mySet;
    song s1(10,100);
    song s2(20,200);
    song s3(20,300);
    song s4(30,200);
    mySet.insert(s1);    //插入s1
    mySet.insert(s2);    //插入s2
    mySet.insert(s3);    //s3和s2的id相同,不插入
    mySet.insert(s4);    //插入s4
    for(auto it:mySet)
    {
        std::cout<<"id:"<<it.m_id<<",hot:"<<it.m_hot<<std::endl;
    }
    std::cout<<"end"<<std::endl;
};

结果如下:
id:30,hot : 200
id:20,hot : 200
id:10,hot : 100
end

4.1 map的定义

map<typename1,typename2> mp;

map<key,value> mp;

map<int,int> mp 相当于常见的int型数组。

 

假定是字符串到整型的炫目,必须用string,不能够用char数组。

map<string,int>  mp;

map的键和值也足以是STL容器。

例如:

map<set<int>,string> mp;

 

         2.2 重载()运算符

4.2 map容器内元素的拜会

1.透过下标访谈

与探望普通数组同样,比方

map<char,int> mp;

mp[‘c’]来采访它对应的卡尺头。

mp[‘c’]=20;

注:map的键值是天下无双的。

2.透过迭代器访谈

map<typename1,typename2>::iterator it;

用it->first访问键

用it->second访问值

map<char,int>mp;

mp[‘m’]=20;

mp[‘r’]=30;

mp[‘a’]=40;

 

for(auto it=mp.begin();it!=mp.end();it++)

printf(“%c %d\n”,it->first,it->second);

 

map会按钮值从小到大自动排序。

 

     具体代码如下:

4.3 map常用函数

(1)find()

find(key)重回键值为key的炫人眼目的迭代器。

auto it = mp.find(‘c’);

(2)erase()

1.去除单个成分。

mp.erase(it);  it为迭代器。

mp.erase(key); key为欲删除的照射的键。

2.剔除二个距离内的有所因素。

map.erase(first,last)  [first,last) 删除迭代器区间,左闭右开。

(3)size()

回来map中映射的对数。

(4)clear()

清空map中全部的因素。

 

 1 #include <iostream>
 2 #include <set>
 3 using namespace std;
 4 struct song
 5 {
 6     int m_id;
 7     int m_hot;
 8     song(int id,int hot)
 9     {
10 
11         this->m_id = id;
12         this->m_hot = hot;
13     }
14     /*
15     bool operator<(const struct song & right)const   //重载<运算符
16     {
17         if(this->m_id == right.m_id)     //根据id去重
18             return false;
19         else
20         {
21             if(this->m_hot != right.m_hot)
22             {
23                 return this->m_hot > right.m_hot;      //降序
24             }
25             else
26             {
27                 return this->m_id > right.m_id;     
28             }
29         }
30     }
31     */
32 };
33 struct comp   
34 {
35     bool operator()(struct song left,struct song  right)  //重载()运算符
36     {
37 
38         if(left.m_id == right.m_id)     //根据id去重
39             return false;
40         else
41         {
42             if(left.m_hot != right.m_hot)
43             {
44                 return left.m_hot > right.m_hot;      //降序
45             }
46             else
47             {
48                 return left.m_id > right.m_id;     
49             }
50 
51         }
52     }
53 
54 };
55 void main()
56 {
57     std::set<song,comp> mySet;      //写法和2.1中的的区别
58     song s1(10,100);
59     song s2(20,200);
60     song s3(20,300);
61     song s4(30,200);
62     mySet.insert(s1);    //插入s1
63     mySet.insert(s2);    //插入s2
64     mySet.insert(s3);    //s3和s2的id相同,不插入
65     mySet.insert(s4);    //插入s4
66     for(auto it:mySet)
67     {
68         std::cout<<"id:"<<it.m_id<<",hot:"<<it.m_hot<<std::endl;
69     }
70     std::cout<<"end"<<std::endl;
71 };

结果如下:
id:30,hot : 200
id:20,hot : 200
id:10,hot : 100
end

5.queue

队列,贰个先进先出的器皿。

头文件

#include<queue>

    

5.1 queue的定义

queue<typename> name;

 

 

5.2 queue 容器内成分的拜见

queue是一种先进先出的限量访谈的数据结构。

只可以front()访谈队首成分,back()访谈队尾成分。

queue<int> q;

q.front();

q.back();

 

5.3 queue 常用函数

(1)push()

q.push(x)将x实行入队

(2)front() / back()

访谈队首和队尾成分。

(3)pop()

q.pop()令队首成分出队。

 

(4)empty()

检查测量检验queue是还是不是为空,重返true为空,重回false则非空。

(5)size()

归来queue内成分的个数。

 

 

5.4 queue常见用途

譬如说广度优先搜索。

 

6.priority_queue

先行队列,底层用堆来落实。在事先队列中,队首成分是方今队列中优先级最高的二个。

 

头文件

#include<queue>

 

6.1 priority_queue的定义

priority_queue<typename> name;

 

6.2 priority_queue 容器内成分的探访

不得不用q.top()函数访谈。

 

6.3 priority_queue 常用函数

(1)push()

q.push(x)将x入队。

(2)top()

q.top()可以获得队首元素。

(3)pop()

令队首成分(堆顶成分)出队。

q.pop();

(4)empty()

检验优先队列是不是为空,为空则重返true,再次来到false为空。

(5)size()

回到优先队列内成分的个数。

 

6.4 priority_queue内成分优先级的设置

1.主导数据类型的事先级设置

主导数据类型指int、double、char型等数据类型。

上面三种优先队列的概念是等价的。

priority_queue<int> q;

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

 

vector<int>
是来承载底层数据结构堆(heap)的容器,而less<int>是相比类。

less<int>
表示数字大的先行级越大,而greater<int>表示数字小的事先级越大。char类型按字典序。

 

2.结构体的开始的一段时期级设置

亟待重载相比符号。

例如:

struct fruit{

string name;

int price;

friend bool operator<(fruit f1,fruit f2){

return f1.price<f2.price;
}

};

认清f1==f2,则一定于!(f1<f2)&&!(f2<f1)。

所以
priority_queue<fruit> q; 内部以价格高的鲜果优先级高。

同理,假设想以价格低的果品为先行级高,那么把<改成>。

struct fruit{

string name;

int price;

friend bool operator<(fruit f1,fruit f2){

return f1.price>f2.price;
}

};

 

注:只可以重载<,重载>会编写翻译错误。

不用greater<typename>,不重载<,不用friend函数

用cmp。

#include<iostream>

#include<queue>

#include<string>

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=”a”;

f1.price=3;

f2.name=”b”;

f2.price=2;

f3.name=”c”;

f3.price=1;

 

q.push(f1);

q.push(f2);

q.push(f3);

 

cout<<q.top().name<<” “<<q.top().price;

return 0;

}

 

结果: c  1

 

 

就算是着力数据类型或任何STL容器(如set),也足以用同一的章程定义优先级。如若协会体内数据较强大,前边加const
& 援用来提升效用。

friend bool operator<(const & fruit f1,const & fruit f2){

return f1.price>f2.price;

}

struct cmp{

bool operator () (const & fruit f1,const & fruit f2){

return f1.price>f2.price;

}

};

 

priority_queue的实质是堆。

 

7.stack

栈,二个后进先出的器皿。

头文件

#include<stack>

7.1stack的定义

stack<typename> name;

 

7.2stack容器内成分的寻访

由于栈是一种后进先出的数据结构,所以不得不用top()来拜访栈顶元素。

st.top();

 

7.3 stack常用函数

(1)push()

st.push(x)将x入栈

(2)top()

st.top()访谈栈顶成分。

(3)pop()

st.pop()删除栈顶成分。

(4)empty()

st.empty()检验是不是为空,为空重回true,不然再次来到false。

(5)size()

st.size()重临栈桐月素的个数。

8.pair

当想要将三个成分绑在一齐作为多个合成成分,又不想定义结构体时,能够动用pair。

头文件

#include<utility>

map实现用了pair,所以#include<map>包含#include<utility>,用map没有须求再蕴涵utility头文件。

pair 相当于

struct pair{

typeName1 first;

typeName2 second;

};

 

8.1 pair的定义

pair<typeName1,typeName2> name;

例如:

pair<string ,int> p;

 

初始化:

pair<string ,int> p(“haha”,5);

pair<string,int> p=make_pair(“haha”,5);

 

8.2 pair桐月素的拜谒

用p.first和p.second访问。

8.3 pair常用函数

(1)比较操作数,pair能够直接行使==,!=,<,<=,>,>=比较大
小。

       比较准绳是先以first的大小作为标准,唯有当first相等时才
去比较second的大大小小。

 

8.4 pair常见用途

例如:

#include<iostream>

#include<map>

using namespace std;

 

int main(){

map<string,int>mp;

mp.insert(make_pair(“heihei”,5));

mp.insert(pair<string,int>(“haha”,10));

//auto it ==map<string,int>::iterator it

for(auto it = mp.begin();it!=mp.end();it++)

cout<<it->first<<” “<<it->second<<endl;

return 0;

}

 

9.algorithm头文件

(1)max() /min()/abs()

max和min重返多少个数x、y中的最大十分小值。abs(x)中x必须为整数,浮点数用math头文件下的fabs()。

(2)swap()

  swap(x,y)交换x和y的值。

(3)reverse()

reverse(it,it2)能够将数组指针在[it1,it2)之间的因素或器皿的迭代器[it1,it2)范围内的因素进行反转。

例如:

int a[10]={10,11,12,13,14,15};

reverse(a,a+4); //将a[0]~a[3} 4个成分反转。

13 12 11 10 14 15

string str =“abcdefghi”

reverse(str.begin()+2,str.begin()+6);

abfedcghi

 

(4)next_permutation()

next_permutation()给出三个系列在全排列中的下一个行列。

例如:

n=3的全排列为

123 132 213 231 312 321

231的下一个队列为312。

int a[10]={1,2,3};

do{

cout<<a[0]<<a[1]<<a[2]<<” ”;

}while(next_permutation(a,a+3));

输出:123 132 213 231 312
321

(5)fill()

fill()能够把数组或某容器的某一段距离赋为某些一样的值,与memset分歧,这里的赋值能够是数组类型对应范围中的放肆值。

int a[5];

fill(a,a+5,233);

(6)sort()

sort(a,a+4); //暗中同意递增排序

cmp函数

bool cmp(int a,int b){
return a>b; //从大到小排序 与priority_queue相反。

}

结构体

struct node{

int x;

int y;

}

 

bool cmp(node a,node b){

    if(a.x!=b.x)
return a.x>b.x; //按x从大到小排序 与priority_queue相反。

 else

return a.y<b.y; //若x相等,则按y从小到大排序。

}

STL中,独有vector,string,deque是足以用sort的,像set、map容器是用红黑树达成的,元素自个儿有序,不允许用sort排序。

 

(7)lower_bound()/upper_bound()

 
lower_bound(first,last,val)用来查找在数组或容器中的[first,last)范围内先是个值大于等于val的成分的职位,假设是数组,再次来到该职位指针;假设是容器,再次回到该地方的迭代器。

upper_bound(first,last,val)用来搜寻数组或容器的[first,last)范围第三个值大于val的因素的地点,借使是数组,重临该岗位指针;假若是容器,重回该岗位的迭代器。

比方数组或容器中一直不寻觅到该因素,则lower_bound()和upper_bound()再次回到能够插入该因素的地点的指针或迭代器。

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注