键值对集合

<参看 c++primer p407,ch11>

1. 概述

1. 顺序容器包括vector、deque、list、forward_list、array、string，顺序容器都提供了快速(顺序)访问元素的能力, vector封装数组，list封装了链表
2. 关联容器包括set、map, set存储的是key类型的元素, map存储的元素是{key,val}组成的pair类型,
   • 创建一个pair可以 pair<T1,T2> p; 或者pair<T1,T2> p(v1,v2); 或 pair<T1,T2> p={v1,v2}; 或 make_pair(v1,v2)
   • 访问一个pair则 p.first 和 p.second
3. set包含以下几种:
   • set<T> 容器保存 T 类型的对象，保存的对象不重复。元素有序，默认用 less 对象比较。可以用相等、不相等来判断对象是否相同。(内部采用红黑树实现) 需要 #include <set>
   • multiSet<T> 与set<T>区别在他可以保存重复的对象。#include <multiset>
   • unorderd_set<T> 容器保存 T 类型的对象，保存的对象不重复。元素在容器中的位置由元素的哈希值决定。默认用 equal_to 判断元素是否相等。(内部采用hash表实现),需要 include <unorderd_set>
   • unordered_multiset<T> 与unorderd_set<T>区别在它可以保存重复的对象。include <unordered_multiset>
4. map包含以下几种
   • map<Tkey,Tval> 键值对集合(红黑树实现), 支持[ ]操作(set不支持因为没有获取val的意义)
   • multimap<Tkey,Tval> key可以重复的键值对集合(红黑树实现),(不支持[ ] 操作因为可能返回多个val)
   • unordered_map<Tkey,Tval> 键值对集合(hash表 实现),支持[ ]操作
   • unordered_multimap<Tkey,Tval> key可以重复的键值对集合(hash表 实现)
5. set的迭代器是const的

map和set的插入删除效率比用其他序列容器高？ 因为内部采用红黑树/哈希表, 不涉及内存的拷贝和移动等操作

为何每次insert之后，以前保存的iterator不会失效？ iterator 相当于指向节点的指针，内存没有变，指向内存的指针不会失效(当然被删除的那个元素本身已经失效了)。相对于vector，每一次删除和插入，指针都有可能失效。因为为了保证内部数据的连续存放，vector管理的那块内存可能被扩容(伴随着释放和重新分配)。特别在和find等算法在一起使用时,牢记不要使用过期的iterator。

2. 一些接口

成员函数	含义
begin()	返回容器的第一个元素,map是pair类型,set则就是key的类型
end()	返回容器的最后一个元素
clear()	删除容器中的所有的元素
empty()	判断容器是否为空
max_size()	返回容器可能包含的元素最大个数
size()	返回当前容器中的元素个数
rbegin()	返回的值和end()相同
rend()	返回的值和rbegin()相同
———————	—————————————————————————————————-
erase(iterator)	删除iterator指向的元素
erase(first,second)	删除iterator first和second之间的元素
erase(k)	删除键值key=k的元素
find(k)	返回key=k对应的iterator，如果没找到则返回end()
insert(k)	将k插入到键值对集合中，返回值是pair<iterator,bool>，bool标志着插入是否成功，插入成功iterator代表插入的元素，若key=k的元素已经存在，则iterator表示已经存在的那个元素
insert(first,second)	将iteratot first到second之间的元素插入到set中，返回值是void.
———————	—————————————————————————————————-
lower_bound(key_value)	返回第一个大于等于key_value的iterator
upper_bound(key_value)	返回最后一个大于key_value的iterator
equal_range()	返回一对iterator，表示关键字等于
count()	用来查找set中某个某个键值出现的次数(对于key可重复的map/set常用)

此外 unsorted_map unsorted_set还提供了一些和bucket桶相关的api

3. demo1

统计word

map<string, size_t> word_cnt;
set<string> exclude = {"and","And","or","Or","the","The"};    //在集合中的string不进行统计,默认 set<string, less<string>>

//统计
string word;
while(cin>>word)
{
    if(exclude.find(word) == exclude.end())    //word 不在集合中
    {
        ++word_cnt[word];    //调用map的 operator[]/at() 成员函数执行下标操作, 会: 读取map中元素,并进行++操作,写入时若没有key=word的元素则插入
    }
}
//遍历打印
for(const auto &w : word_cnt)    //使用迭代器遍历map, w实际就是一个pair类型
    cout<<"key="<<w.first<<",val="<<w.second<<endl;

与上面等价的版本:

map<string, size_t> word_cnt;
set<string> exclude = {"and","And","or","Or","the","The"};    //在集合中的string不进行统计

//统计
string word;
while(cin>>word)
{
    if(exclude.find(word) == exclude.end())    //若 word 不在集合中
    {
        //if(word_cnt.find(word) == word_cnt.end())
        //{
        //    cout<<word<<" is not in the map. "<<endl;
        //}

        //{word,1}构造一个pair, ret 是 pair<map<string,size_t>::iterator, bool> 类型
        //若pair.second为false,代表key为word的元素已经存在, pair.first 就是那个已经存在的元素(一个pair)
        //若pair.second为true,代表key为word的元素原来不存在(现在已经插入了)
        auto ret = word_cnt.insert({word,1});
        if(!ret.second)
            ++ret.first->second;    //将已经存在的pair的val值++
    }
}
//遍历打印
auto map_it = word_cnt.cbegin();    //cbegin()中的c是const的意思
while(map_it != word_cnt.cend())
{
    cout<<"key="<<map_it->first<<",val="<<map_it->second<<endl;
    map_it++;
}

#include <iostream>
#include <set>

using namespace std;

int main()
{
    int a[] = {1,2,3};
    set<int> s(a,a+3);
    set<int>::iterator iter;
    if((iter = s.find(2)) != s.end())
    {
        cout<<*iter<<endl;//输出为2
    }
    return 0;
}

4. demo2-map使用

参考

4.1. 声明

//头文件
#include<map>
map<int, string> ID_Name;
// 使用{}赋值是从c++11开始的，因此编译器版本过低时会报错，如visual studio 2012
map<int, string> ID_Name = { { 2015, "Jim" }, { 2016, "Tom" }, { 2017, "Bob" } };

4.2. 插入

使用[ ]进行单个插入

map<int, string> ID_Name;

// 如果已经存在键值2015，则会作赋值修改操作，如果没有则插入
ID_Name[2015] = "Tom";

使用insert进行单个和多个插入

// 插入单个键值对，并返回插入位置和成功标志，插入位置已经存在值时，插入失败
pair<iterator,bool> insert (const value_type& val);

//在指定位置插入，在不同位置插入效率是不一样的，因为涉及到重排
iterator insert (const_iterator position, const value_type& val);

// 插入多个
void insert (InputIterator first, InputIterator last);

//c++11开始支持，使用列表插入多个
void insert (initializer_list<value_type> il);

使用实例:

#include <iostream>
#include <map>
int main()
{
    std::map<char, int> mymap;
    // 插入单个值
    mymap.insert(std::pair<char, int>('a', 100));
    mymap.insert(std::pair<char, int>('z', 200));
    //返回插入位置以及是否插入成功
    std::pair<std::map<char, int>::iterator, bool> ret;
    ret = mymap.insert(std::pair<char, int>('z', 500));
    if (ret.second == false)
    {
        std::cout << "element 'z' already existed";
        std::cout << " with a value of " << ret.first->second << '\n';
    }
    //指定位置插入
    std::map<char, int>::iterator it = mymap.begin();
    mymap.insert(it, std::pair<char, int>('b', 300));    //效率更高
    mymap.insert(it, std::pair<char, int>('c', 400));    //效率非最高
    //范围多值插入
    std::map<char, int> anothermap;
    anothermap.insert(mymap.begin(), mymap.find('c'));

    // 列表形式插入
    anothermap.insert({ { 'd', 100 }, {'e', 200} });
    return 0;
}

4.3. 取值

map<int, string> ID_Name;

//ID_Name中没有关键字2016，使用[]取值会导致插入
//因此，下面语句不会报错，但打印结果为空
cout<<ID_Name[2016].c_str()<<endl;

//使用at会进行关键字检查，因此下面语句会报错
ID_Name.at(2016) = "Bob";

4.4. 容量查询

// 查询map是否为空
bool empty();

// 查询map中键值对的数量 
size_t size();

// 查询map所能包含的最大键值对数量，和系统和应用库有关。
// 此外，这并不意味着用户一定可以存这么多，很可能还没达到就已经开辟内存失败了
size_t max_size();

// 查询关键字为key的元素的个数，在map里结果非0即1
size_t count( const Key& key ) const; //

4.5. 迭代器

8个获取迭代器的函数 begin(), end(), rbegin(),rend() 以及对应的 cbegin(), cend(), crbegin(),crend()。二者的区别在于，后者返回 const_iterator，而前者则根据map的类型返回iterator 或者 const_iterator。const情况下，不允许对值进行修改。如下面代码所示：

map<int,int>::iterator it;
map<int,int> mmap;
const map<int,int> const_mmap;

it = mmap.begin(); //iterator
mmap.cbegin(); //const_iterator

const_mmap.begin(); //const_iterator
const_mmap.cbegin(); //const_iterator

返回的迭代器可以进行加减操作，此外，如果map为空，则 begin = end。

4.6. 查找

// 关键字查询，找到则返回指向该关键字的迭代器，否则返回指向end的迭代器 
// 根据map的类型，返回的迭代器为 iterator 或者 const_iterator
iterator find (const key_type& k);
const_iterator find (const key_type& k) const;

实例:

std::map<char,int> mymap;
std::map<char,int>::iterator it;
mymap['a']=50;
mymap['b']=100;
mymap['c']=150;
mymap['d']=200;
it = mymap.find('b');
if (it != mymap.end())
    mymap.erase (it); // b被成功删除

4.7. 删除

// 删除迭代器指向位置的键值对，并返回一个指向下一元素的迭代器
iterator erase( iterator pos )
// 删除一定范围内的元素，并返回一个指向下一元素的迭代器
iterator erase( const_iterator first, const_iterator last );
// 根据Key来进行删除， 返回删除的元素数量，在map里结果非0即1
size_t erase( const key_type& key );
// 清空map，清空后的size为0
void clear();

4.8. 交换

// 就是两个map的内容互换
void swap( map& other );