hash_map的使用

最新推荐文章于 2022-03-09 15:20:28 发布
最新推荐文章于 2022-03-09 15:20:28 发布
阅读量660 收藏
点赞数
分类专栏： stl的使用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/diaolingle/article/details/51397269
版权

例子：

#include <stdio.h>
#include <string>
#include <hash_map>
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
	hash_map<int, int> hm;
	//插入元素
	for (int i = 0; i < 10; i++)
		hm.insert(make_pair(i, i));
	//正序输出
	hash_map<int, int>::iterator iter = hm.begin();
	for (; iter != hm.end(); ++iter)
		printf("hm[%d] = %d\n", iter->first, iter->second);
	printf("\n");
	//逆序输出
	hash_map<int, int>::reverse_iterator riter = hm.rbegin();
	for (; riter != hm.rend(); ++riter)
		printf("hm[%d] = %d\n", riter->first, riter->second);
	getchar();
	return 0;
}

输出结果为： 

hm[0] = 0
hm[8] = 8
hm[1] = 1
hm[2] = 2
hm[3] = 3
hm[4] = 4
hm[5] = 5
hm[6] = 6
hm[7] = 7
hm[9] = 9

hm[9] = 9
hm[7] = 7
hm[6] = 6
hm[5] = 5
hm[4] = 4
hm[3] = 3
hm[2] = 2
hm[1] = 1
hm[8] = 8
hm[0] = 0

分析： 没什么好说的


例子：

#include <stdio.h>
#include <string>
#include <hash_map>
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
	hash_map<const char*, int> s_hm;
	s_hm["a"] = 123;
	s_hm["b"] = 321;
	char str[60];
	scanf("%s", str);
	printf("s_hm[\"%s\"] = %d\n", str, s_hm[str]);
	getchar();
	getchar();
	return 0;
}

输出结果为： 

a
s_hm["a"] = 0

分析： 输出结果与我们预期的不符，预期结果应该是输出 s_hm["a"] = 123, 这是为什么？

我们分析一下hash_map的源码，在vs2013跟进去调试后，可以看到这关键的一段代码

bool operator()(const _Ty& _Left, const _Ty& _Right) const
{	// apply operator< to operands
	return (_Left < _Right);
}

根据key算出hash值锁定某个桶后，我们会在这个桶中寻找元素，在同种寻找元素需要进行key的比较，我们输进去的key是char [] 型，hash_map里的key是const char*型，这两者用 "<" 去比较肯定是不相同，它比较字符串指针，并不比较字符串内容，所以找不到相应的元素


为了处理这种情况，我们可以模仿写一个比较函数

#include <stdio.h>
#include <string>
#include <hash_map>
using namespace std;

struct CharLess : public binary_function<const char*, const char*, bool>
{
	bool operator()(const first_argument_type& _Left, const second_argument_type& _Right)
	{
		return strcmp(_Left, _Right);
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	hash_map<const char*, int, hash_compare<const char*, CharLess> > s_hm;
	s_hm["a"] = 123;
	s_hm["b"] = 321;
	char str[60];
	scanf("%s", str);
	printf("s_hm[\"%s\"] = %d\n", str, s_hm[str]);
	getchar();
	getchar();
	return 0;
}

运行结果如下： 

a
s_hm["a"] = 123


例子：

#include <stdio.h>
#include <string>
#include <hash_map>
using namespace std;

struct CharLess : public binary_function<const char*, const char*, bool>
{
	bool operator()(const first_argument_type& _Left, const second_argument_type& _Right)
	{
		return strcmp(_Left, _Right);
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	hash_map<const char*, int, hash_compare<const char*, CharLess> > s_hm;
	//获取桶个数
	printf("bucket_count: %d\n", s_hm.bucket_count());
	//获取最大桶个数
	printf("max_bucket_count: %d\n", s_hm.max_bucket_count());
	//_Bucket_size这个元素表示所有桶平均最多可以存几个元素，如果平均超过这个值，就需要进行rehash操作
	printf("_Bucket_size: %d\n", s_hm._Bucket_size);
	//bucket(key)计算对应key会放到哪个桶里
	printf("s_hm.bucket(\"%s\") : %d\n", "hello", s_hm.bucket("hello"));
	printf("s_hm.bucket(\"%s\") :%d\n", "helloa", s_hm.bucket("helloa"));
	printf("s_hm.bucket(\"%s\") :%d\n", "hellob", s_hm.bucket("hellob"));
	s_hm.insert(make_pair("hellob", 2));
	s_hm.insert(make_pair("hello", 1));
	s_hm.insert(make_pair("helloa", 1));

	for (int i = 0; i < s_hm.bucket_count(); i++)
		//bucket_size(i)获取第i个桶里存了的元素数量
		printf("bucket_size(%d): %d\n", i, s_hm.bucket_size(i));

	hash_map<const char*, int>::iterator iter = s_hm.begin();
	for (; iter != s_hm.end(); ++iter)
		printf("%s: %d\n", iter->first, iter->second);
	printf("\n");
	getchar();
	return 0;
}

输出结果为： 

bucket_count: 8
max_bucket_count: 8
_Bucket_size: 1
s_hm.bucket("hello") : 3
s_hm.bucket("helloa") :2
s_hm.bucket("hellob") :2
bucket_size(0): 0
bucket_size(1): 0
bucket_size(2): 2
bucket_size(3): 1
bucket_size(4): 0
bucket_size(5): 0
bucket_size(6): 0
bucket_size(7): 0
helloa: 1
hellob: 2
hello: 1

分析：默认初始化的bucket_count和max_bucket_count都为8，_bucket_szie则是1


例子：

#include <stdio.h>
#include <string>
#include <hash_map>
using namespace std;

struct CharLess : public binary_function<const char*, const char*, bool>
{
	bool operator()(const first_argument_type& _Left, const second_argument_type& _Right)
	{
		return strcmp(_Left, _Right);
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	hash_map<const char*, int, hash_compare<const char*, CharLess> > s_hm;
	//获取桶个数
	printf("bucket_count: %d\n", s_hm.bucket_count());
	//获取最大桶个数
	printf("max_bucket_count: %d\n", s_hm.max_bucket_count());
	//_Bucket_size这个元素表示所有桶平均最多可以存几个元素，如果平均超过这个值，就需要进行rehash操作
	printf("_Bucket_size: %d\n", s_hm._Bucket_size);
	//bucket(key)计算对应key会放到哪个桶里
	printf("s_hm.bucket(\"%s\") : %d\n", "hello", s_hm.bucket("hello"));
	printf("s_hm.bucket(\"%s\") : %d\n", "helloa", s_hm.bucket("helloa"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellob", s_hm.bucket("hellob"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellol", s_hm.bucket("hellol"));
	printf("s_hm.bucket(\"%s\") : %d\n", "helloal", s_hm.bucket("helloal"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellobl", s_hm.bucket("hellobl"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellom", s_hm.bucket("hellom"));
	printf("s_hm.bucket(\"%s\") : %d\n", "helloam", s_hm.bucket("helloam"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellobm", s_hm.bucket("hellobm"));
	s_hm.insert(make_pair("hellob", 2));
	s_hm.insert(make_pair("hello", 1));
	s_hm.insert(make_pair("helloa", 1));;
	s_hm.insert(make_pair("hellobl", 2));
	s_hm.insert(make_pair("hellol", 1));
	s_hm.insert(make_pair("helloal", 1));
	s_hm.insert(make_pair("hellobm", 2));
	s_hm.insert(make_pair("hellom", 1));
	//s_hm.insert(make_pair("helloam", 1));
	for (int i = 0; i < s_hm.bucket_count(); i++)
	{
		//bucket_size(i)获取第i个桶里存了的元素数量
		if (s_hm.bucket_size(i) != 0)
			printf("bucket_size(%d): %d\n", i, s_hm.bucket_size(i));
	}
	//获取桶个数
	printf("bucket_count: %d\n", s_hm.bucket_count());
	//获取最大桶个数
	printf("max_bucket_count: %d\n", s_hm.max_bucket_count());
	hash_map<const char*, int>::iterator iter = s_hm.begin();
	for (; iter != s_hm.end(); ++iter)
		printf("%s: %d\n", iter->first, iter->second);
	printf("\n");
	getchar();
	return 0;
}
运行结果为： 

bucket_count: 8
max_bucket_count: 8
_Bucket_size: 1
s_hm.bucket("hello") : 3
s_hm.bucket("helloa") : 2
s_hm.bucket("hellob") : 2
s_hm.bucket("hellol") : 1
s_hm.bucket("helloal") : 5
s_hm.bucket("hellobl") : 1
s_hm.bucket("hellom") : 1
s_hm.bucket("helloam") : 5
s_hm.bucket("hellobm") : 1
bucket_size(1): 4
bucket_size(2): 2
bucket_size(3): 1
bucket_size(5): 1
bucket_count: 8
max_bucket_count: 8
helloa: 1
hellob: 2
hello: 1
hellom: 1
hellobm: 2
hellol: 1
hellobl: 2
helloal: 1

#include <stdio.h>
#include <string>
#include <hash_map>
using namespace std;

struct CharLess : public binary_function<const char*, const char*, bool>
{
	bool operator()(const first_argument_type& _Left, const second_argument_type& _Right)
	{
		return strcmp(_Left, _Right);
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	hash_map<const char*, int, hash_compare<const char*, CharLess> > s_hm;
	//获取桶个数
	printf("bucket_count: %d\n", s_hm.bucket_count());
	//获取最大桶个数
	printf("max_bucket_count: %d\n", s_hm.max_bucket_count());
	//_Bucket_size这个元素表示所有桶平均最多可以存几个元素，如果平均超过这个值，就需要进行rehash操作
	printf("_Bucket_size: %d\n", s_hm._Bucket_size);
	//bucket(key)计算对应key会放到哪个桶里
	printf("s_hm.bucket(\"%s\") : %d\n", "hello", s_hm.bucket("hello"));
	printf("s_hm.bucket(\"%s\") : %d\n", "helloa", s_hm.bucket("helloa"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellob", s_hm.bucket("hellob"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellol", s_hm.bucket("hellol"));
	printf("s_hm.bucket(\"%s\") : %d\n", "helloal", s_hm.bucket("helloal"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellobl", s_hm.bucket("hellobl"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellom", s_hm.bucket("hellom"));
	printf("s_hm.bucket(\"%s\") : %d\n", "helloam", s_hm.bucket("helloam"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellobm", s_hm.bucket("hellobm"));
	s_hm.insert(make_pair("hellob", 2));
	s_hm.insert(make_pair("hello", 1));
	s_hm.insert(make_pair("helloa", 1));;
	s_hm.insert(make_pair("hellobl", 2));
	s_hm.insert(make_pair("hellol", 1));
	s_hm.insert(make_pair("helloal", 1));
	s_hm.insert(make_pair("hellobm", 2));
	s_hm.insert(make_pair("hellom", 1));
	s_hm.insert(make_pair("helloam", 1));
	for (int i = 0; i < s_hm.bucket_count(); i++)
	{
		//bucket_size(i)获取第i个桶里存了的元素数量
		if (s_hm.bucket_size(i) != 0)
			printf("bucket_size(%d): %d\n", i, s_hm.bucket_size(i));
	}
	//获取桶个数
	printf("bucket_count: %d\n", s_hm.bucket_count());
	//获取最大桶个数
	printf("max_bucket_count: %d\n", s_hm.max_bucket_count());
	hash_map<const char*, int>::iterator iter = s_hm.begin();
	for (; iter != s_hm.end(); ++iter)
		printf("%s: %d\n", iter->first, iter->second);
	printf("\n");
	getchar();
	return 0;
}

运行结果为： 

s_hm.bucket("hellom") : 1
s_hm.bucket("helloam") : 5
s_hm.bucket("hellobm") : 1
bucket_size(2): 1
bucket_size(5): 1
bucket_size(9): 1
bucket_size(29): 1
bucket_size(33): 1
bucket_size(35): 1
bucket_size(42): 1
bucket_size(49): 1
bucket_size(57): 1
bucket_count: 64
max_bucket_count: 64
helloa: 1
hellob: 2
hello: 1
hellom: 1
hellobm: 2
hellol: 1
hellobl: 2
helloam: 1
helloal: 1

分析：当当如元素超过8个（超过原来bucket_count的值），为9个的时候，bucket_count和max_bucket_count都变大了，这时进行了一次rehash 


#include <stdio.h>
#include <string>
#include <hash_map>
using namespace std;

struct CharLess : public binary_function<const char*, const char*, bool>
{
	bool operator()(const first_argument_type& _Left, const second_argument_type& _Right)
	{
		return strcmp(_Left, _Right);
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	hash_map<const char*, int, hash_compare<const char*, CharLess> > s_hm;
	//获取桶个数
	printf("bucket_count: %d\n", s_hm.bucket_count());
	//获取最大桶个数
	printf("max_bucket_count: %d\n", s_hm.max_bucket_count());
	//设置_Max_bucket_size的值
	s_hm.max_load_factor(2);
	//max_load_factor()获取_Max_bucket_size的值，这个元素表示所有桶平均最多可以存几个元素，如果平均超过这个值，就需要进行rehash操作
	printf("_Max_bucket_size: %f\n", s_hm.max_load_factor());
	//bucket(key)计算对应key会放到哪个桶里
	printf("s_hm.bucket(\"%s\") : %d\n", "hello", s_hm.bucket("hello"));
	printf("s_hm.bucket(\"%s\") : %d\n", "helloa", s_hm.bucket("helloa"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellob", s_hm.bucket("hellob"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellol", s_hm.bucket("hellol"));
	printf("s_hm.bucket(\"%s\") : %d\n", "helloal", s_hm.bucket("helloal"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellobl", s_hm.bucket("hellobl"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellom", s_hm.bucket("hellom"));
	printf("s_hm.bucket(\"%s\") : %d\n", "helloam", s_hm.bucket("helloam"));
	printf("s_hm.bucket(\"%s\") : %d\n", "hellobm", s_hm.bucket("hellobm"));
	s_hm.insert(make_pair("hellob", 2));
	s_hm.insert(make_pair("hello", 1));
	s_hm.insert(make_pair("helloa", 1));;
	s_hm.insert(make_pair("hellobl", 2));
	s_hm.insert(make_pair("hellol", 1));
	s_hm.insert(make_pair("helloal", 1));
	s_hm.insert(make_pair("hellobm", 2));
	s_hm.insert(make_pair("hellom", 1));
	s_hm.insert(make_pair("helloam", 1));
	for (int i = 0; i < s_hm.bucket_count(); i++)
	{
		//bucket_size(i)获取第i个桶里存了的元素数量

		if (s_hm.bucket_size(i) != 0)
			printf("bucket_size(%d): %d\n", i, s_hm.bucket_size(i));
	}
	//获取桶个数
	printf("bucket_count: %d\n", s_hm.bucket_count());
	//获取最大桶个数
	printf("max_bucket_count: %d\n", s_hm.max_bucket_count());
	hash_map<const char*, int>::iterator iter = s_hm.begin();
	for (; iter != s_hm.end(); ++iter)
		printf("%s: %d\n", iter->first, iter->second);
	printf("\n");
	getchar();
	return 0;
}

输出结果为： 

bucket_count: 8
max_bucket_count: 8
_Max_bucket_size: 2.000000
s_hm.bucket("hello") : 3
s_hm.bucket("helloa") : 2
s_hm.bucket("hellob") : 2
s_hm.bucket("hellol") : 1
s_hm.bucket("helloal") : 5
s_hm.bucket("hellobl") : 1
s_hm.bucket("hellom") : 1
s_hm.bucket("helloam") : 5
s_hm.bucket("hellobm") : 1
bucket_size(1): 4
bucket_size(2): 2
bucket_size(3): 1
bucket_size(5): 2
bucket_count: 8
max_bucket_count: 8
helloa: 1
hellob: 2
hello: 1
hellom: 1
hellobm: 2
hellol: 1
hellobl: 2
helloam: 1
helloal: 1

分析：以上例子吧_Max_bucket_size设置为2后，插入9个元素后哈希表没有rehash操作，这时的临界值上升为16

注意：之前的例子有一个错误，_Bucket_size这个成员变量只是hash_map初始化时用来初始化_Max_bucket_size的, 上面有几个例子把它的作用标错了



reserve函数的使用

#include <stdio.h>
#include <string>
#include <hash_map>
using namespace std;

struct CharLess : public binary_function<const char*, const char*, bool>
{
	bool operator()(const first_argument_type& _Left, const second_argument_type& _Right)
	{
		return strcmp(_Left, _Right);
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	hash_map<const char*, int, hash_compare<const char*, CharLess> > s_hm;
	//获取桶个数
	printf("bucket_count: %d\n", s_hm.bucket_count());
	//获取最大桶个数
	printf("max_bucket_count: %d\n", s_hm.max_bucket_count());
	//设置_Max_bucket_size的值
	s_hm.max_load_factor(2);
	//max_load_factor()获取_Max_bucket_size的值，这个元素表示所有桶平均最多可以存几个元素，如果平均超过这个值，就需要进行rehash操作
	printf("_Max_bucket_size: %f\n", s_hm.max_load_factor());
	s_hm.reserve(100);
	//获取桶个数
	printf("bucket_count: %d\n", s_hm.bucket_count());
	//获取最大桶个数
	printf("max_bucket_count: %d\n", s_hm.max_bucket_count());
	getchar();
	return 0;
}

运行结果为 

bucket_count: 8
max_bucket_count: 8
_Max_bucket_size: 2.000000
bucket_count: 64
max_bucket_count: 64


diaolingle
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ hash_map用法总结
qq632544991p的专栏
06-19 1万+
c++ STL库里有自定义的hash_map 方法，但是使用起来并不是那么方便 hash_map主要的方法有 find(),insert() 我结合官方API说明一下他们的用法 一、需要特别注意的地方， 1.头文件的引用 2.如何插入一个键值对（参考一下代码） 3.find（）的返回值 4.如何获取某一个key值相应的value值 hm1_RcIter -> sec
dense_hash_map:STD的简单替代
05-24
jg :: dense_hash_map 一个简单的std::unordered_map替代品，具有更好的性能，但失去了稳定的寻址方式，这是一种折衷方案。 在此处查看此哈希图的详细说明： : 生成状态： 特拉维斯（Travis）：
C++：Hash_map(哈希映射)
杨杨子江的博客
05-06 2719
猎豹网校的图 ###目录###0 为什么需要hash_map1 数据结构：hash_map原理2 hash_map 使用2.1 一个简单实例2.2 hash_map 的hash函数2.3 hash_map 的比较函数2.4 hash_map 函数3 相关hash容器4 其他4.1 hash_map和map的区别在哪里？4.2 什么时候需要用hash_map，什么时候需要用map?4.3 如何...
一个hash_map的奇怪问题
ltlzyy的专栏
07-20 945
今天，一个朋友问我一个问题，说下面的一段代码不能正常工作：             #include #include #include using namespace std; using namespace stdext; void main() {
hash_map介绍与使用
holybin的专栏
05-19 1万+
http://stackoverflow.com/questions/5908581/is-hash-map-part-of-the-stl http://blog.csdn.net/dongtingzhizi/article/details/8629285
hash_map的简单应用
01-05
hash_map
hash_map的详解
02-10
关于hash_map的用法与解释： #include <hash_map> #include #include using namespace std; //define the class class ClassA{ public: ClassA(int a):c_a(a){} int getvalue()const { return c_a;} void ...
linux hash_map
06-23
与`map`不同，`hash_map`不使用二叉查找树（如红黑树），而是利用哈希函数来实现快速查找。哈希表通常由数组和散列函数组成，数组的大小通常是固定的，散列函数将键转换为数组的索引，从而快速定位到对应的值。 `...
Hash_map 实现源码
06-27
哈希映射（Hash Map）是一种常见的数据结构，它提供了键值对（Key-Value Pair）的快速存储和检索功能。在C++中，STL（Standard Template Library）提供了一个名为`std::unordered_map`的容器，它是基于哈希表实现的...
HashMap详解
热门推荐
java123456111的博客
03-09 5万+
一、HashMap集合简介 HashMap 基于哈希表的 Map 接口实现，是以 key-value 存储形式存在，即主要用来存放键值对。HashMap 的实现不是同步的，这意味着它不是线程安全的。它的 key、value 都可以为 null，此外，HashMap 中的映射不是有序的。 jdk1.8 之前 HashMap 由 数组 + 链表 组成，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突（两个对象调用的 hashCode 方法计算的哈希值经哈希函数算出来的地址被别的元素占用）而存
hash索引的bucket_count如何设置
网络资源
08-13 539
A表为普通表，现在要将他导入B表（B为内存表），那么B表的hash索引的buckt_count设置多少，则可执行以下SQL参考。 SELECT POWER( 2, CEILING( LOG( COUNT( 0)) / LOG( 2))) AS 'BUCKET_COUNT' FROM (SELECT DISTINCT <Index Columns...
C++ map 和 hash_map基本用法 遍历- 插入- find -释放 memory - 对象类型的操作 -remove_if 的替代方法
5266的博客
03-06 7091
/*** * 练习map和 hash_map 的基本用法 * insert 插入 * map 遍历 * map find * object 的成员在一定范围 的find remove_if() 的替代方法 * map erase * map delete key-value * map modify data * 交换 两个map * map vector 的memory 的...
c++ map 获取key列表_Map 在 Go runtime 中的高效实现（不使用范型）
weixin_39662834的博客
11-23 663
这篇文章基于我在日本东京 GoCon Spring 2018 上的演讲讨论了，Go 语言中的 map 是如何实现的。什么是映射函数要明白 map 是如何工作的的，我们需要先讨论一下 map 函数。一个 map 函数用以将一个值映射到另一个值。给定一个值，我们叫 key，它就会返回另外一个值，称为 value。map(key) → value 现在，map 还没什么用，除非我们放入一些数据。我们需要...
map和hash_map的区别
$firecat利白的代码足迹$
02-27 1575
1、STL的map底层是用红黑树（RB Tree）实现的，查找时间复杂度是log(n)，而hash_map底层是用hash表存储的，查询时间复杂度是O(1)2、hash_map比map查找速度更快。3、linux c的使用方法#include &lt;map&gt; //mapusing namespace std;//make_pair需要#include &lt;hash_map&gt;usi...
HashMap的基本用法
flysening的博客
06-12 9907
    HashMap是一个Map的接口下面的一个字接口，是一个非常重要的集合类型，面试也经常问HashMap的的原理。 package JzTest; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java...
STL中的map和hashmap数据结构
猪少爷的专栏
02-28 7448
STL中map的数据结构 1.map定义 map是键-值对的集合。map类型通常可以理解为关联数组：可使用键作为下标来获取一个值，正如内置数组类型一样。而关联的本质在于元素的值与某个特定的键相关联，而并非通过元素在数组中的位置来获取。 map模板原型： template ,           　　　　　　class Allocator = allocator > > class ma
hash_map就是unordered_map吗
最新发布
09-13
根据引用中的内容，有人可能会认为使用标记数组来查询某个数是否出现可以达到O(1)的时间复杂度，这样是否还需要使用hash_map、unordered_map和map呢？根据引用的分析，我们知道hash_map和unordered_map应该选择使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值