首先是map标准容器提供了很好一对一的关系，在一些程序中建立一个map可以起到事半功倍的效果，总结了一些map基本简单实用的操作！
1. map最基本的构造函数；
map<string , int >mapstring; map<int ,string >mapint;
map<sring, char>mapstring; map< char ,string>mapchar;
map<char ,int>mapchar; map<int ,char >mapint；
2. map添加数据；
map<int ,string> maplive;
1.maplive.insert(pair<int,string>(102,"aclive"));
2.maplive.insert(map<int,string>::value_type(321,"hai"));
3, maplive[112]="April";//map中最简单最常用的插入添加！
3，map中元素的查找：
find()函数返回一个迭代器指向键值为key的元素，如果没找到就返回指向map尾部的迭代器。
map<int ,string >::iterator l_it;;
l_it=maplive.find(112);
if(l_it==maplive.end())
cout<<"we do not find 112"<<endl;
else cout<<"wo find 112"<<endl;
4,map中元素的删除：
如果删除112；
map<int ,string >::iterator l_it;;
l_it=maplive.find(112);
if(l_it==maplive.end())
cout<<"we do not find 112"<<endl;
else maplive.erase(l_it); //delete 112;
5,map中 swap的用法：
Map中的swap不是一个容器中的元素交换，而是两个容器交换；
For example：
#include <map>
#include <iostream>
using namespace std;
int main( )
{
map <int, int> m1, m2, m3;
map <int, int>::iterator m1_Iter;
m1.insert ( pair <int, int> ( 1, 10 ) );
m1.insert ( pair <int, int> ( 2, 20 ) );
m1.insert ( pair <int, int> ( 3, 30 ) );
m2.insert ( pair <int, int> ( 10, 100 ) );
m2.insert ( pair <int, int> ( 20, 200 ) );
m3.insert ( pair <int, int> ( 30, 300 ) );
cout << "The original map m1 is:";
for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
cout << " " << m1_Iter->second;
cout << "." << endl;
// This is the member function version of swap
//m2 is said to be the argument map; m1 the target map
m1.swap( m2 );
cout << "After swapping with m2, map m1 is:";
for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
cout << " " << m1_Iter -> second;
cout << "." << endl;
cout << "After swapping with m2, map m2 is:";
for ( m1_Iter = m2.begin( ); m1_Iter != m2.end( ); m1_Iter++ )
cout << " " << m1_Iter -> second;
cout << "." << endl;
// This is the specialized template version of swap
swap( m1, m3 );
cout << "After swapping with m3, map m1 is:";
for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
cout << " " << m1_Iter -> second;
cout << "." << endl;
}
6.map的sort问题：
Map中的元素是自动按key升序排序,所以不能对map用sort函数：
For example：
#include <map>
#include <iostream>
using namespace std;
int main( )
{
map <int, int> m1;
map <int, int>::iterator m1_Iter;
m1.insert ( pair <int, int> ( 1, 20 ) );
m1.insert ( pair <int, int> ( 4, 40 ) );
m1.insert ( pair <int, int> ( 3, 60 ) );
m1.insert ( pair <int, int> ( 2, 50 ) );
m1.insert ( pair <int, int> ( 6, 40 ) );
m1.insert ( pair <int, int> ( 7, 30 ) );
cout << "The original map m1 is:"<<endl;
for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
cout << m1_Iter->first<<" "<<m1_Iter->second<<endl;
}
The original map m1 is:
1 20
2 50
3 60
4 40
6 40
7 30
7， map的基本操作函数：
C++ Maps是一种关联式容器，包含“关键字/值”对
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的函数
举一个例子：
Updating a Dictionary
Time Limit: 1 Sec Memory Limit: 128 MB
Description
In this problem, a dictionary is collection of key-value pairs, where keys are lower-case letters, and values are non-negative integers. Given an old dictionary and a new dictionary, find out what were changed.
Each dictionary is formatting as follows:
{key:value,key:value,...,key:value}
Each key is a string of lower-case letters, and each value is a non-negative integer without leading zeros or prefix '+'. (i.e. -4, 03 and +77 are illegal). Each key will appear at most once, but keys can appear in any order.
Input
The first line contains the number of test cases T (T<=1000). Each test case contains two lines. The first line contains the old dictionary, and the second line contains the new dictionary. Each line will contain at most 100 characters and will not contain any whitespace characters. Both dictionaries could be empty.
WARNING: there are no restrictions on the lengths of each key and value in the dictionary. That means keys could be really long and values could be really large.
Output
For each test case, print the changes, formatted as follows:
·First, if there are any new keys, print '+' and then the new keys in increasing order (lexicographically), separated by commas.
·Second, if there are any removed keys, print '-' and then the removed keys in increasing order (lexicographically), separated by commas.
·Last, if there are any keys with changed value, print '*' and then these keys in increasing order (lexicographically), separated by commas.
If the two dictionaries are identical, print 'No changes' (without quotes) instead.
Print a blank line after each test case.
Sample Input
3
{a:3,b:4,c:10,f:6}
{a:3,c:5,d:10,ee:4}
{x:1,xyz:123456789123456789123456789}
{xyz:123456789123456789123456789,x:1}
{first:1,second:2,third:3}
{third:3,second:2}
Sample Output
+d,ee
-b,f
*c
No changes
-first
湖南省第八届C题，就是一个比较复杂的字符串匹配问题。要求找出输入两行中新增的、减少的和改变的数据。
直接模拟相当繁琐，在比赛中如果没有优秀的字符串处理功底的确不好做。
以下代码来自网络，附带了很棒的注释，我就不贴自己的丑代码了。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<iostream>
#include<map>
#define LL long long
#define INF 99999999
#define maxn 214748364
using namespace std;
int main()
{
string str1,str2;
int add1,d,m; // <增加的，减少的，价值变化的>关键字的个数
string ad[102],decr[102],mul[102]; // 存储<增加的，减少的，价值变化的>关键字
int t;
cin>>t; //t组数据
while(t--)
{
map<string,string> ma; //主要查找索引的容器
cin>>str1>>str2; //输入两个“字典”
add1=0; //初始化为0，表示都还没有
d=0;
m=0;
int a=0; //截取检索的起始位置为0
while(str1.find(',',a+1)<str1.size()) //当串中没有逗号的时候结束【截取关键字和其价值】
{
string s(str1,a+1,str1.find(',',a+1)-a-1); //截取到一组关键字及其价值【上一个逗号到下一个逗号之间】
string x(s,0,s.find(':',0));
string y(s,s.find(':',0)+1,s.size()-s.find(':',0)); //分离一组关键字及其价值【分号为分割符】
ma.insert(pair<string,string>(x,y)); //把关键字及其价值作为一组索引，插入到容器map中
a=str1.find(',',a+1); //下组关键字截取的起始位置，从本组关键字截取的末尾位置后面的逗号的下一个字符开始
}
string s(str1,a+1,str1.find('}',a+1)-a-1); //逗号为界的已经截取完，最后一组数据，截取标志是【右大括号】
string x(s,0,s.find(':',0));
string y(s,s.find(':',0)+1,s.size()-s.find(':',0));
if(x.size()!=0) ma.insert(pair<string,string>(x,y)); //若最后一组是【空】，该字典为空字典，截取的空字符串不予处理
a=0;
while(str2.find(',',a+1)<str2.size())
{
string s(str2,a+1,str2.find(',',a+1)-a-1);
string x(s,0,s.find(':',0));
string y(s,s.find(':',0)+1,s.size()-s.find(':',0));
if(ma.find(x)==ma.end())ad[add1++]=x; //在容器map中检索不到关键字x，x是新加进来的，更新【增加的关键字的串数组（添加）】
else //在map中检索到该关键字
{
string temp=ma.find(x)->second; //取出容器中该关键字对应的价值
if(temp!=y)mul[m++]=x; //价值不同，改变【价值变化关键字的串数组（增加）】
ma.erase(x); //检索应用过的，直接删除，免得影响后面的操作
}
a=str2.find(',',a+1);
}
string s1(str2,a+1,str2.find('}',a+1)-a-1);
string x1(s1,0,s1.find(':',0));
string y1(s1,s1.find(':',0)+1,s1.size()-s1.find(':',0));
if(x1.size()!=0) //【第二个字典是空字典】
{
if(ma.find(x1)==ma.end())ad[add1++]=x1;
else
{
string temp=ma.find(x1)->second;
if(temp!=y1)mul[m++]=x1;
ma.erase(x1);
}
}
while(ma.begin()!=ma.end()) //处理两个字典对照后，容器中的关键字【第一个字典更新后，删掉的关键字】
{
string temp=ma.begin()->first;
decr[d++]=temp;
ma.erase(temp);//处理过的就删除，知道容器为空，处理结束
}
if(add1==0&&d==0&&m==0)cout<<"No changes"<<endl; //关键字变化的总个数为0【字典更新后没有变化】
else
{
if(add1!=0) //字典跟新后，关键字有增加
{
sort(ad,ad+add1);
cout<<"+";
for(int i=0;i<add1;i++)
{
if(i!=0)cout<<",";
cout<<ad[i];
}
cout<<endl;
}
if(d!=0) //字典更新后，关键字减少
{
sort(decr,decr+d);
cout<<"-";
for(int i=0;i<d;i++)
{
if(i!=0)cout<<",";
cout<<decr[i];
}
cout<<endl;
}
if(m!=0) //字典更新后，有关键字的价值变化
{
sort(mul,mul+m);
cout<<"*";
for(int i=0;i<m;i++)
{
if(i!=0)cout<<",";
cout<<mul[i];
}
cout<<endl;
}
}
cout<<endl;
}
return 0;
}
扫一扫
175
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
