STL 相关

C++的STL(Standard Template Library,标准模板库)从广义上讲分为algorithm（算法）、container（容器）和iterator（迭代器）三类，包含了诸多在计算机科学领域里面所常用的基本数据结构和基本算法。

在C++标准里面，STL被组织为下面的13个头文件：< algorithm >、< deque >、< functional >、< iterator >、< vector >、< list >、< map >、< memory >、< numeric >、< queue >、< set >、< stack >、< utility >。

vector 向量容器

vector 向量容器是一种简单高效的容器，在尾端插入和删除元素，算法时间为$O(1)$，其他元素插入和删除时间为$O(n)$。vector可动态调整所占用的内存空间。

用数组访问vector元素的参考代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<iostream>
#include<vector>
using namespace std;

int main()
{
	vector < int > v ;
	v.push_back(20);                                    //尾端插入新元素
	v.push_back(26);
	v.push_back(12);
	for(int i = 0 ; i < v.size() ; i++ ){
		cout<<v[i]<<' ';
	}
	getchar();
	return 0;
}

用迭代器访问vector的参考代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include<iostream>
#include<vector>
using namespace std;

int main()
{
	int j ;
	vector < int > v ;
	v.push_back (1) ;                                    //尾端插入新元素
	v.push_back (2) ;
//	v.clear () ;                                         //全部元素清空                                    
	v.push_back ( 4 ) ;
	v.insert ( v.begin() + 2 , 9 ) ;                     //插入9在第二个后面            
	v.insert ( v.begin()  , 5 ) ;                        //插入5为首元素
	v.insert ( v.end()    , 12 ) ;                       //插入12为末元素
	v.erase ( v.begin() + 1 ) ;                          //删除第二个元素
	v.erase ( v.begin() , v.begin() + 2 ) ;              //删除前三个元素
 	vector < int > :: iterator i ;                       //迭代器，相当于游标

 	for( i = v.begin() , j = 0 ; i != v.end() ; i++ , j++ ){
 		cout<<"v["<<j<<"]="<<*i<<endl;
 	}

 	swap(v[1],v[2]);                                     //交换

    for( i = v.begin() , j = 0 ; i != v.end() ; i++ , j++ ){
 		cout<<" v[ "<<j<<" ]= "<<*i<<endl;
 	}

 	cout<<v.empty()<<endl;                               //判断是否为空

 	cout<<v.size()<<endl;                                //元素实际个数

 	cout<<v.max_size()<<endl;                            //可容纳的最大元素个数

 	cout<<v.capacity()<<endl;                            //当前可容纳的最大元素个数

 	cout<<v.front()<<endl;                               //首元素引用

 	cout<<v.back()<<endl;                                //末元素引用

 	v.pop_back();                                        //删除末尾的一个元素

 	v.reserve(30);                                       //调整数据空间大小

 	cout<<v.capacity()<<endl;

 	vector < int > :: reverse_iterator ri ;              //反向迭代器

 	for( ri = v.rbegin() ; ri != v.rend() ; ri++ ){      //首尾反向
 		cout<<*ri<<endl;
 	}
 	
	getchar();
	return 0;
}

结构体容器参考代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include<iostream>
#include<vector>
using namespace std;

struct stu{
	int x;
	int y;
};

int main()
{
	int j ;
	vector < stu > v_1 ;                                  //结构体容器
	vector < stu > v_2 ;
	struct stu a = { 1 , 2 } ;
	struct stu b = { 2 , 3 } ;
	struct stu c = { 4 , 5 } ;
	v_1.push_back( a ) ;
	v_1.push_back( b ) ;
	v_1.push_back( c ) ;
	v_2.push_back( c ) ;
	v_2.push_back( b ) ;
	v_2.push_back( a ) ;
	cout<<"v1:\n";
	for(int i = 0 ; i < v_1.size() ; i++ ){
		cout<<v_1[i].x<<' '<<v_1[i].y<<'\n';
	}
	cout<<"v2:\n";
	for(int i = 0 ; i < v_2.size() ; i++ ){
		cout<<v_2[i].x<<' '<<v_2[i].y<<'\n';
	}
	swap(v_1,v_2);                                              //两结构体元素交换
	cout<<"v1:\n";
	for(int i = 0 ; i < v_1.size() ; i++ ){
		cout<<v_1[i].x<<' '<<v_1[i].y<<'\n';
	}
	cout<<"v2:\n";
	for(int i = 0 ; i < v_2.size() ; i++ ){
		cout<<v_2[i].x<<' '<<v_2[i].y<<'\n';
	}
	getchar();
	return 0;
}

deque双端队列容器

deque与vector很相似，不仅可以在尾部插入和删除元素，还可以在头部插入和删除元素，时间复杂度为$O(1)$，考虑到容器元素的内存分配策略和操作性能时，deque比vector有优势。

由于使用了Map管理以及块为单位进行内存分配，所以不易实现capacity和reverse函数（也不需要这种函数）。

参考程序如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include<iostream>
#include<deque>
using namespace std;

int main(){
	deque <string> d ;
	d.push_back("la");
	d.push_back("2");
	d.push_back("3");
	d.push_front("front");                              // 高效的头部插入元素
	//d.pop_front();                                    // 删除首元素
	//d.pop_back();                                     // 删除尾元素
	//d.erase(d.begin()+1);                             // 删除指定位置元素
	//d.clear();                                        // 删除所有元素
	d.insert(d.end()-2,"insert");                       // 指定位置插入
	for( int i = 0 ; i < d.size() ; i++){               // 数组方式访问
		cout<<d[i]<<' ';
	}
	cout<<'\n';
	
	
	deque<string>::iterator i;                          // 迭代器访问
	for(i=d.begin();i!=d.end();i++){
		cout<<*i<<' ';
	}
	cout<<endl;
	swap(d[1],d[2]);                                    // 两元素交换，可以交换两个queue的所有元素
	
	deque<string>::reverse_iterator pi;
	for(pi=d.rbegin();pi!=d.rend();pi++){
		cout<<*pi<<' ';
	}
	cout<<endl;
	
	cout<<"deque 是否有元素"<<d.empty()<<endl;
	cout<<"deque 元素个数为"<<d.size()<<endl;
	cout<<"deque 首元素为"<<d.front()<<endl;
	cout<<"deque 尾元素为"<<d.back()<<endl;
	cout<<"deque 的最大容量为"<<d.max_size()<<endl;
	getchar();
}

list双向链表容器

list双向链表中任一位置的元素查找、插入、和删除都具有高效的常熟阶算法时间复杂度$O(1)$。

常用方法参考程序如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include<iostream>
#include<list>
using namespace std;

struct student{
	char *name;
	int age ;
	char *city;
};

void print(list<student>&l){
	list<student>::iterator i ;
	for(i=l.begin();i!=l.end();i++){
		cout<<(*i).name<<' ';
		cout<<(*i).age<<' ';
		cout<<(*i).city<<endl;
	}
}

int main(){
	student s[]={
		{"Zhang",18,"Zhe"},
		{"Li",18,"Bei"},
		{"Wang",18,"Shang"},
	};
	list<student>l;
	l.push_back(s[0]);                                      // 插入元素
	l.push_back(s[1]);
	l.push_back(s[2]);
	student x = {"Kang",18,"Jiang"};
	l.push_front(x);                                        // 插入到首位置，复杂度为$O(1)$
	l.insert(l.begin(),x);                                  // 插入到任意位置，时间复杂度为$O(1)$
	//l.pop_front();                                        // 删除首元素
	//l.pop_back();                                         // 删除尾元素
	l.erase(l.begin());
	//l.remove(2);                                          // 删除所有值为2的元素，结构体未知方法
	//l.clear();                                            // 删除所有元素
	//l.earse(l.begin(),l.end());                           // 删除区间的元素，方法未完全掌握
	print(l);
	
	list<student>::reverse_iterator ri;
	for(ri=l.rbegin();ri!=l.rend();ri++){
		cout<<(*ri).name;
	}
	return 0;
}

链表归并的参考代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include<iostream>
#include<list>
using namespace std;

struct student{
	char *name;
	int age ;
	char *city;
};

void print(list<int>l){
	list<int>::iterator i ;
	for(i=l.begin();i!=l.end();i++){
		cout<<*i<<' ';
    }
    cout<<'\n';
}

int main(){
    list <int >l_1;
    for(int j=10;j>=0;j--){
        l_1.push_back(j);
    }

    list <int >l_2;
    list <int >::iterator ii ;
    ii=l_2.begin()++;
    l_2.splice(l_2.begin(),l_1);                        //将l_1的全部元素归并到l_2上，l_1清空
    l_1.splice(l_1.begin(),l_2,ii);                     //将l_2的ii位置的元素归并到l_1，l_2原元素删除
    swap(l_1,l_2);                                      //交换l_1,l_2
    l_1.sort();                                         //排序
    l_1.push_back(8);
    l_1.push_back(8);
    l_1.push_back(35);
    l_2.push_back(30);
    l_1.unique();                                       //除去连续重复元素
    l_2.merge(l_1);                                     //l_1归并到l_2，需要两个链表均排序，最后的结果也为排序结果
    print(l_1);
    print(l_2);
    return 0;
}

set集合容器

set集合容器使用一种红黑树的平均二叉检索树，不会将重复键值插入，检索效率高($\log n $)。检索使用二叉树的中序遍历，因此可以将元素从小到大排列出来。

红黑树的节点结构如下表格所示：

颜色 左指针 父指针 右指针 数据

红黑树的建立是一个复杂的过程，一般方法是每次插入一个新节点（黑色根节点除外），都着色为红色，然后再检查红黑树定义是否被破坏，否则要进行子树的左右旋转以作平衡处理。

参考代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include<iostream>
#include<set>
using namespace std;


int main(){
    set<int >s;

    for(int i=1;i<=20;i++){
        pair<set<int>::iterator,bool>p=s.insert(i);       //判断是否插入成功
        if(p.second)
            cout<<"插入成功"<<endl;
        else
            cout<<"插入失败，已存在该元素，不能重复插入"<<endl;

    }
    set<int>s2(s);                                       //拷贝s生成s2
    s.erase(s.begin());
    s.erase(s.erase(10));

    s.insert(5);                                         //不会重复插入
    set<int >::iterator ii ;                             //遍历
    for(ii=s.begin();ii!=s.end();ii++)
        cout<<*ii<<' ';
    cout<<endl<<"反向遍历"<<endl;
    set<int >::reverse_iterator ri ;
    for(ri=s.rbegin();ri!=s.rend();ri++)
        cout<<*ri<<' ';
    cout<<"元素个数为:"<<s.size();
    cout<<"是否为空："<<s.empty();
    ii=s.find(10);                                       //查找元素的值，如果指标不在末尾，则找到输出
    if(ii!=s.end())
        cout<<"\n查找="<<*ii;
    return 0;
}

set_intersection()

C++ STL 提供求交集的函数 set_intersection( ) 、求集合差的函数 set_difference( ) 和合并两个集合的函数 set_union( ) 。以 set_intersection( ) 为例，分析两端程序并简单记录其用法：

nums1：1，2，2，1

nums2：2，2

1
2
3
4
5
6
7
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> res;
        set<int> cod1(nums1.begin(),nums1.end());
        set<int> cod2(nums2.begin(),nums2.end());
        std::set_intersection(cod1.begin(),cod1.end(),cod2.begin(),cod2.end(),insert_iterator<vector<int>>(res,res.begin()));
        return res;    // res：2
    }

1
2
3
4
5
6
7
vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> res;
        std::sort(nums1.begin(),nums1.end());
        std::sort(nums2.begin(),nums2.end());
        std::set_intersection(nums1.begin(),nums1.end(),nums2.begin(),nums2.end(),insert_iterator<vector<int>>(res,res.begin()));
        return res;    // res：2，2
    }

首先传递的容器必须是排序的，set 容器中元素默认是排序的，而 vector 需要调用 sort 函数进行排序。其次 set_intersection( )中最后存放交集的容器的容量必须要足够大到能放下所有的元素，即函数只执行复制，不是插入！但是模板 insert_iterator 可以将复制转换为插入，可以解决该问题。

set_intersection( ) 不是 set 的方法，而是一个通用函数，而 set 函数必须要满足这些算法！使用 set 时，可以自动忽略重复的元素，而使用 vector 时可以保留重复的元素，即保留了‘个数’这一信息。

该函数的时间复杂度为线性复杂度，其实现为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 OutputIterator result)
{
  while (first1!=last1 && first2!=last2)
  {
    if (*first1<*first2) ++first1;
    else if (*first2<*first1) ++first2;
    else {
      *result = *first1;
      ++result; ++first1; ++first2;
    }
  }
  return result;
}

multiset多重集合容器

multiset多重集合容器可将重复元素插入

参考代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include<iostream>
#include<set>
using namespace std;


int main(){
    multiset< int > ms;
    ms.insert(10);
    ms.insert(13);
    ms.insert(11);
    ms.insert(13);
    ms.insert(12);
    ms.insert(13);

    int v=121;
    multiset<int>::iterator ii=ms.find(v);
    if(ii!=ms.end())
        cout<<*ii<<endl;

        v=11;
    pair<multiset<int>::iterator ,multiset<int>::iterator >p=ms.equal_range(v);
    cout<<"大于等于11第一个元素的为"<<*p.first<<endl;
    cout<<"大于11的第一个元素的为"<<*p.second<<endl;

    multiset<int>::iterator i;
    for(i=p.first;i!=p.second;i++)
        cout<<*i<<' ';
    cout<<"等于13的个数："<<ms.count(13);
    //以下两行无法执行
    //cout<<"键值大于等于12的第一个元素位置"<<ms.lower_bound(12)<<endl;
    //cout<<"键值大于12的第一个元素位置"<<ms.upper_bound(12)<<endl;
    return 0;
}

map映照容器

map映照容器的元素数据是一个键值和一个映照数据组成的，键值与映照数据之间具有一一映照的关系。

map映照容器的数据结构是采用红黑树来实现的，插入键值的元素不允许重复，比较函数只对元素的键值进行比较，元素的各项数据可通过键值检索出来。

简单的参考程序如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
#include<map>
#include<iostream>
using namespace std;
int main(){
	map<const char * , float > m ;
	m["apple"]=3.4;
	m["orange"]=1.2;
	m["pear"]=3.5;
	cout<<m["apple"]<<endl;
	cout<<m["orange"]<<endl;
	cout<<m["pear"]<<endl;
	return 0;
}

又一个使用map映照容器的参考代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<map>
#include<iostream>

using namespace std;

int main(){
	map< int , string > mapstudent ;
	mapstudent[1]="student_one";
	mapstudent[1]="student_two";
	mapstudent[2]="student_three";
	map<int ,string >::iterator iter;
	for(iter=mapstudent.begin();iter!=mapstudent.end();iter++)
		cout<<iter->first<<" "<<iter->second<<endl;
	return 0;
}

双一个使用map映照容器的参考代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include<map>
#include<iostream>

using namespace std;

int main(){
	map< int , string > mapstudent ;
	mapstudent[1]="student_one";
	mapstudent[1]="student_two";                           //id相同，则忽略
	mapstudent[2]="student_three";
	pair<map<int ,string >::iterator,bool>pa;
	if(!pa.second)                                         //id相同，则忽略
		cout<<"error"<<endl;
	mapstudent.insert(pair<int ,string>(5,"student_two"));
	mapstudent.insert(pair<int ,string>(6,"student_three"));
	map<int , string >::iterator iter;
	for(iter=mapstudent.begin();iter!=mapstudent.end();iter++)
		cout<<iter->first<<" "<<iter->second<<endl;
	//搜索学号为2的记录并且打印
	map<int ,string>::iterator ii = mapstudent.find(2);
	cout<<"学号为"<<(*ii).first<<' '<<(*ii).second<<endl;
	return 0;
}

结构体示例程序如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include<map>
#include<iostream>

using namespace std;

struct StuInfo{                                      //学生信息结构体
	char * name;
	int year ;
	char * add;
};

struct StuReco{                                      //学生记录结构体
	int id ;                                         //学号作为键值
	StuInfo sf;                                      //学生信息作为映照数据
};

int main(){
	
	StuReco stArray[]={
		{1,"Li",21,"Bei"},
		{2,"Wang",29,"Shang"},
		{3,"Zhang",30,"Sheng"}
	};
	
	map< int , StuInfo > m ;
	for(int j=0;j<3;j++){                            //装入三个学生信息
		m[stArray[j].id]=stArray[j].sf;
	}
	
	StuReco stu_1={1,"Ling",23,"Xin"};
	//正向遍历
	map<int , StuInfo>::iterator i;
	for(i=m.begin();i!=m.end();i++)
		cout<<(*i).first<<' '<<(*i).second.name<<' '<<(*i).second.year<<' '<<(*i).second.add<<endl;
	
	map<int , StuInfo>::reverse_iterator ri;
	//逆向遍历
	for(ri=m.rbegin();ri!=m.rend();ri++)
		cout<<(*ri).first<<' '<<(*ri).second.name<<' '<<(*ri).second.year<<' '<<(*ri).second.add<<endl;
	//查找记录
	i=m.find(2);
	cout<<"记录为 2 "<<(*i).first<<' '<<(*i).second.name<<' '<<(*i).second.year<<endl;
		
	return 0;
}

pair是一个模板类，你可以理解成一个仅存储两个元素的结构体，第一个是first，第二个是seconditerator指向map成员，map的每一个成员都是一个pair，只是将它的first作为红黑树的排序key。一个map中没有相同的key的元素，即没有两个pair的first相同。

map与set的区别是：map是处理带有键值的记录型元素数据的快速插入、删除和检索，而set是对单一数据的处理，map不允许重复的元素键插入，map与set都是泛型库对二叉树的一个泛化。

multimap 多重映照容器

multimap多重映照容器与map映照容器基本相同，唯独不同的是，multimap允许重复键值的存在，所以，multimap的元素的插入、删除、查找都与map不相同。

参考代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include<map>
#include<iostream>
using namespace std;

int main(){
	multimap< string , double > mp ;                            //定义map对象，当前没有任何元素
	mp.insert(pair<string,double>("Jack",300.5));               //插入元素
	mp.insert(pair<string,double>("Kity",200));
	mp.insert(pair<string,double>("Memi",500));
	mp.insert(pair<string,double>("Jack",306));                 //重复插入键值“jack”
	multimap< string , double >::iterator it ;                  //使用前向迭代器中序遍历multimap
	mp.erase("Jack");                                           //删除键值等于“jack”的元素
	for(it=mp.begin();it!=mp.end();it++){         
		cout<<(*it).first<<' '<<(*it).second<<' '<<endl;
	}
	
	it=mp.find("Nacy");                                        //元素的查找
	if(it!=mp.end()){                                          //找到
		cout<<(*it).first<<' '<<(*it).second<<' '<<endl;
	}
	else {                                                     //没找到
		cout<<"404 Not Found "<<' '<<endl;
	}
	return 0;
}

stack堆栈容器

堆栈容器是一个线性表，插入和删除只在线性表的一端进行。一端称为栈顶 (Stack Top)；另一端称为栈底(Stack Bottom)。堆栈的元素插入称为入栈，元素的删除称为出栈。由于元素的入栈和出栈总在栈顶进行，因此，堆栈是一个后进先出(Last In First Out)的线性表结构，即LIFO表。
C++的STL的stack堆栈容器不设置最大容量，提供入栈、出栈、栈顶元素访问和判断是否为空的基本操作。

参考程序如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<stack>
#include<iostream>
#define stack_size 100
using namespace std;

int main(){
	stack<string>s;
	s.push("aaa");
	s.push("bbb");
	s.push("ccc");
	if(s.size()<stack_size)                                  //可限制大小
	s.push("68");
	while(!s.empty()){
		cout<<s.top()<<endl;
		s.pop();
	}
	return 0;
}

queue队列容器

queue队列容器是一个线性存储表，与后进先出的堆栈不同，元素的插入在线性表的一端进行，删除在另一端进行。从而构成了一个先进先出（First In First Out）表。插入一段称为队尾，删除一端称为队首。
C++的STL的queue队列容器提供基本操作。

参考程序如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<queue>
#include<iostream>
#define queue_size 100
using namespace std;

int main(){
	queue<int>q;
	q.push(3);
	q.push(5);
	q.push(2);
	cout<<"ÔªËظöÊýΪ£º"<<' '<<q.size()<<endl;
	cout<<q.back()<<endl;                                //取队尾元素
	while(!q.empty()){                         
		cout<<q.front()<<endl;                           //打印队首元素
		q.pop();
	}
	return 0;
}

priority_queue优先队列容器

优先队列是一种容器适配器，它的第一个元素（位于头部top）总是队列中最大的元素,这里的“最大”是指队列元素的严格弱序中的“最大”。严格弱序是一系列数或事物按照一定的比较关系”<”排列得出的序列，“<”可以是数学中进行数值比较的大于，也可以是小鱼，还可以是其他含义。

priority_queue优先队列容器使用堆排序算法，每次将最大值或最小值出列。时间复杂度为$\long n $。

创建一个优先队列的格式为priority_quque，可以看出，创建一个优先队列默认需要三个参数（实际应用上有些参数可以省去）参数见解释 ：

T:队列中元素的数据类型。
Container：用于存储和访问队列队列元素的底层容器的类型。
Compare：比较关系，默认是数值上的小于关系，比如 1<2 , 6<7 , 此时队列中元素从队头到队尾由大到小排列，采用默认compare时此参数可以省去。当需要采用其他标准进行比较时需要额外定义这一比较方式。当满足比较关系“<”时，返回true，否则返回false。

参考代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<iostream>
#include<queue>
#define size_ 100
using namespace std;

int main(){
	priority_queue<int >q ;
	q.push(93);
	q.push(5);
	q.push(2);
	q.push(33);
	q.push(52);
	q.push(12);
	
	cout<<"ÔªËظöÊýΪ £º "<<q.size()<<endl;
	
	while(!q.empty()){
		cout<<q.top()<<endl;
		q.pop();
	}
	return 0;
}

另一个参考代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include<iostream>
#include<queue>
#define size_ 100
using namespace std;

class cmp{
	public:
		bool operator()(const int a , const int b){
			return  a > b ;
		}
};

int main(){
	priority_queue<int ,vector<int>,cmp>que1 ;
	priority_queue<int ,vector<int> >que2 ;
	
	int a[]={1,3,4,2,5,0,6};
	for(int i=0;i<7;i++){
		que1.push(a[i]);
		que2.push(a[i]);
	}
	cout<<"que1 : ";
	while(!que1.empty()){
		cout<<que1.top()<<" ";
		que1.pop();
	}
	cout<<endl<<"que1 : ";
	while(!que2.empty()){
		cout<<que2.top()<<" ";
		que2.pop();
	}
	return 0;
}

STL到底是好还是不好？我个人偏向于赞成用STL，同样是在战场别人有飞机加大炮，你为何还要坚持小米加步枪？

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

ChenShou <br><br> 已是打工人 , 懒散无志向 <br> 专业是电子 , 却喜欢算法 <br><br> 不怎么会使用电焊 <br> 但是爱折腾服务器 <br><br> 目前就职于柏楚，嵌入式方向，还在努力转正<br><br><br> 儒雅随和，乐于交友