精华内容
下载资源
问答
  • 这是语言缺少的multimap集合(这也是创建适当的库/包的一种简单做法)。 多重映射(有时也称为多重哈希或多重字典)是映射或关联数组抽象数据类型的概括,其中多个以上值可以与给定键相关联并返回给定键。 此数据...
  • 一、multimap(一对多索引) C++ multimap和map所支持的操作相同(除了multimap不支持下标运算),但是multimap允许重复的元素。 完整程序代码: /*请务必运行以下程序后对照阅读*/ ///头文件依旧是map #include #...
  • 通过multimap进行信息的插入 key(部门编号) value(员工) 分部门显示员工信息 实现步骤: 创建10名员工,放到vector中 遍历vector容器,取出每个员工,进行随机分组 分组后,将员工部门编号作为key,具体员工作为...
  • MultiMAP是一种集成单细胞多组学的方法。 MultiMAP也可以用于批量校正。 更多详细信息可在我们的。 安装 我们正在努力让包装上pip尽快。 同时享受此占位符解决方案! git clone ...
  • multimap

    2020-03-21 13:55:36
    multimap template<class Key, class T, class Pred = less<Key>, class A = allocator<T> > class multimap { …. typedef pair<const Key, T> value_type; ……. }; //Key 代表关键字的...

    multimap

    template<class Key, class T, class Pred = less<Key>,
    class A = allocator<T> >
    class multimap {.
    typedef pair<const Key, T> value_type;
    …….
    }; //Key 代表关键字的类型
    

     multimap中的元素由 <关键字,值>组成,每个元素是一个pair对象,关键字
    就是first成员变量,其类型是Key
     multimap 中允许多个元素的关键字相同。元素按照first成员变量从小到大
    排列,缺省情况下用 less 定义关键字的“小于”关系。

    multimap::value_type是multimap的成员,可以直接调用它来实例化pair对象:
    eg:

    multimap<int, double> m1;
    m1.insert(m1::value_type(1,2.1));
    
    #include <iostream>
    #include <map>
    using namespace std;
    int main() {
    typedef multimap<int,double,less<int> > mmid;
    mmid pairs;
    cout << "1) " << pairs.count(15) << endl;
    pairs.insert(mmid::value_type(15,2.7));//typedef pair<const Key, T> value_type;
    pairs.insert(mmid::value_type(15,99.3));
    cout <<2)<< pairs.count(15) << endl; //求关键字等于某值的元素个数
    pairs.insert(mmid::value_type(30,111.11));
    pairs.insert(mmid::value_type(10,22.22));
    pairs.insert(mmid::value_type(25,33.333));
    pairs.insert(mmid::value_type(20,9.3));
    for( mmid::const_iterator i = pairs.begin();
    i != pairs.end() ;i ++ )
    cout << "(" << i->first << "," << i->second << ")" << ",";
    } 
    

    输出:

    1. 0
    2. 2
      (10,22.22),(15,2.7),(15,99.3),(20,9.3),(25,33.333),(30,111.11)

    map

    template<class Key, class T, class Pred = less<Key>,
    class A = allocator<T> >
    class map {.
    typedef pair<const Key, T> value_type;
    …….
    };
    

     map 中的元素都是pair模板类对象。关键字(first成员变量)各不相同。元
    素按照关键字从小到大排列,缺省情况下用 less,即“<” 定义“小
    于”。

    map的[ ]成员函数

    若pairs为map模版类的对象,
    pairs[key]
    返回对关键字等于key的元素的值(second成员变量)的引用。若没有关键
    字为key的元素,则会往pairs里插入一个关键字为key的元素,其值用无参
    构造函数初始化,并返回其值的引用.

    若pairs为map模版类的对象,
    pairs[key]
    返回对关键字等于key的元素的值(second成员变量)的引用。若没有关键
    字为key的元素,则会往pairs里插入一个关键字为key的元素,其值用无参
    构造函数初始化,并返回其值的引用.
    如:
    map<int,double> pairs;

    pairs[50] = 5; 会修改pairs中关键字为50的元素,使其值变成5。
    若不存在关键字等于50的元素,则插入此元素,并使其值变为5。

    展开全文
  • 文章目录multimap的基本性质 multimap的基本性质

    multimap的基本性质

    multimap容器是和map容器相似的关联式容器,所谓“相似”,是指multimap容器具有和map容器相同的特性,即multimap容器也存储pair<const K, T>类型的键值对(其中K表示键的类型,T表示值的类型),其中各个键值对的键的值不能被修改;并且,该容器也会自行根据键的大小对所存储的所有键值对做排序操作。
    multimap容器和map容器的区别在于,multimap容器中可以同时存储多个键相同的键值对。
    multimap容器提供的成员方法,map容器都有提供,并且它们的用法是相同的。详细的用法请参照map的用法及实例详解。本文只是给出了所有在multimap中的成员函数及其实现功能,具体的实例及代码请参照map容器。


    STL——multimap容器的用法

    实现multimap容器的类模板也定义在<map>头文件,并位于std命名空间中,故使用multimap容器前,应该引入头文件:

    #include<map>
    using namespace std;
    

    第二行代码不是必须的,但若不用,则程序中在使用multimap容器时需要手动注明std命名空间。
    multimap容器的类模板定义如下:

    template < class Key,                                   // 指定键(key)的类型
               class T,                                     // 指定值(value)的类型
               class Compare = less<Key>,                   // 指定排序规则
               class Alloc = allocator<pair<const Key,T> >  // 指定分配器对象的类型
               > class multimap;
    

    和map容器一样,其中后2个参数都设有默认值,大多数时候只需设置前2个参数的值,有时候会用到第3个参数,最后一个参数几乎不会用到。


    multimap容器的创建与初始化

    multimap类模板内部提供多个构造函数,创建multimap容器的方式可以总结为以下5种。

    1)默认构造函数,创建一个空的multimap容器。

    std::multimap <std::K, std::T> multimapname;
    

    其中K和T分别为multimap容器中键值对的键和值的类型。另外,如果程序种已经默认指定了std命名空间,则这里可以省略std::,以下同理,不再赘述。

    #include<iostream>
    #include<map>
    #include<string>
    using namespace std;
    
    int main(){
        multimap<string, int> mymultimap;
        cout<<mymultimap.size()<<endl; //0
        return 0;
    }
    

    2)在创建multimap容器的同时,也可以进行初始化。

    multimap<string, int> mymultimap{{"penny",1},{"leonard",2},{"sheldon",3}};
    

    使用这个方式初始化multimap容器时,其底层会先将每一个{key, value}创建成pair类型的键值对,然后再用已建好的各个键值对初始化multimap容器。有关于pair的用法,可以参照C++ pair的基本用法
    事实上,也可以先手动创建好键值对,然后再用其初始化multimap容器。例如下面这两种方式是等价的:

    //借助pair类模板的构造函数生成各个pair类型的键值对
    multimap<string,int> mymultimap{
        pair<string,int>{"penny",1},
        pair<string,int>{"leonard",2},
        pair<string,int>{"sheldon",3}
    };
    //调用make_pair()函数,生成键值对元素;然后创建并初始化multimap容器
    multimap<string,int> mymultimap{
        make_pair("penny", 1),
        make_pair("leonard",2),
        make_pair("sheldon",3)
    };
    

    3)拷贝(复制)构造函数,也可以初始化新的multimap容器。

    multimap<string,int> newmultimap(mymultimap);
    

    用上面的代码就可以创建一个和mymultimap完全一样的newmultimap容器。
    在C++ 11标准中,还为multimap类增添了移动构造函数。即当有临时的multimap容器作为参数初始化新的multimap容器时,其底层就会调用移动构造函数来实现初始化操作。

    //创建一个会返回临时multimap对象的函数
    multimap<string,int> tmpmultimap(){
        multimap<string,int> tempmultimap{{"penny",1},{"leonard",2}};
        return tempmultimap;
    }
    
    //在main函数中调用multimap类模板的移动构造函数创建newmultimap容器
    multimap<string,int> newmultimap(tmpmultimap());
    

    tempmultimap容器是一个临时对象,因此初始化newmultimap容器时,底层调用的是multimap容器的移动构造函数,而不再是拷贝构造函数。


    4)multimap类模板还支持从已有的multimap容器中,选取某块区域内的所有键值对,用作初始化新multimap容器时使用。

    #include<iostream>
    #include<map>
    #include<string>
    using namespace std;
    
    int main(){
        //创建并初始化multimap容器
        multimap<string,int> mymultimap{
            {"penny",1},{"leonard",2},{"sheldon",3},{"howard",4}};
        multimap<string,int> newmultimap(++mymultimap.begin(),mymultimap.end());      
        for(auto iter = newmultimap.begin(); iter != newmultimap.end(); iter++){
            cout<<iter->first<<" "<<iter->second<<endl;
        }
        return 0;
    }
    

    执行结果:
    在这里插入图片描述


    5)前面提到,multimap类模板总共可以接收4个参数,其中第3个参数可以用来修改multimap容器内部的排序规则。默认情况下,此参数的值为std::less<T>,即升序排列,这意味着下面两种创建multimap容器的方式是等价的:

    multimap<string,int> mymultimap{{"penny",1},{"leonard",2}}; 
    multimap<string,int,less<string>> mymultimap{{"penny",1},{"leonard",2}};
    

    容器中键值对的存储顺序均为<“leonard”,2> , <“penny”, 1>。
    若想要multimap容器中的键值对降序排列,可以使用模板库中提供的std::greater<T>排序函数:

    multimap<string,int,greater<string>> mymultimap{{"penny",1},{"leonard",2}};
    

    此时,multimap容器中键值对的存储顺序为<“penny”,1> , <“leonard”,2>。


    multimap容器包含的成员方法

    multimap容器大小

    成员方法功能
    empty()若容器为空,则返回true,否则返回false。
    size()返回当前multimap容器中键值对的个数。
    max_size()返回multimap容器所能容纳的键值对的最大个数,不同的操作系统,其返回值亦不同。
    count(key)在当前multimap容器中,查找键为key的键值对的个数并返回。

    multimap容器中键值对的访问与遍历

    成员方法功能
    begin()返回指向容器中第一个(已排好序的第一个)键值对的双向迭代器。
    end()返回指向容器中最后一个元素(已排好序的最后一个)所在位置的后一个位置的双向迭代器。
    rbegin()返回指向容器中最后一个(已排好序的最后一个)元素的反向双向迭代器。
    rend()返回指向容器中第一个(已排好序的第一个)元素所在位置的前一个位置的反向双向迭代器。
    cbegin()和begin()功能相同,只不过在其基础上,增加了const属性,不能用于修改容器内储存的键值对。
    cend()和end()功能相同,只不过在其基础上,增加了const属性,不能用于修改容器内储存的键值对。
    crbegin()和rbegin()功能相同,只不过在其基础上,增加了const属性,不能用于修改容器内储存的键值对。
    crend()和rend()功能相同,只不过在其基础上,增加了const属性,不能用于修改容器内储存的键值对。
    find(key)在map容器中查找键为key的键值对,若成功找到,则返回指向该键值对的双向迭代器;若未找到,则返回和end()方法一样的迭代器。
    lower_bound(key)返回一个指向当前map容器中第一个大于或等于key的键值对的双向迭代器。
    upper_bound(key)返回一个指向当前map容器中第一个大于key的键值对的双向迭代器。
    equal_range(key)返回一个pair对象(包含2个双向迭代器),其中pair.first和lower_bound()方法的返回值等价,pair.second和upper_bound()方法的返回值等价。也就是说,该方法将返回一个范围,该范围中包含的键为key的键值对(map容器键值对唯一,因此该返回最多包含一个键值对)。

    multimap插入数据

    成员方法功能
    insert()向multimap容器中插入键值对。
    emplace()在当前multimap容器中的指定位置处构造新键值对。其效果和插入键值对一样,但效率更高。
    emplace_hint()在本质上和emplace()在multimap容器中构造新键值对的方式是一样的,不同之处在于,必须为该方法提供一个指示键值对生成位置的迭代器,并作为该方法的第一个参数。

    multimap删除数据

    成员方法功能
    erase()删除multimap容器指定位置、指定键(key)值或者指定区域内的键值对。
    clear()清空multimap容器中的所有键值对。

    multimap交换数据

    成员方法功能
    swap()交换2个multimap容器中存储的键值对,操作的2个键值对的类型必须相同。

    说明

    和map容器相比,multimap未提供at()成员方法,也没有重载[ ] 运算符。
    这意味着,map容器中通过指定键获取指定键值对的方式,将不再适用于multimap容器。
    其实这也很好理解,因为multimap容器中指定的键可能对应多个键值对,而不再是一个。
    另外,由于maltimap容器可存储多个具有相同键的键值对,因此lower_bound()、upper_bound()、equal_range()以及count()方法经常会用到。


    再次说明,multimap容器提供的成员方法,map容器都有提供,并且它们的用法是相同的。详细的用法请参照map的用法及实例详解

    展开全文
  • 2.multimap 3.unordered_map 4.unordered_multimap map map特点 1.map支持下标访问符,即在[]中放入key,就可以找到与key对应的value 2.map通常被实现为二叉搜索树(更准确的说:平衡二叉搜索树(红黑树) 3.键...
     
    
    

    2.multimap

    3.unordered_map

    4.unordered_multimap

    map

    map特点

    1.map支持下标访问符,即在[]中放入key,就可以找到与key对应的value

    2.map通常被实现为二叉搜索树(更准确的说:平衡二叉搜索树(红黑树)

    3.键的值相同的元素不能重复

    map<string, size_t> people4{ {"Ann", 25}, {"Bill", 36}, {"Bill", 46}, {"Bill", 56},{"Jack", 32},{"Jill", 32} };
    	for (auto e : people4) {
    		cout << e.first << " " << e.second << endl;
    	}
    //out:
    Ann 25
    Bill 36
    Jack 32
    Jill 32
    

    4.键的值无法修改,只能改变值

        map<string, size_t> people{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} };
    
    	map<string, size_t>::iterator e = people.begin();
    	e->second = 18;  //true
    	e->first = "Niuniu";  //error
    

    5.map会根据键排序,可以通过迭代器得到按键排序的结果(因为map底层的实现是红黑树)

        map<size_t, string> people{ {88, "Fuu"}, { 26, "Ann"}, {46, "Bill"},{ 32,"Jack"} };
    	map<size_t, string>::const_iterator it = people.cbegin();
    	while (it != people.cend()) {
    		cout << it->first << " " << it->second << endl;
    		it++;
    	}
    	cout << endl;
    	/*out:
        	26 Ann
            32 Jack
            46 Bill
            88 Fuu
    	*/
    

    6.通过不存在的键访元素将会插入所访问的不存在的键值对,并且值给默认值

    map<size_t, string> people{ {88, "Fuu"}, { 26, "Ann"}, {46, "Bill"},{ 32,"Jack"} };
    	cout << people[64] << endl;  //不做边界检查,会插入pair(64,"\0")-->    通过不存在的键访元素将会插入所访问的不存在的键值对,并且值给默认值
    	for (auto e : people)
    		cout << e.first << " " << e.second << endl;
    	cout << endl;
    	
    	/*out:
        	26 Ann
            32 Jack
            46 Bill
            64
            88 Fuu
        */
    

    通过at()接口可以对边界做检查,不会导致插入不存在的元素, 访问键不存在的元素编译器会报错

    map<size_t, string> people{ {88, "Fuu"}, { 26, "Ann"}, {46, "Bill"},{ 32,"Jack"} };
    	cout << people。at(64) << endl;  //对边界做检查
    	for (auto e : people)
    		cout << e.first << " " << e.second << endl;
    	cout << endl;
    	
    	/*out:
        	26 Ann
            32 Jack
            46 Bill
            88 Fuu
        */
    
    map用法

    map定义及初始化

    1.定义一个空map

    map<string, size_t> people1;
    

    2.用初始化列表来指定 map 的初始值

    map<string, size_t> people2{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} }; 
    

    3.utility 头文件中定义了make_pair<T1,T2>()函数模板,它提供了一种组合 T1和T2类型对象的简单方法。因此,可以按如下方式创建 pair 对象来初始化 map:

    map<string, size_t> people3{ make_pair("Ann",25),make_pair("Bill", 46),make_pair("Jack", 32),make_pair("Jill", 32) };
    

    4.map<K,T> 模板定义了移动和拷贝构造函数,所以可以复制现有的容器

    map<string, size_t> personnel1{ people2 };  //Duplicate people2 map
    

    5.可以用另一个容器的一段元素来创建一个map,用开始和结束迭代器以通常的方式指定元素。显然,迭代器指向的pair元素的类型必须和容器兼容。

    map<string, size_t> personnel2{ begin(people1),end(people1) };  
    //people1.end();  等价于  end(people1)
    

    6.当然,也可以用另一个容器的元素子集来创建容器:左闭右开[iterator1 , iterator2 )

        map<string, size_t>::iterator it1 = people2.begin();
    	map<string, size_t>::iterator it2 = people2.find("Jack");
    
    	map<string, size_t> personnel3{it1 , it2 };
    	map<string, size_t>::iterator e = personnel3.begin();
    

    插入

        map<string, size_t> people{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} };
        
        //首先定义一个pair
    	pair<string, size_t> p("yang", 20);
    	//然后插入,只能成功插入键值不同的元素(特性:map相同键值的元素不重复)
    	people.insert(p);
    	
    	
    	//或者
    	people.insert(pair<string, size_t>("yang", 20));
    	
    	
    
    	for (auto e : people) 
    		cout << e.first << " " << e.second << endl;    
    

    删除

    1.直接通过键值删除元素

        people.erase("yang");
    

    2.通过迭代器删除迭代器所迭代的元素

        map<string, size_t>::iterator it = people.find("yang");
    	people.erase(it);
    

    3.删除两个迭代器区间上的元素

        map<string, size_t>::iterator it1 = people.find("Bill");
    	map<string, size_t>::iterator it2 = people.find("Jill");
    	people.erase(it1, it2);
    

    修改:通过[key]直接修改, 如果修改的键值对不存在则会插入

    map<string, size_t> people{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} }; 
    people[Ann] = 16;  //修改
    people[yzy] = 20;  //插入
    

    求容量及判空

        map<string, size_t> people{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} };
        
        //容量
    	cout << people.size() << endl;  //4
    	//判空
    	cout << people.empty() << endl;  //0
    

    清空

        map<string, size_t> people{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} };
        people.clear();
    	cout << people.size() << endl;  //0
    

    交换

        map<string, size_t> people1{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} };
    	map<string, size_t> people2{ {"Fuu", 26}, {"Sansan", 32} };
    	people1.swap(people2);
    

    遍历

    1.利用C++ auto

    (1).不加const

        map<string, size_t> people{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} };
    
        for (auto e : people) {
    		e.second = 16;
    		cout << e.first <<" "<< e.second << endl;
    	}
    	cout << endl;
    	/*out:
    	    Ann 16
            Bill 16
            Jack 16
            Jill 16
    	*/
    
    	for (auto e : people) {
    		cout << e.first << " " << e.second << endl;
    	}
    	cout << endl;
    	/*out:
    	    Ann 25
            Bill 46
            Jack 32
            Jill 32
    	*/
    

    实际上只是改变了输出结果

    (1).加const

        map<string, size_t> people{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} };
    
        for (const auto e : people) {
    		cout << e.first << e.second << endl;
    		//e.second = 16;  //error
    	}
    	cout << endl;
    

    auto关键字遍历的话,如果给auto关键字前面加上const,for (const auto e : people) 那么就无法通过e来修改值了

    2.利用迭代器

    (1).正向迭代器
    map<string, size_t>::iterator

        map<string, size_t> people{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} };
    
        map<string, size_t>::iterator e = people.begin();
    	while (e != people.end()) {
    		cout << e->first << " "<< e->second<<endl;
    		e++;
    	}
    	
    

    (2).正向常迭代器, 不能通过迭代器修改值
    map<string, size_t>::const_iterator

        map<string, size_t> people{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} };
    
        map<string, size_t>::const_iterator e = people.cbegin();
    	//e->second = 17;  //error
    	while (e != people.cend()) {
    		cout << e->first << " " << e->second << endl;
    		e++;
    	}
    	
    

    (3).反向迭代器,可以通过迭代器修改值
    map<string, size_t>::reverse_iterator

        map<string, size_t> people{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} };
    
        map<string, size_t>::reverse_iterator e = people.rbegin();  //可以通过迭代器修改值
    	e->second = 16;
    	while (e != people.rend()) {
    		cout << e->first << " " << e->second << endl;
    		e++;
    	}
    

    (4).反向常迭代器,不可以通过迭代器修改值
    map<string, size_t>::const_reverse_iterator

        map<string, size_t> people{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} };
    
        map<string, size_t>::const_reverse_iterator e = people.crbegin();
    	//e->second = 16;  //error
    	while (e != people.crend()) {
    		cout << e->first << " " << e->second << endl;
    		e++;
    	}
    

    3.利用重载的运算符[]访问([]中是键, 返回值是值)

        map<string, size_t> people{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} };
    
    	size_t age = people["Ann"];
    	cout << age <<endl;
    	cout << people["Bill"] << endl; 
    

    auto关键字遍历的话,是用点访问键和值,迭代器的话是用箭头访问键和值

    查找 时间复杂度为:

    log_2 n
    

    只能通过键值来查找,返回类型是迭代器

        map<string, size_t> people{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} };
        map<string, size_t>::iterator it3 = people.find("Ann");//找到就会返回迭代
        
        //error:不能通过键值对的值来查找
    	map<string, size_t>::iterator it3 = people.find(25); 
    	
    	//找不到迭代器就会走到end()
    	map<string, size_t>::iterator it4 = people.find("Fuu");
    	if (it4 == end(people))
    		cout << "not found" << endl;
    

    multimap

    #include

    multimap特点(与map的区别是)

    1.multimap在底层用二叉搜索树(红黑树)来实现。在内部,multimap中的元素总是通过其内部比较对象,按照指定的特定严格弱排序标准对key进行排序 的。

    2.multiset容器通过key访问单个元素的速度通常比比unordered_multiset容器慢

    3.键的值相同的元素可以重复

         pair<string, string> value[] = {
    		{"111", "abc"},
    		{"555","xyz"},
    		{"222", "opq"},
    		{"222", "opq"},
    		{"222", "opq"}
    	};
    	multimap<string, string> multiMap;
    	for (int i = 0; i < (sizeof(value) / sizeof(pair<string, string>)); i++) 
    		multiMap.insert(value[i]);
    
    	multimap<string, string>::iterator it = multiMap.begin();
    	while (it != multiMap.end()) {
    		cout << it->first << " ";
    		cout<< it++->second << endl;
    	}  
    	
    	/*out:
    	    111 abc
            222 opq
            222 opq
            222 opq
            555 xyz
    	*/
    

    4.不可以以[key]的方式访问键值对的值

    multimap用法与map相似

    multimap定义及初始化(与map的定义及初始化方式一样)

    容量及判空 清空 交换 遍历 都相似

    插入:可以插入键的值相同的元素

    删除:会删除键的值相同的所有元素

    修改:不允许

        multimap<string, size_t> people{ {"Ann", 25},{"Ann", 18}, {"Bill", 46},{"Jack", 32},{"Jill", 32} };
    	people["Bill"] = 100;  //error
    

    查找:返回键值相同的元素中迭代顺序第一个的元素,找不到迭代器走到end()

    	pair<string, string> value[] = {
    		{"111", "abc"},
    		{"555","xyz"},
    		{"222", "opq"},
    		{"222", "exo"},
    		{"222", "nha"}
    	};
    	multimap<string, string> multiMap;
    	for (int i = 0; i < (sizeof(value) / sizeof(pair<string, string>)); i++) 
    		multiMap.insert(value[i]);
    		
    	multimap<string, string>::iterator find = multiMap.find("222");
    	cout << find->first <<" "<< find->second <<endl;
    	/*out:
        	222 opq
    	*/
    	
    	multimap<string, string>::iterator find2 = multiMap.find("999");
    	if (find2 == multiMap.end())
    		cout << "Not found" << "iterator has pointed the end" << endl;
    	/*out:
        	Not founditerator has pointed the end
    	*/
    

    unordered_map

    #include <unordered_map>

    unordered_map特点(与map的区别是)

    1.在内部,unordered_map没有对<kye,value>按照任何特定的顺序排序,为了能在常数范围内找到key所对应的value,unordered_map将相同哈希值的键值对放在相同的桶中。

    2.unordered_map容器通过key访问单个元素要比map快,但它通常在遍历元素子集的范围迭代方面效率较低。

    3.unordered_maps实现了直接访问操作符(operator[]),它允许使用key作为参数直接访问value。若使用key作为参数直接访问value时,当不存在key对应的键值对时,就会插入值为默认值的键值对。

    4.相较于map,unordered_map具有桶操作(map平衡化的红黑树, unordered_map哈希结构)

    unordered_map用法

    unordered_map定义及初始化(与map的定义及初始化方式一样)

    1.定义一个空unordered_map

    unordered_map<string, size_t> people1;
    

    2.用初始化列表来指定 unordered_map 的初始值

    unordered_map<string, size_t> people2{ {"Ann", 25}, {"Bill", 46},{"Jack", 32},{"Jill", 32} }; 
    

    3.utility 头文件中定义了make_pair<T1,T2>()函数模板,它提供了一种组合 T1和T2类型对象的简单方法。因此,可以按如下方式创建 pair 对象来初始化 map:

    unordered_map<string, size_t> people3{ make_pair("Ann",25),make_pair("Bill", 46),make_pair("Jack", 32),make_pair("Jill", 32) };
    

    4.map<K,T> 模板定义了移动和拷贝构造函数,所以可以复制现有的容器

    unordered_map<string, size_t> personnel1{ people2 };  //Duplicate people2 map
    

    5.可以用另一个容器的一段元素来创建一个unordered_map,用开始和结束迭代器以通常的方式指定元素。显然,迭代器指向的pair元素的类型必须和容器兼容。

    unordered_map<string, size_t> personnel2{ begin(people1),end(people1) };  
    //people1.end();  等价于  end(people1)
    

    6.当然,也可以用另一个容器的元素子集来创建容器:左闭右开[iterator1 , iterator2 )

        unordered_map<string, size_t>::iterator it1 = people2.begin();
    	unordered_map<string, size_t>::iterator it2 = people2.find("Jack");
    
    	unordered_map<string, size_t> personnel3{it1 , it2 };
    	unordered_map<string, size_t>::iterator e = personnel3.begin();
    

    插入 删除 容量及判空 清空 交换 查找都相似

    遍历:只有正向的迭代器和正向的常迭代器

    (1).正向的迭代器

        unordered_map<string, int> unorderedMap = { {"Ann", 25},{"Fuu", 18}, {"Bill", 46} };
    
    	unordered_map<string, int>::iterator it = unorderedMap.begin();
    	while (it != unorderedMap.end()) {
    		cout << it->first << " ";
    		cout<< it++->second << endl;
    	}
    	cout << endl;
    

    (2).正向的常迭代器

        unordered_map<string, int> unorderedMap = { {"Ann", 25},{"Fuu", 18}, {"Bill", 46} };
    	unordered_map<string, int>::const_iterator cit = unorderedMap.cbegin();
    	while (cit != unorderedMap.cend()) {
    		cout << cit->first << " ";
    		cout<< cit++->second << endl;
    	}
    

    修改:

        unordered_map<string, int> unorderedMap = { {"Ann", 25},{"Fuu", 18}, {"Bill", 46} };
    	unorderedMap["Ann"] = 24;
    

    unordered_map的桶操作:

    1.求桶的总个数

        unordered_map<string, string> unorderedMap;
    	pair<string, string> val[] = {
    		{"111", "aaa"},
    		{"222", "bbb"},
    		{"222", "ddd"},
    		{"222", "uuu"},
    		{"333", "ccc"},
    		{"333", "fff"}
    	};
    	for (int i = 0; i < (sizeof(val) / sizeof(pair<string, string>)); i++) 
    		unorderedMap.insert(val[i]);
    		
    //求桶的总个数
        cout<<"bucket cout: "<<unorderedMap.bucket_count()<<endl;
    

    2.根据key值求元素在几号桶中

        cout << "find the  element in which bucket that key is ""333"" " << unorderedMap.bucket("333") <<endl;
    

    3.求几号桶的size(元素个数)

        cout<<"one of the buckets size: "<<unorderedMap.bucket_size(0)<<endl;
        
        
         //访问所有桶的size
        for (int i = 0; i < unorderedMap.bucket_count(); i++) 
    		cout << "buck["<< i<< "]" << "  size = " << unorderedMap.bucket_size(i) <<endl;
    

    sizeof(pair<T1, T2>)大小

    pair < {short, size_t, int, long}, { short, size_t, int, long } > //都是8
    	pair < {string}, { short, size_t, int, long } >  //都是:32   string类不影响另一个(小于等于4的)类型字节对齐
       	//string 是28, long long 是8
       	sizeof(pair<string, string>) 是56
       	
    	特殊: pair < string, long long >  //是: 40
    	pair < {short, size_t, int, long}, long long >  //都是16  longlong会使short, size_t, int, long 都是8
    

    unordered_multimap

    #include <>

    unordered_multimap特点(与multimap的区别是)

    1.值可以重复,会将哈希值的键值对放在相同的桶中。unordered系列容器底层都使用了哈希结构,元素访问效率高

    2.multimap都没有[key]访问元素的功能,也就是没有重载[]

    unordered_multimap用法

    定义及初始化(与multimap的定义及初始化方式一样)

    插入(因为没用重载[],因此不能通过不存在的键值访问,从而插入元素)

    删除 (会删除值相同的所有元素)

    容量及判空 清空 交换 查找都相似

    遍历:只有正向的迭代器和正向的常迭代器

    (1).正向的迭代器

        unordered_multimap<string, string> unorderedMultiMap;
    	pair<string, string> val[] = {
    		{ "111", "aaa" },
    		{ "222", "bbb" },
    		{ "333", "ccc" },
    		{ "444", "ddd"}	
    	};
    	for (int i = 0; i < (sizeof(val) / sizeof(pair<string, string>)); i++) 
    		unorderedMultiMap.insert(val[i]);
    
        unordered_multimap<string, string>::iterator it = unorderedMultiMap.begin();
    	//it->first = "888";  //error
    	it->second = "uuu";
    	while (it != unorderedMultiMap.end()) {
    		cout << it->first << " ";
    		cout << it++->second << endl;
    	}
    	cout << endl;
    

    (2).正向的常迭代器

        unordered_multimap<string, string>::const_iterator cit = unorderedMultiMap.cbegin();
    	//cit->first = "999";  //error
    	//cit->second = "uuu";  //error
    	while (cit != unorderedMultiMap.cend()) {
    		cout << cit->first << " ";
    		cout<< cit++->second << endl;
    	}
    	cout << endl;
    

    修改:(由于没有对[]重载,因此只能通过迭代器来修改)
    并且修改的值是哈希桶中第一个元素的值,并没有修改匹配的所有值。

        unordered_multimap<string, string>::iterator find = unorderedMultiMap.find("222");
    	find->second = "kkk";
    

    unordered_map的桶操作:

    1.求桶的总个数

        unordered_multimap<string, string> unorderedMap;
    	pair<string, string> val[] = {
    		{"111", "aaa"},
    		{"222", "bbb"},
    		{"222", "ddd"},
    		{"222", "uuu"},
    		{"333", "ccc"},
    		{"333", "fff"}    	};
    	for (int i = 0; i < (sizeof(val) / sizeof(pair<string, string>)); i++) 
    		unorderedMultiMap.insert(val[i]);
    		
    //求桶的总个数
        cout<<"bucket cout: "<<unorderedMultiMap.bucket_count()<<endl;
    

    2.根据key值求元素在几号桶中

        cout << "find the  element in which bucket that key is ""333"" " << unorderedMultiMap.bucket("333") << endl;
    

    3.求几号桶的size(元素个数)

        cout << "one of the buckets[0] size: " << unorderedMultiMap.bucket_size(0) << endl;
        
        
        //访问所有桶的size
        for (int i = 0; i < unorderedMultiMap.bucket_count(); i++)
    		cout << "bucket[" << i << "]" << "  size = " << unorderedMultiMap.bucket_size(i) << endl;
    
    展开全文
  • Multimap

    2019-01-25 19:27:00
    Multimap对于树状数据结构很管用。比如一个dept下有个deptList。 基本用法: public static void main(String[] args) { Multimap ,String> map = ArrayListMultimap.create(); map.put( 1,"tom" ); ...

    引入依赖

     <dependency>
          <groupId>com.fasterxml.jackson.datatype</groupId>
          <artifactId>jackson-datatype-guava</artifactId>
          <version>2.5.3</version>
        </dependency>

    Multimap对于树状数据结构很管用。比如一个dept下有个deptList。

    基本用法:

    public static void main(String[] args) {
            Multimap<Integer,String> map = ArrayListMultimap.create();
            map.put(1,"tom");
            map.put(2,"jack");
            map.put(1,"hellen");
            map.put(2,"Rose");
            System.out.println(map.get(1));
    
        }

    输出结果:

    [tom, hellen]

    转载于:https://www.cnblogs.com/yintingting/p/10321300.html

    展开全文
  • C++ multimap

    2020-03-17 19:30:20
    multimap 是关联容器的一种,multimap 的每个元素都分为关键字和值两部分,容器中的元素是按关键字排序的,并且允许有多个元素的关键字相同。 注意:不能直接修改 multimap 容器中的关键字。因为 multimap 中的元素...
  • 多映射示例:multimap 实现的简单好友列表。
  • stl multimapIn this tutorial we will learn about stl unordered multimap container in C++. 在本教程中,我们将学习C ++中的stl无序多图容器。 Unordered multimap is an associative container. Same as ...
  • 哈希多图 Java的HashMultimap集合在JavaScript上的实现
  • Multimap的使用

    千次阅读 2018-09-07 16:31:11
    multimap 类   标准模板库多重映射类用于存储和检索集合中的数据,此集合中的每个元素均为包含数据值和排序键的元素对。 键值不需要唯一,用于自动排序数据。 可以直接更改多重映射中的元素值,但不能直接更改...
  • 本篇学习unordered_multimap的查找操作和观察器操作,具体函数如下: count(C++11)返回匹配特定键的元素数量 find(C++11)寻找带有特定键的元素 equal_range(C++11)返回匹配特定键的元素范围 hash_function(C++11)...
  • C++multimap的使用

    2021-02-20 21:04:14
    问题描述 ...然后对每组multimap中的元素遍历,最终的键是不能重复的,所有每处理一组的key,都要放在set中,然后每组value也是不能重复的,去过不进行处理,会出现重复读,即h1*w1/w2/w2/w1,多以还需
  • 文章目录使用场景及概述1 映射容器1.1 `map`1.2 `multimap`1.3 `unordered_map`参考文献 使用场景及概述 当你想通过非遍历或非穷举的方式,快速判断一个元素是否出现集合里,Hash Table是非常合适的数据结构 这里先...
  • map/multimap的简介 map是标准的关联式容器,一个map里存储的元素是一个键值对序列,叫做(key,value)键值对。它提供基于key快速检索数据的能力。 map中key值是唯一的。集合中的元素按一定的顺序排列。元素插入...
  • 一、multimap的相关原理 multimap与map一样,都是使用红黑树对记录型的元素数据按元素键值的比较关系,进行快速的插入、删除和检索操作,所不同的是multimap允许将具有重复键值的元素插入容器。在multimap容器中,...
  • 本篇学习multimap删除相关的操作,具体的函数如下: clear清除内容 erase擦除元素 swap交换内容 extract(C++17)从另一容器释出结点 merge(C++17)从另一容器接合结点
  • 本篇学习multimap插入数据相关的操作,具体的操作函数如下 insert插入元素或结点 (C++17 起) emplace(C++11)原位构造元素 emplace_hint(C++11)使用提示原位构造元素
  • multimap 是关联容器,含有键值对的已排序列表,其功能与map一样,唯一不同的是,它容许多个元素拥有同一键。本篇学习map的创建,初始化,赋值操作operator=, empty,size,max_size
  • C++ map容器和multimap容器(STL map容器)

    万次阅读 多人点赞 2018-11-08 22:30:05
    目录 1. 关联容器和map容器概述 2. map容器 2.1 map的创建以及初始化列表 ...3. multimap容器 3.1 访问元素 3.2 删除元素 1. 关联容器和map容器概述 map容器是关联容器的一种。在关联容器中,对象的位...
  • c++ map、multimap 的使用方法

    千次阅读 2019-04-26 13:52:43
    一、区别 1. Map:一对一;有序( 自动按 key 升序 );可用 [ ] 赋值和取值;采用 红黑树 结构;实现O(lgn)的查找,插入和删除 2. Mulitimap:多对多;... multimap<char, int, less<char> > -...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,301
精华内容 10,520
关键字:

multimap