STL讲解容器(map,set,vector,stack,queue)

- 日理万妓 2022-06-07 01:51 171阅读 0赞

**1.Map**

Map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。这里说下map内部数据的组织，map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的，后边我们会见识到有序的好处。

下面举例说明什么是一对一的数据映射。比如一个班级中，每个学生的学号跟他的姓名就存在着一一映射的关系，这个模型用map可能轻易描述，很明显学号用int描述，姓名用字符串描述(本篇文章中不用char \*来描述字符串，而是采用STL中string来描述),下面给出map一个简单的描述代码：

Map<int, string> mapStudent;

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  //用数组方式插入数据  
2.  \#include <map>  
3.  \#include <string>  
4.  \#include <iostream>  
5.  **using** **namespace** std;  
6.  **int** main()  
7.  \{  
8.         map<**int**, string> mapStudent;  
9.         mapStudent\[1\] =  “student\_one”;  
10.        mapStudent\[2\] =  “student\_two”;  
11.        mapStudent\[3\] =  “student\_three”;  
12.        map<**int**, string>::iterator  iter;  
13.        **for**(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)  
14.       \{  
15.           Cout<<iter->first<<”   ”<<iter->second<<end;  
16.       \}  
17. \}

**下面由一个具体的例题来联系一下map:**

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1004

这道题就是说统计气球中出现颜色最多的一种,输出颜色,用了map会发现代码简洁省时间

代码如下;

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include<iostream>  
2.  \#include<cstdio>  
3.  \#include<map>  
4.  **using** **namespace** std;  
5.  **int** main()  
6.  \{  
7.      **int** n;  
8.      string ballon;  
9.      **while**(cin>>n,n)  
10.     \{  
11.         map<string,**int**> m;  
12.         **int** N=n;  
13.         **while**(N--)  
14.         \{  
15.             cin >> ballon;  
16.             m\[ballon\]++;  
17.         \}  
18.         map<string,**int**>::iterator p;  
19.         **int** maxx=0;  
20.         string max\_ballon;  
21.         **for**(p=m.begin();p!=m.end();p++)  
22.         \{  
23.             **if**(p->second>maxx)  
24.             \{  
25.                 maxx=p->second;  
26.                 max\_ballon=p->first;  
27.             \}  
28.         \}  
29.         cout<< max\_ballon << endl;  
30.     \}  
31.     **return** 0;  
32. \}

这个简单说一下就是容器map对应这气球颜色和数量,然后用迭代器通过比较数量大小从而输出对应的颜色.

**下面来一点map常用的操作函数:**

begin() 返回指向map头部的迭代器

clear(） 删除所有元素

count() 返回指定元素出现的次数

empty() 如果map为空则返回true

end() 返回指向map末尾的迭代器

equal\_range() 返回特殊条目的迭代器对

erase() 删除一个元素

find() 查找一个元素

get\_allocator() 返回map的配置器

insert() 插入元素

key\_comp() 返回比较元素key的函数

lower\_bound() 返回键值>=给定元素的第一个位置

max\_size() 返回可以容纳的最大元素个数

rbegin() 返回一个指向map尾部的逆向迭代器

rend() 返回一个指向map头部的逆向迭代器

size() 返回map中元素的个数

swap() 交换两个map

upper\_bound() 返回键值>给定元素的第一个位置

value\_comp() 返回比较元素value的函数

**2.set**

set是关联式容器。set作为一个容器也是用来存储同一数据类型的数据类型，并且能从一个数据集合中取出数据，在set中每个元素的值都唯一，而且系统能根据元素的值自动进行排序。应该注意的是set中数元素的值不能直接被改变。C++ STL中标准关联容器set, multiset, map, multimap内部采用的就是一种非常高效的平衡检索二叉树：红黑树，也成为RB树(Red-Black Tree)。RB树的统计性能要好于一般平衡二叉树，所以被STL选择作为了关联容器的内部结构。

下面还是来一个具体的例子来说明一下,接着总说一下用法

题目链接:http://codeforces.com/problemset/problem/745/A

这道题就是找循环节的个数,因为字符串的长度给的范围很小,所以直接暴力就可以了

先贴代码,再解释:

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include<iostream>  
2.  \#include<cstdio>  
3.  \#include<vector>  
4.  \#include<algorithm>  
5.  \#include<cstring>  
6.  \#include<set>  
7.  **using** **namespace** std;  
8.  **int** main()  
9.  \{  
10.     ios::sync\_with\_stdio(0);  
11.     cin.tie(0);  
12.     string a;  
13.     cin>>a;  
14.     **int** len=a.size();  
15.     a+=a;  
16.     set<string>str;  
17.     **for**(**int** i=0;i<len;i++)  
18.     \{  
19.         string s=a.substr(i,len);  
20.         str.insert(s);  
21.     \}  
22.     cout<<str.size()<<endl;  
23.     **return** 0;  
24. \}

就是先把输入的字符串克隆连接一下,然后用substr截取原长度放到set容器里面,因为set的每个值都是唯一的,所以重复的会自动覆盖,然后最后看容器里面的元素个数就可以了.

**下面说一下set常用操作函数:**

begin()     　　 ,返回set容器的第一个元素

end() 　　　　 ,返回set容器的最后一个元素后面的地址(切记不是返回最后一个元素)

clear()   　　     ,删除set容器中的所有的元素

empty() 　　　,判断set容器是否为空

max\_size() 　 ,返回set容器可能包含的元素最大个数

size() 　　　　 ,返回当前set容器中的元素个数

rbegin　　　　 ,返回的值和end()相同

rend()　　　　 ,返回的值和rbegin()相同

常用操作函数运用:

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  //    >File Name: lianxi1.cpp  
2.  //    > Author: Webwei  
3.    
4.  \#include<iostream>  
5.  \#include<algorithm>  
6.  \#include<set>  
7.  **using** **namespace** std;  
8.  **int** main()  
9.  \{  
10.     set<**int**>s;  
11.     s.insert(1);  
12.     s.insert(2);  
13.     s.insert(3);  
14.     s.insert(1);  
15.     cout<<"set中size的值为:"<<s.size()<<endl;  
16.     cout<<"set中maxsize的值为:"<<s.max\_size()<<endl;  
17.     cout<<"set中第一个元素是:"<<\*s.begin()<<endl;  
18.     cout<<"set中最后一个元素是:"<<\*s.end()<<endl;  
19.     s.clear();  
20.     **if**(s.empty())  
21.     \{  
22.         cout<<"set为空!!!"<<endl;  
23.     \}  
24.     cout<<"set的size值为:"<<s.size()<<endl;  
25.     cout<<"set的maxsize的值为:"<<s.max\_size()<<endl;  
26.     **return** 0;  
27. \}

运行结果如下 :

**\[plain\]**  [view plain][]   [copy][view plain]

1.  set中size的值为:3  
2.  set中maxsize的值为:461168601842738790  
3.  set中第一个元素是:1  
4.  set中最后一个元素是:3  
5.  set为空!!!  
6.  set的size值为:0  
7.  set的maxsize的值为:461168601842738790

**3.vector**

vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的.其实就是用容器充当了数组.如:声明一个int向量以替代一维的数组:vector <int> a;(等于声明了一个int数组a\[\],大小没有指定,可以动态的向里面添加删除)。再如:用vector代替二维数组.其实只要声明一个一维数组向量即可,而一个数组的名字其实代表的是它的首地址,所以只要声明一个地址的向量即可,即:vector <int \*> a.同理想用向量代替三维数组也是一样,vector <int\*\*>a;再往上面依此类推.

还是来一道题,这个题有点难理解,但是理解了这个vector可以较好的掌握.

题目链接:http://codeforces.com/problemset/problem/747/C

题意：给定n个服务器编号1—n，q个任务，每个任务都有一个开始时间t，需要的服务器的个数k，和任务完成需要花的时间d，求每个任务完成所需要的服务器的id号的和最小是多少.

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  //    >File Name: vector.cpp  
2.  //    > Author: Webwei  
3.    
4.  \#include<iostream>  
5.  \#include<algorithm>  
6.  \#include<vector>  
7.  **using** **namespace** std;  
8.  vector<**int**> jq\[105\];  
9.    
10. **int** main()  
11. \{  
12.     ios::sync\_with\_stdio(0);  
13.     cin.tie(0);  
14.     **int** n,q;  
15.     cin>>n>>q;  
16.     **for**(**int** i=0;i<q;i++)  
17.     \{  
18.         **int** t , k , d;  
19.         cin >> t >> k >> d;  
20.         **int** sum=0;  
21.         **int** w = k;  
22.         **for**(**int** i=1;k&&i+k-1<=n;i++)\{  
23.             **if**(jq\[i\].empty()||jq\[i\]\[jq\[i\].size()-1\]<t)   
24.             \{  
25.                 k--;  \}  
26.         \}  
27.         **if**(!k)\{  
28.             k = w;  
29.             **for**(**int** i = 1; k &&i+k-1 <= n ; i++ )\{  
30.                 **if**(jq\[i\].empty()||jq\[i\]\[jq\[i\].size()-1\]<t)\{  
31.                     sum+=i;  
32.                     jq\[i\].push\_back(t+d-1);  
33.                     k--;  
34.                 \}  
35.             \}  
36.         \}  
37.         **if**(sum)  cout<<sum<<'\\n';  
38.         **else** cout<<"-1"<<'\\n';  
39.     \}  
40.     **return** 0;     
41. \}

这个其实也就是用vector开了一个二维数组,i代表机器的型号,然后判断每一次机器的是否空闲或者机器用完的时间是否满足其他时间的利用.下面再来一个不用vector的题解,两者比较理解.

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include <bits/stdc++.h>  
2.  **using** **namespace** std;  
3.  **int** jq\[105\];  
4.  **int** main() \{  
5.      ios::sync\_with\_stdio(0);  
6.      cin.tie(0);  
7.      **int** n, q;  
8.      cin >> n >> q;  
9.      **for** (**int** i = 0; i < q; i++) \{  
10.         **int** t, k, d;  
11.         cin >> t >> k >> d;  
12.         **int** sum = 0;  
13.         **int** q = k;  
14.         **for** (**int** i = 1; k && i + k - 1 <= n; i++) \{  
15.             **if** (jq\[i\] < t) k--;  
16.         \}  
17.         **if** (!k) \{  
18.             k = q;  
19.             **for** (**int** i = 1; k && i + k - 1 <= n ; i++) \{  
20.                 **if** (jq\[i\] < t) \{  
21.                     sum += i;  
22.                     jq\[i\] = t + d - 1;  
23.                     k--;  
24.                 \}  
25.             \}  
26.         \}  
27.         **if** (sum) cout << sum << '\\n';  
28.         **else** cout << "-1\\n";  
29.     \}  
30. \}

**vector常用操作函数:**

push\_back   在数组的最后添加一个数据  
pop\_back    去掉数组的最后一个数据   
at                得到编号位置的数据  
begin           得到数组头的指针  
end             得到数组的最后一个单元+1的指针  
front        得到数组头的引用  
back            得到数组的最后一个单元的引用  
max\_size     得到vector最大可以是多大  
capacity       当前vector分配的大小  
size           当前使用数据的大小  
resize         改变当前使用数据的大小，如果它比当前使用的大，者填充默认值  
reserve      改变当前vecotr所分配空间的大小  
erase         删除指针指向的数据项  
clear          清空当前的vector  
rbegin        将vector反转后的开始指针返回(其实就是原来的end-1)  
rend          将vector反转构的结束指针返回(其实就是原来的begin-1)  
empty        判断vector是否为空  
swap         与另一个vector交换数据

**5.stack**

stack 模板类的定义在<stack>头文件中。  
stack 模板类需要两个模板参数，一个是元素类型，一个容器类型，但只有元素类型是必要  
的，在不指定容器类型时，默认的容器类型为deque。  
定义stack 对象的示例代码如下：  
stack<int> s1;  
stack<string> s2;  
stack 的基本操作有：  
入栈，如例：s.push(x);  
出栈，如例：s.pop();注意，出栈操作只是删除栈顶元素，并不返回该元素。  
访问栈顶，如例：s.top()  
判断栈空，如例：s.empty()，当栈空时，返回true。  
访问栈中的元素个数，如例：s.size()。

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1022

这个题就是进栈和出栈的问题

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  //    >File Name: stack.cpp  
2.  //    > Author: Webwei  
3.    
4.  \#include<iostream>  
5.  \#include<algorithm>  
6.  \#include<stack>  
7.  **using** **namespace** std;  
8.  **int** main()  
9.  \{  
10.     stack<**char**> s;  
11.     **int** n,i,j,k,result\[100\];  
12.     **char** str1\[100\],str2\[100\];  
13.     **while**(cin>>n>>str1>>str2)  
14.     \{  
15.         j=0,i=0,k=1;  
16.         s.push(str1\[0\]);  
17.         result\[0\]=1;  
18.         **while**(i<n&&j<n)  
19.         \{  
20.             **if**(s.size()&&s.top()==str2\[j\])  
21.             \{  
22.                 j++;  
23.                 s.pop();  
24.                 result\[k++\]=0;  
25.             \}  
26.             **else** \{  
27.                 **if**(i==n) **break**;  
28.                 s.push(str1\[++i\]);  
29.                 result\[k++\]=1;  
30.             \}  
31.         \}  
32.         **if**(i==n)  cout<<"No."<<endl;  
33.         **else**  
34.         \{  
35.             cout<<"Yes."<<endl;  
36.             **for**(i=0;i<k;i++)  
37.             \{  
38.                 **if**(result\[i\])  
39.                     cout<<"in"<<endl;  
40.                 **else**  
41.                     cout<<"out"<<endl;  
42.             \}  
43.         \}  
44.         cout<<"FINISH"<<endl;  
45.     \}  
46.     **return** 0;  
47. \}

5.queue

queue 模板类的定义在<queue>头文件中。  
与stack 模板类很相似，queue 模板类也需要两个模板参数，一个是元素类型，一个容器类  
型，元素类型是必要的，容器类型是可选的，默认为deque 类型。  
定义queue 对象的示例代码如下：  
queue<int> q1;  
queue<double> q2;

queue 的基本操作有：  
入队，如例：q.push(x); 将x 接到队列的末端。  
出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。  
访问队首元素，如例：q.front()，即最早被压入队列的元素。  
访问队尾元素，如例：q.back()，即最后被压入队列的元素。  
判断队列空，如例：q.empty()，当队列空时，返回true。  
访问队列中的元素个数，如例：q.size()

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include <cstdlib>  
2.  \#include <iostream>  
3.  \#include <queue>  
4.    
5.  **using** **namespace** std;  
6.    
7.  **int** main()  
8.  \{  
9.      **int** e,n,m;  
10.     queue<**int**> q1;  
11.     **for**(**int** i=0;i<10;i++)  
12.        q1.push(i);  
13.     **if**(!q1.empty())  
14.     cout<<"dui lie  bu kong\\n";  
15.     n=q1.size();  
16.     cout<<n<<endl;  
17.     m=q1.back();  
18.     cout<<m<<endl;  
19.     **for**(**int** j=0;j<n;j++)  
20.     \{  
21.        e=q1.front();  
22.        cout<<e<<" ";  
23.        q1.pop();  
24.     \}  
25.     cout<<endl;  
26.     **if**(q1.empty())  
27.     cout<<"dui lie  bu kong\\n";  
28.     system("PAUSE");  
29.     **return** 0;  
30. \}

[view plain]: http://blog.csdn.net/sinat_35121480/article/details/53771482#