C++ 高级编程 编写一个 STL 容器：基本 hashmap

最新推荐文章于 2024-03-21 15:02:28 发布
最新推荐文章于 2024-03-21 15:02:28 发布
阅读量1.1k 收藏
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mabing993/article/details/79652038
版权

参考 C++ 高级编程，实现一个 STL 容器：基本 hashmap

hashmap.h

#include <stdexcept>
#include <string>
#include <vector>
#include <list>
#include <algorithm>
#include <iterator>

using namespace std;

template<typename T>
class DefaultHash
{
	public:
		DefaultHash(int numBuckets = 101) throw(std::invalid_argument);
		int hash(const T& key) const;
		int numBuckets() const 
		{
			return mNumBuckets;
		}

	private:
		int mNumBuckets;
};

	template<typename T>
DefaultHash<T>::DefaultHash(int numBuckets) throw(std::invalid_argument)
{
	if (numBuckets <= 0)
	{
		throw std::invalid_argument("numBuckets must be > 0");
	}

	mNumBuckets = numBuckets;
}

template<typename T>
int DefaultHash<T>::hash(const T& key) const 
{
	int bytes = sizeof(key);
	unsigned long ret = 0;
	for (int i = 0; i < bytes; ++i)
	{
		ret += *((char*)&key + i);
	}
	return ret % mNumBuckets;
}

template<>
class DefaultHash<string>
{
	public:
		DefaultHash(int numBuckets = 101) throw(std::invalid_argument);
		int hash(const string& key) const;
		int numBuckets() const 
		{
			return mNumBuckets;
		}

	private:
		int mNumBuckets;
};

DefaultHash<string>::DefaultHash(int numBuckets) throw(std::invalid_argument)
{
	if (numBuckets <= 0)
	{
		throw std::invalid_argument("numBuckets must be > 0");
	}

	mNumBuckets = numBuckets;
}

int DefaultHash<string>::hash(const string& key) const 
{
	int sum = 0;
	for (size_t i = 0; i < key.size(); ++i)
	{
		sum += key[i];
	}
	return sum % mNumBuckets;
}

template<typename Key, typename T, typename Compare, typename Hash>
class HashIterator;

template<typename Key, typename T, typename Compare = std::equal_to<Key>, typename Hash = DefaultHash<Key> >
class hashmap
{
	public:
		typedef Key key_type;
		typedef T mapped_type;
		typedef pair<const Key, T> value_type;
		typedef pair<const Key, T>& reference;
		typedef const pair<const Key, T>& const_reference;
		typedef size_t size_type;
		typedef ptrdiff_t difference_type;
		typedef HashIterator<Key, T, Compare, Hash> iterator;
		typedef HashIterator<Key, T, Compare, Hash> const_iterator;
		typedef Compare key_compare;

		class value_compare
			: public std::binary_function<value_type, value_type, bool>
		{
			public:
				bool operator()(const value_type& x, const value_type& y) const 
				{
					return comp(x.first, y.first);
				}

				friend class hashmap<Key, T, Compare, Hash>;

			private:
				value_compare(Compare c)
					: comp(c)
				{

				}

				Compare comp;
		};

		friend class HashIterator<Key, T, Compare, Hash>;

		explicit hashmap(const Compare& comp = Compare(), const Hash& hash = Hash()) throw(std::invalid_argument);

		template<typename InputIterator>
			hashmap(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Hash& = Hash()) throw(std::invalid_argument);

		~hashmap();
		hashmap(const hashmap<Key, T, Compare, Hash>& src);
		hashmap<Key, T, Compare, Hash>& operator=(const hashmap<Key, T, Compare, Hash>& rhs);

		template<typename InputIterator>
			void insert(InputIterator first, InputIterator last);

		pair<iterator, bool> insert(const value_type& x);
		iterator insert(iterator position, const value_type& x);

		void erase(iterator position);
		size_type erase(const key_type& x);
		void erase(iterator first, iterator last);

		void clear();
		key_compare key_comp() const;
		value_compare value_comp() const;

		iterator find(const key_type& x);
		const_iterator find(const key_type& x) const;

		T& operator[](const key_type& x);

		bool empty() const;
		size_type size() const;
		size_type max_size() const;
		size_type count(const key_type& x) const;

		void swap(hashmap<Key, T, Compare, Hash>& hashIn);

		iterator begin();
		iterator end();
		const_iterator begin() const;
		const_iterator end() const;

	private:
		typedef list<value_type> ListType;

		typename ListType::iterator findElement(const key_type& x, int& bucket) const;

		vector<ListType>* mElems;
		int mSize;
		Compare mComp;
		Hash mHash;
};

	template<typename Key, typename T, typename Compare, typename Hash>
hashmap<Key, T, Compare, Hash>::hashmap(const Compare& comp, const Hash& hash) throw(std::invalid_argument)
	: mSize(0), mComp(comp), mHash(hash)
{
	if (mHash.numBuckets() <= 0)
	{
		throw std::invalid_argument("number of buckets must be positive");
	}

	mElems = new vector<ListType>(mHash.numBuckets());
}

template<typename Key, typename T, typename Compare, typename Hash>
	template<typename InputIterator>
hashmap<Key, T, Compare, Hash>::hashmap(InputIterator first, InputIterator last, const Compare& comp, const Hash& hash) throw(std::invalid_argument)
	: mSize(0), mComp(comp), mHash(hash)
{
	if (mHash.numBuckets() <= 0)
	{
		throw std::invalid_argument("number of buckets must be positive");
	}

	mElems = new vector<ListType>(mHash.numBuckets());
	insert(first, last);
}

	template<typename Key, typename T, typename Compare, typename Hash>
hashmap<Key, T, Compare, Hash>::~hashmap()
{
	delete mElems;
}

	template<typename Key, typename T, typename Compare, typename Hash>
hashmap<Key, T, Compare, Hash>::hashmap(const hashmap<Key, T, Compare, Hash>& src)
	: mSize(src.mSize), mComp(src.mComp), mHash(src.mHash)
{
	mElems = new vector<ListType>(*(src.mElems));
}

	template<typename Key, typename T, typename Compare, typename Hash>
hashmap<Key, T, Compare, Hash>& hashmap<Key, T, Compare, Hash>::operator=(const hashmap<Key, T, Compare, Hash>& rhs)
{
	if (this != &rhs)
	{
		delete mElems;
		mSize = rhs.mSize;
		mComp = rhs.mComp;
		mHash = rhs.mHash;
		mElems = new vector<ListType>(*(rhs.mElems));
	}

	return *this;
}

template<typename Key, typename T, typename Compare, typename Hash>
typename hashmap<Key, T, Compare, Hash>::ListType::iterator hashmap<Key, T, Compare, Hash>::findElement(const key_type& x, int& bucket) const 
{
	bucket = mHash.hash(x);
	for (typename ListType::iterator it = (*mElems)[bucket].begin(); it != (*mElems)[bucket].end(); ++it)
	{
		if (mComp(it->first, x))
		{
			return it;
		}
	}

	return (*mElems)[bucket].end();
}

	template<typename Key, typename T, typename Compare, typename Hash>
typename hashmap<Key, T, Compare, Hash>::iterator hashmap<Key, T, Compare, Hash>::find(const key_type& x)
{
	int bucket;
	typename ListType::iterator it = findElement(x, bucket);
	if (it == (*mElems)[bucket].end())
	{
		return end();
	}

	return HashIterator<Key, T, Compare, Hash>(bucket, it, this);
}

template<typename Key, typename T, typename Compare, typename Hash>
typename hashmap<Key, T, Compare, Hash>::const_iterator hashmap<Key, T, Compare, Hash>::find(const key_type& x) const 
{
	int bucket;
	typename ListType::iterator it = findElement(x, bucket);
	if (it == (*mElems)[bucket].end())
	{
		return end();
	}

	return HashIterator<Key, T, Compare, Hash>(bucket, it, this);
}

	template<typename Key, typename T, typename Compare, typename Hash>
T& hashmap<Key, T, Compare, Hash>::operator[](const key_type& x)
{
	return (insert(make_pair(x, T())).first)->second;
}

	template<typename Key, typename T, typename Compare, typename Hash>
pair<typename hashmap<Key, T, Compare, Hash>::iterator, bool> hashmap<Key, T, Compare, Hash>::insert(const value_type& x)
{
	int bucket;
	typename ListType::iterator it = findElement(x.first, bucket);

	if (it != (*mElems)[bucket].end())
	{
		HashIterator<Key, T, Compare, Hash> newIt(bucket, it, this);
		pair<HashIterator<Key, T, Compare, Hash>, bool> p(newIt, false);
		return p;
	}
	else 
	{
		++mSize;
		typename ListType::iterator endIt = (*mElems)[bucket].insert((*mElems)[bucket].end(), x);
		pair<HashIterator<Key, T, Compare, Hash>, bool> p(HashIterator<Key, T, Compare, Hash>(bucket, endIt, this), true);
		return p;
	}
}

template<typename Key, typename T, typename Compare, typename Hash>
	template<typename InputIterator>
void hashmap<Key, T, Compare, Hash>::insert(InputIterator first, InputIterator last)
{
	insert_iterator<hashmap<Key, T, Compare, Hash> > inserter(*this, begin());
	copy(first, last, inserter);
}

	template<typename Key, typename T, typename Compare, typename Hash>
typename hashmap<Key, T, Compare, Hash>::iterator hashmap<Key, T, Compare, Hash>::insert(typename hashmap<Key, T, Compare, Hash>::iterator position, const value_type& x)
{
	(void)position;
	return insert(x).first;
}

	template<typename Key, typename T, typename Compare, typename Hash>
typename hashmap<Key, T, Compare, Hash>::size_type hashmap<Key, T, Compare, Hash>::erase(const key_type& x)
{
	int bucket;
	typename ListType::iterator it = findElement(x, bucket);
	if (it != (*mElems)[bucket].end())
	{
		(*mElems)[bucket].erase(it);
		--mSize;
		return 1;
	}

	return 0;
}

	template<typename Key, typename T, typename Compare, typename Hash>
void hashmap<Key, T, Compare, Hash>::erase(typename hashmap<Key, T, Compare, Hash>::iterator position)
{
	(*mElems)[position.getBucket()].erase(position.getIterator());
	--mSize;
}

	template<typename Key, typename T, typename Compare, typename Hash>
void hashmap<Key, T, Compare, Hash>::erase(typename hashmap<Key, T, Compare, Hash>::iterator first, typename hashmap<Key, T, Compare, Hash>::iterator last)
{
	typename hashmap<Key, T, Compare, Hash>::iterator cur, next;
	for (next = first; next != last; )
	{
		cur = next++;
		erase(cur);
	}
}

	template<typename Key, typename T, typename Compare, typename Hash>
void hashmap<Key, T, Compare, Hash>::clear()
{
	for_each(mElems->begin(), mElems->end(), mem_fun_ref(&ListType::clear));
	mSize = 0;
}

template<typename Key, typename T, typename Compare, typename Hash>
typename hashmap<Key, T, Compare, Hash>::key_compare hashmap<Key, T, Compare, Hash>::key_comp() const 
{
	return mComp;
}

template<typename Key, typename T, typename Compare, typename Hash>
typename hashmap<Key, T, Compare, Hash>::value_compare hashmap<Key, T, Compare, Hash>::value_comp() const 
{
	return value_compare(mComp);
}

template<typename Key, typename T, typename Compare, typename Hash>
bool hashmap<Key, T, Compare, Hash>::empty() const 
{
	return mSize == 0;
}

template<typename Key, typename T, typename Compare, typename Hash>
typename hashmap<Key, T, Compare, Hash>::size_type hashmap<Key, T, Compare, Hash>::size() const 
{
	return mSize;
}

template<typename Key, typename T, typename Compare, typename Hash>
typename hashmap<Key, T, Compare, Hash>::size_type hashmap<Key, T, Compare, Hash>::max_size() const 
{
	return (*mElems)[0].max_size();
}

template<typename Key, typename T, typename Compare, typename Hash>
typename hashmap<Key, T, Compare, Hash>::size_type hashmap<Key, T, Compare, Hash>::count(const key_type& x) const 
{
	if (find(x) == end())
	{
		return 0;
	}
	else 
	{
		return 1;
	}
}

	template<typename Key, typename T, typename Compare, typename Hash>
void hashmap<Key, T, Compare, Hash>::swap(hashmap<Key, T, Compare, Hash>& hashIn)
{
	std::swap(*this, hashIn);
}

	template<typename Key, typename T, typename Compare, typename Hash>
typename hashmap<Key, T, Compare, Hash>::iterator hashmap<Key, T, Compare, Hash>::begin()
{
	if (mSize == 0)
	{
		return end();
	}

	for (size_t i = 0; i < mElems->size(); ++i)
	{
		if (!((*mElems)[i].empty()))
		{
			return HashIterator<Key, T, Compare, Hash>(i, (*mElems)[i].begin(), this);
		}
	}

	return end();
}

	template<typename Key, typename T, typename Compare, typename Hash>
typename hashmap<Key, T, Compare, Hash>::iterator hashmap<Key, T, Compare, Hash>::end()
{
	return HashIterator<Key, T, Compare, Hash>(mElems->size() - 1, (*mElems)[mElems->size() - 1].end(), this);
}

template<typename Key, typename T, typename Compare, typename Hash>
typename hashmap<Key, T, Compare, Hash>::const_iterator hashmap<Key, T, Compare, Hash>::begin() const 
{
	if (mSize == 0)
	{
		return end();
	}

	for (size_t i = 0; i < mElems->size(); ++i)
	{
		if (!((*mElems)[i].empty()))
		{
			return HashIterator<Key, T, Compare, Hash>(i, (*mElems)[i].begin(), this);
		}
	}

	return end();
}

template<typename Key, typename T, typename Compare, typename Hash>
typename hashmap<Key, T, Compare, Hash>::const_iterator hashmap<Key, T, Compare, Hash>::end() const 
{
	return HashIterator<Key, T, Compare, Hash>(mElems->size() - 1, (*mElems)[mElems->size() - 1].end(), this);
}

template<typename Key, typename T, typename Compare, typename Hash>
class HashIterator : public std::iterator<std::bidirectional_iterator_tag, pair<const Key, T> >
{
	public:
		HashIterator();
		HashIterator(int bucket, typename list<pair<const Key, T> >::iterator listIt, const hashmap<Key, T, Compare, Hash>* inHashMap);

		pair<const Key, T>& operator*() const;
		pair<const Key, T>* operator->() const;

		HashIterator<Key, T, Compare, Hash>& operator++();
		const HashIterator<Key, T, Compare, Hash> operator++(int);

		HashIterator<Key, T, Compare, Hash>& operator--();
		const HashIterator<Key, T, Compare, Hash> operator--(int);

		bool operator==(const HashIterator& rhs) const;
		bool operator!=(const HashIterator& rhs) const;

		const HashIterator<Key, T, Compare, Hash>& operator+(int);
		const HashIterator<Key, T, Compare, Hash>& operator-(int);

		int getBucket() const 
		{
			return mBucket;
		}

		typename list<pair<const Key, T> >::iterator getIterator() const 
		{
			return mIt;
		}

	private:
		void increment();
		void decrement();

		int mBucket;
		typename list<pair<const Key, T> >::iterator mIt;
		const hashmap<Key, T, Compare, Hash>* mHashMap;
};

	template<typename Key, typename T, typename Compare, typename Hash>
HashIterator<Key, T, Compare, Hash>::HashIterator()
{
	mBucket = -1;
	mIt = typename list<pair<const Key, T> >::iterator();
	mHashMap = NULL;
}

	template<typename Key, typename T, typename Compare, typename Hash>
HashIterator<Key, T, Compare, Hash>::HashIterator(int bucket, typename list<pair<const Key, T> >::iterator listIt, const hashmap<Key, T, Compare, Hash>* inHashMap)
	: mBucket(bucket), mIt(listIt), mHashMap(inHashMap)
{

}

template<typename Key, typename T, typename Compare, typename Hash>
pair<const Key, T>& HashIterator<Key, T, Compare, Hash>::operator*() const 
{
	return *mIt;
}

template<typename Key, typename T, typename Compare, typename Hash>
pair<const Key, T>* HashIterator<Key, T, Compare, Hash>::operator->() const 
{
	return &(*mIt);
}

	template<typename Key, typename T, typename Compare, typename Hash>
HashIterator<Key, T, Compare, Hash>& HashIterator<Key, T, Compare, Hash>::operator++()
{
	increment();
	return *this;
}

	template<typename Key, typename T, typename Compare, typename Hash>
const HashIterator<Key, T, Compare, Hash> HashIterator<Key, T, Compare, Hash>::operator++(int)
{
	HashIterator<Key, T, Compare, Hash> oldIt = *this;
	increment();
	return oldIt;
}

	template<typename Key, typename T, typename Compare, typename Hash>
HashIterator<Key, T, Compare, Hash>& HashIterator<Key, T, Compare, Hash>::operator--()
{
	decrement();
	return *this;
}

	template<typename Key, typename T, typename Compare, typename Hash>
const HashIterator<Key, T, Compare, Hash> HashIterator<Key, T, Compare, Hash>::operator--(int)
{
	HashIterator<Key, T, Compare, Hash> newIt = *this;
	decrement();
	return newIt;
}

template<typename Key, typename T, typename Compare, typename Hash>
bool HashIterator<Key, T, Compare, Hash>::operator==(const HashIterator& rhs) const 
{
	return (mHashMap == rhs.mHashMap) && (mBucket == rhs.mBucket) && (mIt == rhs.mIt);
}

template<typename Key, typename T, typename Compare, typename Hash>
bool HashIterator<Key, T, Compare, Hash>::operator!=(const HashIterator& rhs) const 
{
	return !(operator==(rhs));
}

	template<typename Key, typename T, typename Compare, typename Hash>
const HashIterator<Key, T, Compare, Hash>& HashIterator<Key, T, Compare, Hash>::operator+(int step)
{
	for (int i = 0; i < step; ++i)
	{
		increment();
	}
	return *this;
}

	template<typename Key, typename T, typename Compare, typename Hash>
const HashIterator<Key, T, Compare, Hash>& HashIterator<Key, T, Compare, Hash>::operator-(int step)
{
	for (int i = 0; i < step; ++i)
	{
		decrement();
	}
	return *this;
}

	template<typename Key, typename T, typename Compare, typename Hash>
void HashIterator<Key, T, Compare, Hash>::increment()
{
	++mIt;
	if (mIt == (*(mHashMap->mElems))[mBucket].end())
	{
		for (size_t i = mBucket + 1; i < (*(mHashMap->mElems)).size(); ++i)
		{
			if (!((*(mHashMap->mElems))[i].empty()))
			{
				mIt = (*(mHashMap->mElems))[i].begin();
				mBucket = i;
				return;
			}
		}

		mBucket = (*(mHashMap->mElems)).size() - 1;
		mIt = (*(mHashMap->mElems))[mBucket].end();
	}
}

	template<typename Key, typename T, typename Compare, typename Hash>
void HashIterator<Key, T, Compare, Hash>::decrement()
{
	if (mIt == (*(mHashMap->mElems))[mBucket].begin())
	{
		for (int i = mBucket - 1; i >= 0; --i)
		{
			if (!((*(mHashMap->mElems))[i].empty()))
			{
				mIt = (*(mHashMap->mElems))[i].end();
				--mIt;
				mBucket = i;
				return;
			}
		}

		mIt = (*(mHashMap->mElems))[0].begin();
		--mIt;
		mBucket = 0;
	}
	else 
	{
		--mIt;
	}
}

test.cpp

#include "hashmap.h"
#include <iostream>
#include <map>

using namespace std;

void printHashMap(const hashmap<string, int>& myMap);

int main()
{
	DefaultHash<int> hash;
	cout << hash.hash(23) << endl;;

	DefaultHash<string> hash2;
	cout << hash2.hash("my hashmap") << endl;

	hashmap<int, int> hm;
	hm.insert(make_pair(4, 40));
	hm.insert(make_pair(5, 50));

	hashmap<int, int>::iterator x = hm.find(4);
	if (x != hm.end())
	{
		cout << "4 maps to " << x->second << endl;
	}
	else 
	{
		cout << "can not find 4 in map" << endl;
	}

	cout << hm.size() << " " << hm.max_size() << endl;

	hm.erase(4);

	x = hm.find(4);
	if (x != hm.end())
	{
		cout << "4 maps to " << x->second << endl;
	}
	else 
	{
		cout << "can not find 4 in map" << endl;
	}

	cout << hm.size() << " " << hm.max_size() << endl;

	hm[4] = 35;
	cout << hm[4] << endl;

	cout << hm.size() << " " << hm.max_size() << endl;

	list<pair<int, int> > l;
	vector<list<pair<int, int> > > v;
	cout << l.max_size() << " " << v.max_size() << endl;

	hashmap<string, int> myHash;
	cout << boolalpha << myHash.empty() << endl;
	myHash.insert(make_pair("KeyOne", 100));
	myHash.insert(make_pair("KeyTwo", 200));
	myHash.insert(make_pair("KeyThree", 300));
	myHash.insert(myHash.begin(), make_pair("KeyFour", 400));
	myHash.insert(myHash.end(), make_pair("KeyFive", 500));
	cout << boolalpha << myHash.empty() << endl;
	cout << myHash.count("KeyFive") << " " << myHash.count("KeySix") << endl;
	printHashMap(myHash);

	map<string, int> myMap;
	myMap.insert(make_pair("KeyMap", 1000));
	myMap.insert(make_pair("KeyMap2", 2000));
	myMap.insert(make_pair("KeyMap3", 3000));

	hashmap<string, int> myHash2(myMap.begin(), myMap.end());
	printHashMap(myHash2);

	myHash2.swap(myHash);
	printHashMap(myHash);
	printHashMap(myHash2);
	myHash2.swap(myHash);

	myHash.insert(myMap.begin(), myMap.end());
	printHashMap(myHash);

	hashmap<string, int> myHash3(myHash);
	printHashMap(myHash3);

	hashmap<string, int> myHash4 = myHash;
	printHashMap(myHash4);

	map<string, int> myMap2(myHash.begin(), myHash.end());
	for (map<string, int>::iterator it = myMap2.begin(); it != myMap2.end(); ++it)
	{
		cout << it->first << " STL maps to " << (*it).second << endl;
	}
	cout << endl;

	myHash.erase("KeyFour");
	printHashMap(myHash);

	myHash.erase("KeySix");
	printHashMap(myHash);

	printHashMap(myHash2);
	myHash2.erase(myHash2.begin() + 1);
	printHashMap(myHash2);

	myHash2.erase(myHash2.end() - 1);
	printHashMap(myHash2);

	myHash2.erase(myHash2.end() - 1);
	printHashMap(myHash2);

	cout << boolalpha << myHash2.empty() << endl;
	
	myHash3.erase(myHash3.begin(), myHash3.end());
	cout << boolalpha << myHash3.empty() << endl;
	
	myHash.clear();
	cout << boolalpha << myHash.empty() << endl;

	return 0;
}

void printHashMap(const hashmap<string, int>& myMap)
{
	for (hashmap<string, int>::iterator it = myMap.begin(); it != myMap.end(); ++it)
	{
		cout << it->first << " maps to " << (*it).second << endl;
	}

	cout << endl;
}
mabing993
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ HashMap
有趣的人
11-08 4993
HashMap map用法总结 hashmap简单介绍 #include< map> 数据结构 基于哈希表，以空间换时间，是存储key-value键值对的集合。 基本原理：使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数，也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标，hash值）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键...
详细解说STL hash_map系列
fisher_jiang的专栏
04-01 2884
0 为什么需要hash_map 用过map吧？map提供一个很常用的功能，那就是提供key-value的存储和查找功能。例如，我要记录一个人名和相应的存储，而且随时增加，要快速查找和修改： 岳不群－华山派掌门人，人称君子剑张三丰－武当掌门人，太极拳创始人东方不败－第一高手，葵花宝典...这些信息如果保存下来并不复杂，但是找起来比较麻烦。例如我要找"张三丰"的信息，最傻的方法就是取得所有的记录，然后
hash_map:C++ STL 哈希映射容器
07-14
STL hash_map: 链式散列 版权所有 (c) 2014，龙 (Ryan) 南宫。 保留所有权利。 邮箱： 创建时间：2014 年 7 月 15 日 这是无序的哈希映射，它具有恒定的插入、删除、搜索时间，并支持向前/向后迭代。 hash_map 的成员函数实现： size_t hash (const Key& key); size_t size(); iterator begin(); iterator end(); iterator rbegin(); iterator rend(); iterator insert (const Key& key, const Value& value); iterator find (const Key& key); void erase (iterator pos); Value operator[] (const Key&
C++中的Hashmap
Misty_Rain_的博客
02-16 2万+
C++中的Hashmap Hashmap 结构 HashMap是基于哈希表实现的，每一个元素是一个key-value对，其内部通过单链表解决冲突问题，容量不足（超过了阀值）时，同样会自动增长。 HashMap是非线程安全的，只是用于单线程环境下,但是Hash Table是线程安全的（https://www.cnblogs.com/williamjie/p/9099141.html） 哈希表(key，value) 是把key值通过一个固定的算法即哈希函数转换成一个整型数字，然后就将该数字对数组长度进行取余，取
c++中的hash_map
qq_36276431的博客
05-14 5811
c++中的hash_maphash相关哈希函数哈希表c++中的hash_map 最近刷左神算法，hash_map经常被用到(hash_map的增删改查时间复杂度都能低至O(1))。但是左神用的都是java中的hash_map，苦于这个原因，只能自己研究一下C++中的hash_map。 参考：https://blog.csdn.net/u010025211/article/details/46653519?utm_medium=distribute.pc_relevant_bbs_down.none-task
编程参考 - C++使用hashmap
guoqx的专栏
01-19 3244
我们一般使用int和string类型，是有这个运算符的，如果使用其他的类型，就可能需要自己实现operator
TESTSYM.rar_Java编程_Visual_C++_
08-12
综合以上，"TESTSYM.rar"可能是一个教学资源，包含了一个使用Java和C++编程的实例，用户可以从中学习到两种语言的基本概念、语法以及如何在实际项目中结合使用。通过分析和修改"TESSYM.CPP"源代码，用户可以提升对这...
shiyan5.3.rar_Java编程_Visual_C++_
08-11
2. **C++标准库**：包括STL（Standard Template Library），如容器（vector、list、set等）、算法和迭代器，是C++编程的基础。 3. **WinAPI**：对于系统级别的编程，Visual C++可以直接使用Windows API，与操作系统...
Matching.rar_Java编程_Visual_C++_
08-11
3. **C++标准库**：虽然标题提到Java，但C++编程通常会用到STL（Standard Template Library），包括容器（如vector、list）、迭代器、算法等。 4. **编译与调试**：Visual C++提供了强大的编译器和调试工具，方便...
kcsjjj.rar_Java编程_Visual_C++_
08-11
【标题】"kcsjjj.rar_Java编程_Visual_C++_" 提供了一个学习Java编程和Visual C++集成开发环境的资源集合。这个压缩包很可能是为了帮助初学者或进阶者通过实际案例来深化对这两种编程语言的理解。下面我们将深入探讨...
75-points-quick-table.zip_Java编程_Visual_C++_
08-11
【标题】"75-points-quick-table.zip" 提供了一个快速参考指南，涵盖了Java编程和Visual C++的主要概念。这个压缩包旨在为开发者提供便捷的工具，帮助他们在编写代码时迅速查找关键信息。 【Java编程】是全球广泛...
C++ STL中哈希表 hash_map从头到尾详细介绍
热门推荐
susandebug
06-26 7万+
0 为什么需要hash_map 用过map吧？map提供一个很常用的功能，那就是提供key-value的存储和查找功能。例如，我要记录一个人名和相应的存储，而且随时增加，要快速查找和修改： 岳不群－华山派掌门人，人称君子剑 张三丰－武当掌门人，太极拳创始人 东方不败－第一高手，葵花宝典 ... 这些信息如果保存下来并不复杂，但是找起来比较麻烦。例如我要找"张三丰"的信
C++：Hash_map(哈希映射)
杨杨子江的博客
05-06 2720
猎豹网校的图 ###目录###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 如何...
C++ HashMap
Pan的博客
06-09 3160
C++ HashMap参考自boost库。 基本原理： 使用连续的内存块（数组）来存储数据，通过一个hash函数（即使每一个元素值都能形成固定的数组下标值），然后数组在相应的位置存起来，不能保证每个元素的关键值与hash函数值是一一对应的（可以有多个元素生成一样的hash值），这时候就需要解决冲突。 我们把数组叫做桶（因为数组把很多相似的元素存放在同一个位置）。流程： 查找元素 - 元素的关键值
C++ map和hashmap用法
qq_33216029的博客
07-19 6万+
1，map简介 map是STL的一个关联容器，它提供一对一的hash。 第一个可以称为关键字(key)，每个关键字只能在map中出现一次； 第二个可能称为该关键字的值(value)； map以模板(泛型)方式实现，可以存储任意类型的数据，包括使用者自定义的数据类型。Map主要用于资料一对一映射(one-to-one)的情況，map內部的实现自建一颗红黑树，这颗树具有对数据自动排序的功能。在map内...
C++ 中 HashMap 用法
最新发布
EveryDayOneHour的博客
03-21 653
include // 引入unordered_map头文件。// 创建一个unordered_map实例。// 查询HashMap中是否含有某个key。// 向HashMap中插入数据。// 删除HashMap中的元素。// 通过key查找value。// 遍历HashMap。// 清空HashMap。
c++实现HashMap
m0_63251896的博客
03-04 785
它有put(key, value)方法来添加键值对，get(key)方法来检索与键相关的值，remove(key)方法来删除键值对，size()方法来获取哈希映射的当前大小。它使用散列函数计算索引，然后遍历该索引处的链表，如果键已经存在，则更新该值，或者添加新的键值对。它使用散列函数计算索引，并在该索引处的链表中搜索键。vector的每个元素都是键值对的链表(std::list)。hash(const K& key):该方法使用std::hash函数计算给定键的哈希值。的参数，默认值为10。
hashmap C++实现分析
jiange_zh的博客
08-12 1万+
一、简介 Map 是 Key-Value 对映射的抽象接口，该映射不包括重复的键，即一个键对应一个值。 在HashMap中，其会根据hash算法来计算key-value的存储位置并进行快速存取。 本文介绍的C++ hashmap，是一个缓存用的hash_map，实现模仿自Java的HashMap，做了一些改造和精简。 特点：无读锁， 低写锁， 不删除只添加/更新， 桶不扩容， 按经验值初始...
【C++】c++中的map与hashmap
ystraw - Come on！！！
11-17 904
c++里面也有map和hashmap，分别适用于不同场景。 详细介绍可以参考：C++ STL中哈希表 hash_map从头到尾详细介绍 示例代码： #include<unordered_map> //由于编译器报错，把hash_map换为了unordered_map #include<iostream> using namespace std; int main(void) { unordered_map<unsigned int, unsigned int>hm;
C++泛型编程与STL入门：模板与容器比较
通过一个比较两个容器的例子展示了如何使用STL进行操作，并介绍了模板在泛型编程中的重要性。" 在C++编程中，STL（Standard Template Library，标准模板库）是一个强大的工具，它提供了高效的数据结构和算法。STL的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值