看着显示屏,学习新知识

看着显示屏,学习新知识

知识先知道

m a p < k e y ( 键 ) , v a l u e ( 值 ) > n a m e ( 名 ) map<key(键), value(值)> name(名) map<key(),value()>name()
u n o r d e r e d _ m a p 如法炮制 unordered\_map如法炮制 unordered_map如法炮制

m a p & u n o r d e r e d _ m a p 的区别 : map \& unordered\_map 的区别: map&unordered_map的区别:

1. 实现 : 1.实现: 1.实现:

  • m a p 是基于平衡二叉搜索树 ( 通常是红黑树 ) 实现的,键是有序的 map是基于平衡二叉搜索树(通常是红黑树)实现的,键是有序的 map是基于平衡二叉搜索树(通常是红黑树)实现的,键是有序的
  • u n o r d e r e d _ m a p 名副其实,它是基于哈希表实现的,键是无序的 unordered\_map名副其实,它是基于哈希表实现的,键是无序的 unordered_map名副其实,它是基于哈希表实现的,键是无序的

2. 性能 : 2.性能: 2.性能:

  • m a p : 插入、删除、查找的平均时间复杂度为 O ( l o g n ) map:插入、删除、查找的平均时间复杂度为O(logn) map:插入、删除、查找的平均时间复杂度为O(logn)
  • u n o r d e r e d _ m a p : 如果哈希函数良好,插入、删除、查找的平均时间复杂度接近 O ( 1 ) ,但最坏情况下可能达到 O ( n ) unordered\_map:如果哈希函数良好,插入、删除、查找的平均时间复杂度接近O(1),但最坏情况下可能达到O(n) unordered_map:如果哈希函数良好,插入、删除、查找的平均时间复杂度接近O(1),但最坏情况下可能达到O(n)

3. 内存 3.内存 3.内存
u n o r d e r e d _ m a p 使用哈希表,当填充因子较低时,需要更多内存 unordered\_map使用哈希表,当填充因子较低时,需要更多内存 unordered_map使用哈希表,当填充因子较低时,需要更多内存

4. 其他: 4.其他: 4.其他:

  • m a p 中的键是有序的,可以很容易的获取键的范围或进行范围查询 map中的键是有序的,可以很容易的获取键的范围或进行范围查询 map中的键是有序的,可以很容易的获取键的范围或进行范围查询
  • u n o r d e r e d _ m a p 虽然键是无序的,但再好的哈希函数与负载因子下,可以提供更快的额查询性能 unordered\_map虽然键是无序的,但再好的哈希函数与负载因子下,可以提供更快的额查询性能 unordered_map虽然键是无序的,但再好的哈希函数与负载因子下,可以提供更快的额查询性能

综上所述,如果需要键的有序特性,用 m a p ;如果需要快速查询且不关心键的顺序,使用 u n o r d e r e d _ m a p 综上所述,如果需要键的有序特性,用map;如果需要快速查询且不关心键的顺序,使用unordered\_map 综上所述,如果需要键的有序特性,用map;如果需要快速查询且不关心键的顺序,使用unordered_map

#include<bits/stdc++.h>
using namespace std;
const unordered_map<char, vector<string>> get_digit_matrix(){//1.定义函数
	//vector:动态数组 
	unordered_map<char, vector<string>> matrix;//2.创建映射
	//3.填充映射
	matrix['0'] = {"XXX", "X.X", "X.X", "X.X", "XXX"};
	matrix['1'] = {"..X", "..X", "..X", "..X", "..X"};
    matrix['2'] = {"XXX", "..X", "XXX", "X..", "XXX"};
    matrix['3'] = {"XXX", "..X", "XXX", "..X", "XXX"};
    matrix['4'] = {"X.X", "X.X", "XXX", "..X", "..X"};
    matrix['5'] = {"XXX", "X..", "XXX", "..X", "XXX"};
    matrix['6'] = {"XXX", "X..", "XXX", "X.X", "XXX"};
    matrix['7'] = {"XXX", "..X", "..X", "..X", "..X"};
    matrix['8'] = {"XXX", "X.X", "XXX", "X.X", "XXX"};
    matrix['9'] = {"XXX", "X.X", "XXX", "..X", "XXX"};
	return matrix;//4.返回映射 
}
int main(){
	std::ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n;
	cin >> n;
	string s;
	cin >> s;
	auto matrix = get_digit_matrix();//auto:自动判断matrix的类型 
	//调用 get_digit_matrix() 函数获取其返回的映射,并将映射存储在变量matrix中 
	for(int i = 0; i < 5; i++){
		for(int j = 0; j < n; j++){
			cout << matrix[s[j]][i];
			if(j != n - 1) cout << ".";
		}
		cout << endl;
	}
	return 0;
}

优化

避免了多次创建映射:每次输出时都会调用 g e t _ d i g i t _ m a t r i x ,从而创建和填充映射,效率十分低效 避免了多次创建映射:每次输出时都会调用get\_digit\_matrix,从而创建和填充映射,效率十分低效 避免了多次创建映射:每次输出时都会调用get_digit_matrix,从而创建和填充映射,效率十分低效

s t a t i c static static
第一次调用 第一次调用 第一次调用get_digit_matrix() 时,该映射会被创建与初始化,所以在后续的调用中,已经存在的映射被返回,从而无需重新创建与初始化 时,该映射会被创建与初始化,所以在后续的调用中,已经存在的映射被返回,从而无需重新创建与初始化 时,该映射会被创建与初始化,所以在后续的调用中,已经存在的映射被返回,从而无需重新创建与初始化

& :返回对静态对象的应用,而不是返回对象的复制品 :返回对静态对象的应用,而不是返回对象的复制品 :返回对静态对象的应用,而不是返回对象的复制品
为什么在 为什么在 为什么在get_digit_matrix() 函数的返回类型前加 函数的返回类型前加 函数的返回类型前加&
每次调用都要从新返回一个新的拷贝,导致性能损失,内存增加 每次调用都要从新返回一个新的拷贝,导致性能损失,内存增加 每次调用都要从新返回一个新的拷贝,导致性能损失,内存增加

#include<bits/stdc++.h>
using namespace std;
const unordered_map<char, vector<string>>& get_digit_matrix(){//1.定义函数 
	//vector:动态数组
    static const unordered_map<char, vector<string>> matrix = {//2.创建映射
    	//3.填充映射
        {'0', {"XXX", "X.X", "X.X", "X.X", "XXX"}},
        {'1', {"..X", "..X", "..X", "..X", "..X"}},
        {'2', {"XXX", "..X", "XXX", "X..", "XXX"}},
        {'3', {"XXX", "..X", "XXX", "..X", "XXX"}},
        {'4', {"X.X", "X.X", "XXX", "..X", "..X"}},
        {'5', {"XXX", "X..", "XXX", "..X", "XXX"}},
        {'6', {"XXX", "X..", "XXX", "X.X", "XXX"}},
        {'7', {"XXX", "..X", "..X", "..X", "..X"}},
        {'8', {"XXX", "X.X", "XXX", "X.X", "XXX"}},
        {'9', {"XXX", "X.X", "XXX", "..X", "XXX"}}
    };
    return matrix;//4.返回映射 
}
int main(){
	std::ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n;
	cin >> n;
	string s;
	cin >> s;
	auto& matrix = get_digit_matrix();//auto:自动判断matrix的类型 
	//调用 get_digit_matrix() 函数获取其返回的映射,并将映射存储在变量matrix中 
	for(int i = 0; i < 5; i++){
		for(int j = 0; j < n; j++){
			cout << matrix.at(s[j])[i];//at:访问键s[j]对应的值 
			if(j != n - 1) cout << ".";
		}
		cout << endl;
	}
	return 0;
}

c o n s t const const
1. 没优化前每次输出都会调用 1.没优化前每次输出都会调用 1.没优化前每次输出都会调用get_digit_matrix() ,每次都要创建与填充映射,创建一个全局的 ,每次都要创建与填充映射,创建一个全局的 ,每次都要创建与填充映射,创建一个全局的const 映射,只创建一次,避免了多次创建映射 映射,只创建一次,避免了多次创建映射 映射,只创建一次,避免了多次创建映射

2. 使用 2.使用 2.使用const 可以防止不小心修改该映射 可以防止不小心修改该映射 可以防止不小心修改该映射

#include<bits/stdc++.h>
using namespace std;
const unordered_map<char, vector<string>> get_digit_matrix = {
	//vector:动态数组
    {'0', {"XXX", "X.X", "X.X", "X.X", "XXX"}},
    {'1', {"..X", "..X", "..X", "..X", "..X"}},
    {'2', {"XXX", "..X", "XXX", "X..", "XXX"}},
    {'3', {"XXX", "..X", "XXX", "..X", "XXX"}},
    {'4', {"X.X", "X.X", "XXX", "..X", "..X"}},
    {'5', {"XXX", "X..", "XXX", "..X", "XXX"}},
    {'6', {"XXX", "X..", "XXX", "X.X", "XXX"}},
    {'7', {"XXX", "..X", "..X", "..X", "..X"}},
    {'8', {"XXX", "X.X", "XXX", "X.X", "XXX"}},
    {'9', {"XXX", "X.X", "XXX", "..X", "XXX"}}
};
int main(){
	std::ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n;
	cin >> n;
	string s;
	cin >> s;
	for(int i = 0; i < 5; i++){
		for(int j = 0; j < n; j++){
			cout << get_digit_matrix.at(s[j])[i];//at:访问键s[j]对应的值 
			if(j != n - 1) cout << ".";
		}
		cout << endl;
	}
	return 0;
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值