大同市网站建设_网站建设公司_营销型网站_seo优化

map系列的使⽤

map和multimap参考⽂档

参考文档

map类的介绍

map的声明如下，Key就是map底层关键字的类型，T是map底层value的类型，set默认要求Key⽀持⼩于⽐较，如果不⽀持或者需要的话可以⾃⾏实现仿函数传给第⼆个模版参数，map底层存储数据的内存是从空间配置器申请的。⼀般情况下，我们都不需要传后两个模版参数。map底层是⽤红⿊树实现，增删查改效率是O(logN) ，迭代器遍历是⾛的中序，所以是按key有序顺序遍历的。

template < class Key, // map::key_type class T, // map::mapped_type class Compare = less<Key>, // map::key_compare class Alloc = allocator<pair<const Key,T> > //map::allocator_type > class map;

pair类型介绍

map底层的红⿊树节点中的数据，使⽤pair<Key, T>存储键值对数据。

typedef pair<const Key, T> value_type; template <class T1, class T2> struct pair { typedef T1 first_type; typedef T2 second_type; T1 first; T2 second; pair(): first(T1()), second(T2()) {} pair(const T1& a, const T2& b): first(a), second(b) {} template<class U, class V> pair (const pair<U,V>& pr): first(pr.first), second(pr.second) {} }; template <class T1,class T2> inline pair<T1,T2> make_pair (T1 x, T2 y) { return ( pair<T1,T2>(x,y) ); }

map的构造

map的构造我们关注以下⼏个接⼝即可。
map的⽀持正向和反向迭代遍历，遍历默认按key的升序顺序，因为底层是⼆叉搜索树，迭代器遍历⾛的中序；⽀持迭代器就意味着⽀持范围for，map⽀持修改value数据，不⽀持修改key数据，修改关键字数据，破坏了底层搜索树的结构。

// empty (1) ⽆参默认构造 explicit map (const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type()); // range (2) 迭代器区间构造 template <class InputIterator> map (InputIterator first, InputIterator last, const key_compare& comp = key_compare(), const allocator_type& = allocator_type()); // copy (3) 拷⻉构造 map (const map& x); // initializer list (5) initializer 列表构造 map (initializer_list<value_type> il, const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type()); // 迭代器是⼀个双向迭代器 iterator -> a bidirectional iterator to const value_type // 正向迭代器 iterator begin(); iterator end(); // 反向迭代器 reverse_iterator rbegin(); reverse_iterator rend();

map的增删查

map的增删查关注以下⼏个接⼝即可：
map增接⼝，插⼊的pair键值对数据，跟set所有不同，但是查和删的接⼝只⽤关键字key跟set是完全类似的，不过find返回iterator，不仅仅可以确认key在不在，还找到key映射的value，同时通过迭代还可以修改value

Member types key_type -> The first template parameter (Key) mapped_type -> The second template parameter (T) value_type -> pair<const key_type,mapped_type> // 单个数据插⼊，如果已经key存在则插⼊失败,key存在相等value不相等也会插⼊失败 pair<iterator,bool> insert (const value_type& val); // 列表插⼊，已经在容器中存在的值不会插⼊ void insert (initializer_list<value_type> il); // 迭代器区间插⼊，已经在容器中存在的值不会插⼊ template <class InputIterator> void insert (InputIterator first, InputIterator last); // 查找k，返回k所在的迭代器，没有找到返回end() iterator find (const key_type& k); // 查找k，返回k的个数 size_type count (const key_type& k) const; // 删除⼀个迭代器位置的值 iterator erase (const_iterator position); // 删除k，k存在返回0，存在返回1 size_type erase (const key_type& k); // 删除⼀段迭代器区间的值 iterator erase (const_iterator first, const_iterator last); // 返回⼤于等k位置的迭代器 iterator lower_bound (const key_type& k); // 返回⼤于k位置的迭代器 const_iterator lower_bound (const key_type& k) const;

map的数据修改

map⽀持修改mapped_type数据，不⽀持修改key数据，修改关键字数据，破坏了底层搜
索树的结构。
map第⼀个⽀持修改的⽅式时通过迭代器，迭代器遍历时或者find返回key所在的iterator修改，map还有⼀个⾮常重要的修改接⼝operator[]，但是operator[]不仅仅⽀持修改，还⽀持插⼊数据和查找数据，所以他是⼀个多功能复合接⼝
需要注意从内部实现⻆度，map这⾥把我们传统说的value值，给的是T类型，typedef为mapped_type。⽽value_type是红⿊树结点中存储的pair键值对值。⽇常使⽤我们还是习惯将这⾥的T映射值叫做value。

Member types key_type -> The first template parameter (Key) mapped_type -> The second template parameter (T) value_type -> pair<const key_type,mapped_type> // 查找k，返回k所在的迭代器，没有找到返回end()，如果找到了通过iterator可以修改key对应的mapped_type值 iterator find (const key_type& k); // ⽂档中对insert返回值的说明 // The single element versions (1) return a pair, with its member pair::first set to an iterator pointing to either the newly inserted element or to the element with an equivalent key in the map. The pair::second element in the pair is set to true if a new element was inserted or false if an equivalent key already existed. // insert插⼊⼀个pair<key, T>对象 // 1、如果key已经在map中，插⼊失败，则返回⼀个pair<iterator,bool>对象，返回pair对象first是key所在结点的迭代器，second是false // 2、如果key不在在map中，插⼊成功，则返回⼀个pair<iterator,bool>对象，返回pair对象first是新插⼊key所在结点的迭代器，second是true // 也就是说⽆论插⼊成功还是失败，返回pair<iterator,bool>对象的first都会指向key所在的迭代器 // 那么也就意味着insert插⼊失败时充当了查找的功能，正是因为这⼀点，insert可以⽤来实现operator[] // 需要注意的是这⾥有两个pair，不要混淆了，⼀个是map底层红⿊树节点中存的pair<key, T>，另⼀个是insert返回值pair<iterator,bool> pair<iterator,bool> insert (const value_type& val); mapped_type& operator[] (const key_type& k); // operator的内部实现 mapped_type& operator[] (const key_type& k) { // 1、如果k不在map中，insert会插⼊k和mapped_type默认值，同时[]返回结点中存储mapped_type值的引⽤，那么我们可以通过引⽤修改返映射值。所以[]具备了插⼊+修改功能 // 2、如果k在map中，insert会插⼊失败，但是insert返回pair对象的first是指向key结点的迭代器，返回值同时[]返回结点中存储mapped_type值的引⽤，所以[]具备了查找+修改的功能 pair<iterator, bool> ret = insert({ k, mapped_type() }); iterator it = ret.first; return it->second; }

构造遍历及增删查使⽤样例

#include<iostream> #include<map> using namespace std; int main() { // initializer_list构造及迭代遍历 map<string, string> dict = { {"left", "左边"}, {"right", "右边"},{"insert", "插⼊"},{ "string", "字符串" } }; //map<string, string>::iterator it = dict.begin(); auto it = dict.begin(); while (it != dict.end()) { //cout << (*it).first <<":"<<(*it).second << endl; // map的迭代基本都使⽤operator->,这⾥省略了⼀个-> // 第⼀个->是迭代器运算符重载，返回pair*，第⼆个箭头是结构指针解引⽤取pair数据 //cout << it.operator->()->first << ":" << it.operator->()->second << endl; cout << it->first << ":" << it->second << endl; ++it; } cout << endl; // insert插⼊pair对象的4种⽅式，对⽐之下，最后⼀种最⽅便 pair<string, string> kv1("first", "第⼀个"); dict.insert(kv1); dict.insert(pair<string, string>("second", "第⼆个")); dict.insert(make_pair("sort", "排序")); dict.insert({ "auto", "⾃动的" }); // "left"已经存在，插⼊失败 dict.insert({ "left", "左边，剩余" }); // 范围for遍历 for (const auto& e : dict) { cout << e.first << ":" << e.second << endl; } cout << endl; string str; while (cin >> str) { auto ret = dict.find(str); if (ret != dict.end()) { cout << "->" << ret->second << endl; } else { cout << "⽆此单词，请重新输⼊" << endl; } } // erase等接⼝跟set完全类似，这⾥就不演⽰讲解了 return 0; }

map的迭代器和功能样例

#include<iostream> #include<map> #include<string> using namespace std; int main() { // 利⽤find和iterator修改功能，统计⽔果出现的次数 string arr[] = { "苹果", "西⽠", "苹果", "西⽠", "苹果", "苹果", "西⽠", "苹果", "⾹蕉", "苹果", "⾹蕉" }; map<string, int> countMap; for (const auto& str : arr) { // 先查找⽔果在不在map中 // 1、不在，说明⽔果第⼀次出现，则插⼊{⽔果, 1} // 2、在，则查找到的节点中⽔果对应的次数++ auto ret = countMap.find(str); if (ret == countMap.end()) { countMap.insert({ str, 1 }); } else { ret->second++; } } for (const auto& e : countMap) { cout << e.first << ":" << e.second << endl; } cout << endl; for (auto& e : arr) { pair<map<string, int>::iterator, bool> ret; ret = countMap.insert(make_pair(e, 1)); // 已经存在了 if (ret.second == false) { ret.first->second++; } } return 0; } #include<iostream> #include<map> #include<string> using namespace std; int main() { // 利⽤[]插⼊+修改功能，巧妙实现统计⽔果出现的次数 string arr[] = { "苹果", "西⽠", "苹果", "西⽠", "苹果", "苹果", "西⽠", "苹果", "⾹蕉", "苹果", "⾹蕉" }; map<string, int> countMap; for (const auto& str : arr) { // []先查找⽔果在不在map中 // 1、不在，说明⽔果第⼀次出现，则插⼊{⽔果, 0}，同时返回次数的引⽤，++⼀下就变成1次了 // 2、在，则返回⽔果对应的次数++ countMap[str]++; } for (const auto& e : countMap) { cout << e.first << ":" << e.second << endl; } cout << endl; return 0; }

//V& operator[](const K& key) //{ // pair<iterator, bool> ret = insert(make_pair(key, V())); // return ret.first->second; //}

#include<iostream> #include<map> #include<string> using namespace std; int main() { map<string, string> dict; dict.insert(make_pair("sort", "排序")); // key不存在->插⼊ {"insert", string()} dict["insert"]; // 插⼊+修改 dict["left"] = "左边"; // 修改 dict["left"] = "左边、剩余"; // key存在->查找 cout << dict["left"] << endl; return 0; }

multimap和map的差异

multimap和map的使⽤基本完全类似，主要区别点在于multimap⽀持关键值key冗余，那么insert/find/count/erase都围绕着⽀持关键值key冗余有所差异，这⾥跟set和multiset完全⼀样，⽐如find时，有多个key，返回中序第⼀个。其次就是multimap不⽀持[]，因为⽀持key冗余，[]就只能⽀持插⼊了，不能⽀持修改。

138. 随机链表的复制 - 力扣（LeetCode）

数据结构初阶阶段，为了控制随机指针，我们将拷⻉结点链接在原节点的后⾯解决，后⾯拷⻉节点还得解下来链接，⾮常⿇烦。这⾥我们直接让{原结点,拷⻉结点}建⽴映射关系放到map中，控制随机指针会⾮常简单⽅便，这⾥体现了map在解决⼀些问题时的价值，完全是降维打击。

class Solution { public: Node* copyRandomList(Node* head) { map<Node*, Node*> nodeMap; Node* copyhead = nullptr,*copytail = nullptr; Node* cur = head; while(cur) { if(copytail == nullptr) { copyhead = copytail = new Node(cur->val); } else { copytail->next = new Node(cur->val); copytail = copytail->next; } // 原节点和拷⻉节点map kv存储 nodeMap[cur] = copytail; cur = cur->next; } // 处理random cur = head; Node* copy = copyhead; while(cur) { if(cur->random == nullptr) { copy->random = nullptr; } else { copy->random = nodeMap[cur->random]; } cur = cur->next; copy = copy->next; } return copyhead; } };

692. 前K个高频单词 - 力扣（LeetCode）

本题⽬我们利⽤map统计出次数以后，返回的答案应该按单词出现频率由⾼到低排序，有⼀个特殊要求，如果不同的单词有相同出现频率，按字典顺序排序。
解决思路1：
⽤排序找前k个单词，因为map中已经对key单词排序过，也就意味着遍历map时，次数相同的单词，字典序⼩的在前⾯，字典序⼤的在后⾯。那么我们将数据放到vector中⽤⼀个稳定的排序就可以实现上⾯特殊要求，但是sort底层是快排，是不稳定的，所以我们要⽤stable_sort，他是稳定的。

class Solution { public: struct Compare { bool operator()(const pair<string, int>& x, const pair<string, int>& y) const { // >是降序，<是升序 return x.second > y.second; } }; vector<string> topKFrequent(vector<string>& words, int k) { map<string, int> countMap; for(auto& e : words) { countMap[e]++; } vector<pair<string, int>> v(countMap.begin(), countMap.end()); // 仿函数控制降序 stable_sort(v.begin(), v.end(), Compare()); //sort(v.begin(), v.end(), Compare()); // 取前k个 vector<string> strV; for(int i = 0; i < k; ++i) { strV.push_back(v[i].first); } return strV; } };

解决思路2：
将map统计出的次数的数据放到vector中排序，或者放到priority_queue中来选出前k个。利⽤仿函数强⾏控制次数相等的，字典序⼩的在前⾯。

class Solution { public: struct Compare { bool operator()(const pair<string, int>& x, const pair<string, int>& y) const { return x.second > y.second || (x.second == y.second && x.first < y.first);; } }; vector<string> topKFrequent(vector<string>& words, int k) { map<string, int> countMap; for(auto& e : words) { countMap[e]++; } vector<pair<string, int>> v(countMap.begin(), countMap.end()); // 仿函数控制降序,仿函数控制次数相等，字典序⼩的在前⾯ sort(v.begin(), v.end(), Compare()); // 取前k个 vector<string> strV; for(int i = 0; i < k; ++i) { strV.push_back(v[i].first); } return strV; } };

class Solution { public: struct Compare { bool operator()(const pair<string, int>& x, const pair<string, int>& y) const { // 要注意优先级队列底层是反的，⼤堆要实现⼩于⽐较，所以这⾥次数相等，想要字典序⼩的在前⾯要⽐较字典序⼤的为真 return x.second < y.second || (x.second == y.second && x.first > y.first); } }; vector<string> topKFrequent(vector<string>& words, int k) { map<string, int> countMap; for(auto& e : words) { countMap[e]++; } // 将map中的<单词，次数>放到priority_queue中，仿函数控制⼤堆，次数相同按照字典序规则排序 priority_queue<pair<string, int>, vector<pair<string, int>>, Compare> p(countMap.begin(), countMap.end()); vector<string> strV; for(int i = 0; i < k; ++i) { strV.push_back(p.top().first); p.pop(); } return strV; } };