c++ map、multimap 的使用方法

一、区别

1. Map：一对一；有序( 自动按 key 升序 )；可用 [ ] 赋值和取值；采用 红黑树 结构；实现O(lgn)的查找，插入和删除

2. Mulitimap：多对多；有序( 自动按 key 升序 )；无[ ] 操作；可自定义排序函数；采用 红黑树 结构

                multimap<char, int, less<char> > --->less<char>为默认函数，较小的放在前面 即：升序排序

                multimap<char, int, greater<char> > --->greater<char> 系统函数 较大的放前 即：降序排序【可传入自定义排序函数】
3. unordered_map：无序map，采用 hash table 结构

4. unordered_mulitimap：无序mulitimap，采用 hash table 结构

5. map 与 unordered_map 使用时机

map

>通常使用red-black tree实现.
元素被排序.
>相对较小的内存使用(不需要额外的内存用于哈希表).
>相对快速查找：O(log N).

unordered_map

>通常使用hash-table实现.
元素没有排序.
>需要额外的内存来保留哈希表.
>快速查找O(1),但是恒定时间取决于可能相对较慢的hash-function.还要记住,你可以见到Birthday problem.

有序容器里的数据是按关键字的字典顺序进行存储存放的。

二、Map

Map是c++的一个标准容器，它提供了很好一对一的关系，在一些程序中建立一个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;

如在打枚举中打印 “指定值对应的字符串”时，可是采用map<int, string>的STL实现。

static inline const char * 
VNET_TYPE_STRING(vnet_type_t type)
{
    static VALUE_STRING_STRUCT g_type_string[] =
    {
        { VNET_TYPE_UNKOWN, "unkown1" },
        { VNET_TYPE_SOCKET, "socket" },
        { VNET_TYPE_RDP,    "rdp" },
        { VNET_TYPE_PCOIP,  "pcoip" },
        { VNET_TYPE_ICA, "ica" },
		{ VNET_TYPE_XRED, "xred" },
        { 0, NULL },
    };
    return GetValueString(g_type_string, (ULONG)type);
}

static inline const TCHAR *
GetValueString(VALUE_STRING_STRUCT *vsarray, ULONG value)
{
    VALUE_STRING_STRUCT *tmp = vsarray;
 
    while ( tmp->string != NULL )
    {
        if ( tmp->value == value )
        {
            return tmp->string;
        }
        tmp++;
    }
    return _T("unkown");
}

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;
 
	system("pause");
}
 

运行结果是：

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;
 
}

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的函数

三、C++中map用法

/************************************************************************
*
* Map的特点: 1、存储Key-value对
* 2、支持快速查找，查找的复杂度基本是Log(N)
* 3、快速插入，快速删除，快速修改记
*
/************************************************************************/
#include <iostream>
#include <string>
#include <map> 
using namespace std; 
int main()
{
	map<const char*,int> m;
	m["a"]=1;
	m["b"]=6;
	m["c"]=9;
	map<const char*,int>::iterator it;
	it=m.begin();
	const char* c =it->first;
	cout<<"first element is :"<<c<<endl;
	int i = m["c"];
	while(it!=m.end()){
		cout << it->first<<";"<<it->second<<endl;
		++it;
	}
	cout <<"m[\"c\"]="<<i<<endl;
	cout <<"sizeof m:"<<m.size()<<endl;
	cout <<"erase m[\"c\"](1:succ 0:failed):"<<m.erase("c")<<endl;
	cout <<"erase m[\"c\"]:"<<m.erase("c")<<endl;
	cout <<"sizeof m:"<<m.size()<<endl;
	cout<<"m[c]="<<m["c"]<<endl;
	cout<<"sizeof m :"<<m.size()<<endl;
 
	system("pause");
	return 0;
}

请注意上面打感叹号的地方，map的大小因此调用了“cout<<"m[c]="<<m["c"]<<endl;”而增加了1个。这点真的另人很奇怪。！！！！

四、multimap 的使用方法

/*
 *
 ********************************************
 *  multimap多重映照容器的基础说明：
 ********************************************
 *
 * multimap多重映照容器:容器的数据结构采用红黑树进行管理
 * multimap的所有元素都是pair:第一元素为键值(key),不能修改;第二元素为实值(value),可被修改
 *
 * multimap特性以及用法与map完全相同，唯一的差别在于:
 * 允许重复键值的元素插入容器(使用了RB-Tree的insert_equal函数) 
 * 因此:
 * 键值key与元素value的映照关系是多对多的关系
 * 没有定义[]操作运算 
 * 
 * Sorted Associative Container  Pair Associative Container   Unique Associative Container
 *
 * 使用multimap必须使用宏语句#include <map>          
 *
 **************************************************************************************
 *
 * 创建multimap对象:
 * //元素键值类型为char,映照数据类型为int,键值的比较函数对象为greater<char>
 * 1.multimap<char,int,greater<char> > a;
 * //指定一个比较函数对象comp来创建map对象   
 * 2.multimap(const key_compare& comp)
 * //multimap<int,char*> b(a); //此时使用默认的键值比较函数less<int>
 * 3.multimap(const multisetr&);
 * 4.multimap(first,last);         
 * 5.multimap(first,last,const key_compare& comp);  
 *
 * //Example:
 * pair<const int ,char> p1(1,'a');
 * pair<const int ,char> p2(2,'b');
 * pair<const int ,char> p3(3,'c');
 * pair<const int ,char> p4(4,'d');
 * pair<const int ,char> pairArray[]={p1,p2,p3,p4};
 * multimap<const int,char> m4(pairArray,pairArray+5);
 * multimap<const int,char> m3(m4);
 * multimap<const int,char,greater<const int> > m5(pairArray,pairArray+5,greater<const int>());
 *
 **************************************************************************************
 *
 * 元素的插入
 * //typedef pair<const key,T> value_type;
 * pair<iterator,bool> insert(const value_type& v);    
 * iterator insert(iterator pos,const value_type& v);
 * void insert(first,last);
 *
 **************************************************************************************
 *
 * 元素的删除
 * void erase(iterator pos);
 * size_type erase(const key_type& k);     //删除等于键值k的元素
 * void erase(first,last);        //删除[first,last)区间的元素
 * void clear();
 *
 **************************************************************************************
 *
 * 访问与搜索
 *
 * iterator begin();iterator end();     //企图通过迭代器改变元素是不被允许的
 * reverse_iterator rbegin();reverse_iterator rend();
 *
 * iterator find(const key_type& k) const;
 * pair<iterator,iterator> equal_range(const key_type& k) const;//返回的pair对象，
 *                //first为lower_bound(k);大于等于k的第一个元素位置
 *                //second为upper_bound();大于k的第一个元素位置
 *
 * 其它常用函数
 * bool empty() const;
 * size_type size() const;
 * size_type count(const key_type& k) const;   //返回键值等于k的元素个数
 * void swap();
 *
 * iterator lower_bound(); // 上界
 * iterator upper_bound(); // 下届
 * pair<iterator,iterator> equal_range();// 确定区间
 *
 *
 *
 ********************************************
 **   cumirror ** tongjinooo@163.com **    **
 ********************************************
 *
 */
 
#include <map>
#include <string>
#include <iostream>
 
// 基本操作与set类型,牢记map中所有元素都是pair
// 对于自定义类,初学者会觉得比较函数如何构造很麻烦,这个可以参照前面的书写示例
// 但若设置键值为int或char类型，无须构造比较函数
 
struct student{
 char* name;
 int age;
 char* city;
 char* phone;
};
 
int main()
{
	 using namespace std;
 
	 student s[]={
	  {"童进",23,"武汉","XXX"},
	  {"老大",23,"武汉","XXX"},
	  {"饺子",23,"武汉","XXX"},
	  {"王老虎",23,"武汉","XXX"},
	  {"周润发",23,"武汉","XXX"},
	  {"周星星",23,"武汉","XXX"}
	 };
	  pair<int,student> p1(4,s[0]);
	  pair<int,student> p2(2,s[1]);
	  pair<int,student> p3(3,s[2]);
	  pair<int,student> p4(4,s[3]);  //键值key与p1相同
	  pair<int,student> p5(5,s[4]);
	  pair<int,student> p6(6,s[5]);
	 multimap<int,student> a;
	 a.insert(p1);
	 a.insert(p2);
	 a.insert(p3);
	 a.insert(p4);
	 a.insert(p5);
	 a.insert(p6);
	 typedef multimap<int,student>::iterator int_multimap;
	 pair<int_multimap,int_multimap> p = a.equal_range(4);
	 int_multimap i = a.find(4);
	 cout<<"班上key值为"<< i->first<<"的学生有："<<a.count(4)<<"名,"<<"   他们是:"<<endl;
	 for(int_multimap k = p.first; k != p.second; k++)
	 {
		cout<<k->second.name<<endl;
	 }
	 cout<<"删除重复键值的同学"<<endl;
	 a.erase(i);
	 cout<<"现在班上总人数为："<<a.size()<<".   人员如下："<<endl;
	 for(multimap<int,student>::iterator j=a.begin(); j != a.end(); j++)
	 {      
		  cout<<"The name: "<<j->second.name<<"      "<<"age: "<<j->second.age<<"   "
		   <<"city: "<<j->second.city<<"      "<<"phone: "<<j->second.phone<<endl;
	 }
 
	 return 0;
}