C++中的map与unordered_map使用

map

map的头文件#include<map>,内部实现了一颗红黑树

map的优缺点

**优点：**有序性，这是map结构最大的优点，其元素的有序性在很多应用中都会简化很多的操作
红黑树，内部实现一个红黑书使得map的很多操作在lgn的时间复杂度下就可以实现，因此效率非常的高
缺点： 空间占用率高，因为map内部实现了红黑树，虽然提高了运行效率，但是因为每一个节点都需要额外保存父节点、孩子节点和红/黑性质，使得每一个节点都占用大量的空间

**适用处：**对于那些有顺序要求的问题，用map会更高效一些

map的基本用法

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

map的实例

map之牛牛找工作

解析：将职位的能力和薪水放入map中，key为能力，value为薪水，在map中就会根据key自动排序了
结合make_pair把找工作的人也加入到map中，这样就可以一起排序了。
在map中遍历（按能力排序好了），将map->second(value)值的含义改为map->first(能力)值以内最多有多少薪水，然后按每个小伙伴的能力直接输出就好啦。

#include<iostream>
#include<cstring>
#include<map>
#include<vector>
using namespace std;
int main() {
	int numWorks;
	int numNumbers;
	map<int, int >mymap; //定义一个哈希表
	cin >> numWorks >> numNumbers;
	while (numWorks--) {
		int nengLi = 0;
		int wages = 0;
		cin >> nengLi >> wages;
		mymap[nengLi] = wages; //哈希表中value=薪水，key=能力
	}
	vector<int>fellow(numNumbers, 0);//设置一个求职人数为大小，初始值为0的vector
	for (int i = 0; i < numNumbers; i++) {
		cin >> fellow[i]; //输入求职人的能力值
	}
	for (int i = 0; i < fellow.size(); i++) {
		if (mymap.count(fellow[i]) == 0) {  //map.count(Key)返回值为1或者0，1返回存在，0返回不存在，
									//返回的是布尔类型的值，因为在map类型中所有的数据的Key值都是不同的，
									//所以被count的数要么存在1次，要么不存在
			mymap.insert(make_pair(fellow[i], -1));
		}
	}
	int nowMax = 0;
	for (map<int, int>::iterator it = mymap.begin(); it != mymap.end(); it++) {
		if (it->second >= nowMax)nowMax = it->second;  //将要求职的人按照原先key排序进行对他们的薪水
																												 //值进行上一个的薪水进行赋值（原先-1）
		else {
			it->second = nowMax;
		}
	}
	for (int i = 0; i < fellow.size(); i++) {
		cout << mymap[fellow[i]] << endl; //输出薪水值
	}
}

map之字符串比配

题目描述
题目标题：
判断短字符串中的所有字符是否在长字符串中全部出现

思路：可以首先把长字符串中的每个字符依次放进map里面并且令其值为1，然后对短字符串中每个字符串看看对应的map是不是为1，如果不是直接退出返回false，短字符串中的每个字符对应的map值都为1返回true。算法复杂度为线性。

#include<iostream>
#include<set>
#include<map>
#include<string>
using namespace std;
class Solution {
public:
	void methods(string& num1, string& num2) {
		map<char, int>mymap;
		for (int i = 0; i < num1.size(); i++) {
			mymap[num1[i]] = 1;
		}
		for (int i = 0; i < num2.size(); i++) {
			if (mymap[num2[i]] == 1) continue;
			else {
				cout << "false" << endl;
				return; //return直接退出次函数break则后面的输出必会执行
			}
			}
		cout << "ture" << endl;
	}
};

int main() {
	string num1, num2;
	while (cin >> num1 >> num2) {
		Solution sol;
		sol.methods(num1, num2);
	}
}

map之工资人数

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>

using namespace std;


int main() {
    int num, q;
    map<int, int>mymap;
    cin >> num >> q;
    vector<int>slar(num,0);
    for (int i = 0; i < num; i++) {
        cin >> slar[i];
        if (mymap.count(slar[i])) mymap[slar[i]]++;
        else mymap[slar[i]] = 1;
    }
    vector<int>ques(q,0);
    for (int i = 0; i < q; i++) {
        cin >> ques[i];
    }
    for (int i = 0; i < q; i++) { 
        printf("%d\n", mymap[ques[i]]);
    }

}

unordered_map

unordered_map的头文件是#include<unordered_map>,内部实现了一个哈希表。

unordered_map的优缺点

优点： 因为内部实现了哈希表，因此其查找速度非常的快
缺点： 哈希表的建立比较耗费时间
适用处：对于查找问题，unordered_map会更加高效一些，因此遇到查找问题，常会考虑一下用unordered_map

unordered_map的实例

# include<iostream>
# include<vector>
# include<algorithm>
# include<unordered_map>
# include <iomanip>
# include <stdio.h>
using namespace std;
int num;
int quesNum;
vector<int> scores;
vector<int> ques;
vector<int> comp;
int main() {
    cin >> num;
    for (int i = 0; i < num; i++) {
        int tmp;
        cin >> tmp;
        scores.push_back(tmp);
    }
    cin >> quesNum;
    for (int i = 0; i < quesNum; i++) {
        int tmp;
        cin >> tmp;
        ques.push_back(tmp);
    }
    comp = scores; //这保存下来scores保证顺序不会错
    sort(comp.begin(), comp.end());//不能少，否则后面用到i求value会出现错误结果
    unordered_map<int, double> store; //哈希表的存储方式
    for (int i = 0; i < num; i++) {
        store[comp[i]] = (double)i / (double)num;  //要求他的排名必须和i搭上关系
    }
    for (int i = 0; i < quesNum; i++) {
        // cout<<setiosflags(ios::fixed)<<setprecision(6)<<store[scores[ques[i]-1]]*100.0<<endl;
        printf("%.6f\n", store[scores[ques[i] - 1]] * 100.0);
    }
    return 0;
}

**简单总结：**内存占有率的问题就转化成红黑树 VS hash表 , 还是unorder_map占用的内存要高。
但是unordered_map执行效率要比map高很多
map和unordered_map的使用
unordered_map的用法和map是一样的，提供了 insert，size，count等操作，并且里面的元素也是以pair类型来存贮的。其底层实现是完全不同的，上方已经解释了，但是就外部使用来说却是一致的。