简单实现C++ hashmap(包含iterator)

最新推荐文章于 2024-05-13 14:25:08 发布
最新推荐文章于 2024-05-13 14:25:08 发布
阅读量968 收藏 4
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/choudan8888/article/details/119676041
版权

原理：原理很简单就是数组和链表，数组是用来散列的，链表主要用来存储的，链表的长度超过8个就转为红黑树（没实现）。

直接上代码：

#include<iostream>
#include<string>
#include<unordered_map>
using namespace std;

#define LOADFACTOR 0.75
#define	EXPANDFACTOR 2



template<class Key, class Value>
class Pair;
template<class Key, class Value>
class Node {
public:

	Node *next_;
	Key key_;
	Value value_;
	Node *pre_;

	Node(Key key, Value value)
	{
		next_ = NULL;
		key_ = key;
		value_ = value;
		pre_ = NULL;
	}

	~Node()
	{

	}

	Node& operator=(const Node& node)
	{
		key_ = node.key_;
		value_ = node.value_;
		next_ = node.next_;
		pre_ = node.pre_;

		return *this;
	}
};

template<class Key, class Value, class HashFun, class EqualKey>
class my_iterator;
template<class Key, class Value, class HashFun, class EqualKey>
class HashMap {
public:

	typedef my_iterator<Key, Value, HashFun, EqualKey> iterator;
	HashMap(int capacity)
		:capacity_(capacity), size_(0), hash_(), equal_()
	{
		table_ = new Node<Key, Value> *[capacity_];
		for (int i = 0; i < capacity_; i++)
		{
			table_[i] = NULL;
		}
	}

	~HashMap()
	{
		for (int i = 0; i < capacity_; i++)
		{
			Node<Key, Value> *CurNode = table_[i];
			while (CurNode)
			{
				Node<Key, Value>* tmp = CurNode;
				CurNode = CurNode->next_;
				delete tmp;
			}
		}
		delete []table_;
	}

	//返回hashmap当前存储的元素个数size
	int size()
	{
		return size_;
	}

	//返回hashmap的总容量
	int capacity()
	{
		return capacity_;
	}
	//判断容器是否为空
	bool empty()
	{
		return size_ == 0;
	}

	//插入
	bool insert(const Key& key, const Value& value)
	{
		if (size_ >= (capacity_ * LOADFACTOR))
		{
			rehash(capacity_ * EXPANDFACTOR);
		}
		int index = hash_(key) % capacity_;
		Node<Key, Value> *node = new Node<Key, Value>(key, value);
		Node<Key, Value> *tmp = table_[index];
		node->next_ = tmp;
		node->pre_ = NULL;
		if (tmp) {
			tmp->pre_ = node;
		}
		table_[index] = node;

		size_++;
		return true;
	}

	void rehash(int capacity)
	{
		Node<Key, Value> **tmp_table = new Node<Key, Value> *[capacity];
		for (int i = 0; i < capacity; i++)
		{
			tmp_table[i] = NULL;
		}

		for (int i = 0; i < capacity_; i++)
		{
			//size_ = 0;
			if (table_[i] != NULL)
			{
				Node<Key, Value> *tmp_Node = table_[i];
				while (tmp_Node)
				{
					insert1(tmp_Node->key_, tmp_Node->value_, tmp_table, capacity);
					tmp_Node = tmp_Node->next_;
				}
				delete tmp_Node;
			}
		}
		delete []table_;
		table_ = tmp_table;
		capacity_ = capacity;

	}

	void insert1(const Key& key, const Value& value, Node<Key, Value> **table, int capacity)
	{
		int index = hash_(key) % capacity;
		Node<Key, Value> * node = new Node<Key, Value>(key, value);
		node->next_ = table[index];
		table[index] = node;
	}


	//删除
	/*bool Delete(const Key& key)
	{
		//同过key值和hash函数确定存储在哪一个链表中，然后通过比对key值来确定删除的对象
		int index = hash_(key) % capacity_;
		Node<Key, Value> *node = table_[index];
		while (node)
		{
			if (node->key_ == key)
			{
				if (node->pre_ == NULL)
				{
					table_[index] = node->next_;
				}
				else
				{
					node->pre_->next_ = node->next_;
				}
				size_--;
				delete node;
				return true;
			}
			node = node->next_;
		}
		throw exception("删除失败！");
		return false;
	}*/
	
	
	//时间复杂度 O(1) 复杂版
	iterator erase2(const iterator& it)
	{
		int index = hash_(it.cur_Node_->key_) % capacity_;
		Node<Key, Value> *tmp = it.cur_Node_->next_;
		if (it.cur_Node_->pre_ == NULL && it.cur_Node_->next_ != NULL)
		{
			Node<Key, Value> *tmp = it.cur_Node_->next_;
			tmp->pre_ = NULL;
			table_[index] = tmp;
			delete it.cur_Node_;
			size_--;
			return iterator(this, tmp, table_);
		}
		else if (it.cur_Node_->pre_ == NULL && it.cur_Node_->next_ == NULL)
		{
			delete it.cur_Node_;
			table_[index] = NULL;
			for (int i = index + 1; i < capacity_; i++)
			{
				if (table_[i] != NULL)
				{
					Node<Key, Value> *tmp = table_[i];
					size_--;
					return iterator(this, tmp, table_);
				}
			}
			size_--;
			return iterator(this, NULL, table_);
		}
		else if (it.cur_Node_->pre_ != NULL && it.cur_Node_->next_ != NULL)
		{
			it.cur_Node_->pre_->next_ = it.cur_Node_->next_;
			it.cur_Node_->next_->pre_ = it.cur_Node_->pre_;
			Node<Key, Value> *tmp = it.cur_Node_->next_;
			delete it.cur_Node_;
			size_--;
			return iterator(this, tmp, table_);
		}
		else if (it.cur_Node_->pre_ != NULL && it.cur_Node_->next_ == NULL)
		{
			it.cur_Node_->pre_->next_ = NULL;
			delete it.cur_Node_;
			for (int i = index + 1; i < capacity_; i++)
			{
				if (table_[i] != NULL)
				{
					Node<Key, Value> *tmp = table_[i];
					size_--;
					return iterator(this, tmp, table_);
				}
			}
			size_--;
			return iterator(this, NULL, table_);
		}
		return iterator(this, NULL, table_);
	}

	// 时间复杂度O(1) 简化版
	iterator erase1(const iterator& it)
	{
		int index = hash_(it.cur_Node_->key_) % capacity_;
		if (it.cur_Node_->pre_ == nullptr)
			table_[index] = it.cur_Node_->next_;
		else
			it.cur_Node_->pre_->next_ = it.cur_Node_->next_;

		--size_;
		if (it.cur_Node_->next_) {
			it.cur_Node_->next_->pre_ = it.cur_Node_->pre_;
			auto * tmp = it.cur_Node_->next_;

			delete it.cur_Node_;
			return iterator(this, tmp, table_);
		}
		else
		{
			delete it.cur_Node_;

			for (int i = index + 1; i < capacity_; i++)
			{
				if (table_[i] != NULL)
				{
					Node<Key, Value> *tmp = table_[i];
					return iterator(this, tmp, table_);
				}
			}
			return end();
		}
	}

	//时间复杂度O(n)
	iterator erase(const iterator& it)
	{
		int index = hash_(it.cur_Node_->key_) % capacity_;
		Node<Key, Value> *node = table_[index];
		
		while (node)
		{	Node<Key, Value> *tmp = node->next_;
			if (node->key_ == it.cur_Node_->key_)
			{
				if (node->pre_ == NULL && tmp != NULL)
				{
					tmp = node->next_;
					tmp->pre_ = NULL;
					table_[index] = tmp;
					delete node;
					size_--;
					return iterator(this, tmp, table_);
				}
				else if (node->pre_ == NULL && tmp == NULL)
				{
					delete node;
					table_[index] = NULL;
					
					for (int i = index + 1; i < capacity_; i++)
					{
						if (table_[i] != NULL)
						{
							tmp = table_[i];
							size_--;	
							return iterator(this, tmp, table_);
						}
					}
					size_--;
					return iterator(this, tmp, table_);
				}
				else if(node->pre_ != NULL && tmp != NULL)
				{
					node->pre_->next_ = tmp;
					node->next_->pre_ = node->pre_;
					delete node;
					size_--;
					return iterator(this, tmp, table_);
				}	
				else if (node->pre_ != NULL && tmp == NULL)
				{
					node->pre_->next_ = NULL;
					delete node;
					for (int i = index + 1; i < capacity_; i++)
					{
						if (table_[i] != NULL)
						{
							tmp = table_[i];
							size_--;
							return iterator(this, tmp, table_);
						}
					}
				}
			}
			node = node->next_;
		}
		return iterator(this, NULL, table_);
	}

	//查找
	/*Value& find(const Key& key)
	{
		int index = hash_(key) % capacity_;
		if (table_[index] == NULL)
		{
			throw exception("没有找到！");
		}
		else
		{
			Node<Key, Value> *node = table_[index];
			while (node)
			{
				if (node->key_ == key)
				{
					return node->value_;
				}
				node = node->next_;
			}
			throw exception("没有找到！");
		}
	}*/

	iterator find1(const Key& key)
	{
		int index = hash_(key) % capacity_;
		Node<Key, Value> *node = table_[index];
		while (node)
		{
			if (node->key_ == key)
			{
				return iterator(this, node, table_);
			}
			node = node->next_;
		}
		return iterator(this, NULL, table_);
	}

	//rehash 当前容器中存储的元素已经达到的阀值，就需要将容器的容量扩大为原来的两倍
	/*void rehash(int capacity)
	{
		Node<Key, Value> **tmp_table = new Node<Key, Value> *[capacity];
		for (int i = 0; i < capacity; i++)
		{
			tmp_table[i] = NULL;
		}

		for (int i = 0; i < capacity_; i++)
		{
			if (table_[i] != NULL)
			{
				Node<Key, Value> *tmp_Node = table_[i];
				while (tmp_Node)
				{
					insert1(tmp_Node, tmp_table, capacity);
					tmp_Node = tmp_Node->next_;
				}
				delete tmp_Node;
			}
		}
		delete []table_;
		table_ = tmp_table;
		capacity_ = capacity;
	}

	void insert1(Node<Key, Value> *node, Node<Key, Value> **table, int capacity)
	{
		int index = hash_(node->key_) % capacity;
		node->next_ = table[index];
		node->pre_ = NULL;
		table[index] = node;
	}*/

	//reserve
	void reserve(int capacity)
	{
		rehash(capacity);
	}

	//begin
	iterator begin()
	{
		for (int i = 0; i < capacity_; i++)
		{
			Node<Key, Value> *node = table_[i];
			if (node != NULL)
			{
				return iterator(this, node, table_);
			}
		}
		return iterator(this, NULL, table_);
	}

	//end
	iterator end()
	{
		return iterator(this, NULL, table_);
	}

	Value& operator[](const Key& key)
	{
;
		if (find1(key).cur_Node_ != NULL)
		{
			return (*find1(key));
		}
		else
		{
			//Value value = new Value();
			insert(key,Value());
			return (*find1(key));
		}
	}

	friend class my_iterator<Key, Value, HashFun, EqualKey>;
private:
	HashFun hash_;                //hash函数
	EqualKey equal_;				 //比较函数
	Node<Key, Value> **table_;    //创建的哈希表
	int size_;					//hashmap存储元素的个数
	int capacity_;				//hashmap容量
};


//实现迭代器
template<class Key, class Value>
class Node;
template<class Key, class Value, class HashFun, class EqualKey>
class HashMap;
template<class Key, class Value, class HashFun, class EqualKey>
class my_iterator
{
public:
	my_iterator(HashMap<Key, Value, HashFun, EqualKey> *hashmap, Node<Key, Value> *node, Node<Key, Value> **table)
		:hashmap_(hashmap), cur_Node_(node), table_(table)
	{

	}

	~my_iterator()
	{

	}

	Value& operator*()const
	{
		return cur_Node_->value_;
	}

	Value* operator->()const
	{
		return &(operator*());
	}

	bool operator ==(const my_iterator& it)
	{
		return cur_Node_ == it.cur_Node_;
	}

	bool operator!=(const my_iterator& it)
	{
		return cur_Node_ != it.cur_Node_;
	}

	my_iterator& operator++()
	{
		if (cur_Node_->next_ != NULL)
		{
			cur_Node_ = cur_Node_->next_;
		}
		else
		{
			int CapacityTmp = hashmap_->capacity_;
			int index = hashmap_->hash_(cur_Node_->key_) % CapacityTmp;
			int tmpindex = index + 1;

			Node<Key, Value> * tmp = NULL;
			while (tmpindex < hashmap_->capacity_) 
			{
				tmp = table_[tmpindex];
				if (tmp == NULL)
				{
					++tmpindex;
				}
				else
				{
					break;
				}
			}
			if (tmp != NULL)
			{
				cur_Node_ = tmp;
				index = tmpindex;
				return *this;
			}
			else
			{
				hashmap_ = hashmap_->end().hashmap_;
				cur_Node_ = NULL;
				table_ = hashmap_->end().table_;
				return *this;
			}
		}
		return *this;
	}

	my_iterator& operator--()
	{
		if (cur_Node_->pre_ != NULL)
		{
			cur_Node_ = cur_Node_->pre_;
		}
		if (!cur_Node_)
		{
			int  index = hashmap_->hash_(cur_Node_->key_) % hashmap_->capacity_;
			for (int i = index - 1; i >= 0; i--)
			{
				if (hashmap_->table_[index] != NULL)
				{
					cur_Node_ = hashmap_->table_[index];
				}
			}
		}
		return *this;
	}

	my_iterator& operator--(int)
	{
		my_iterator tmp = *this;
		return --*this;
	}

	my_iterator& operator++(int)
	{
		my_iterator tmp = *this;
		return ++*this;
	}

	friend class Node<Key, Value>;
	friend class HashMap<Key, Value, HashFun, EqualKey>;

private:
	HashMap<Key, Value, HashFun, EqualKey> *hashmap_;
	Node<Key, Value> *cur_Node_;      //当前所指的结点
	Node<Key, Value> **table_;		//哈希表
};

//hash函数
class HashFun
{
public:
	int operator()(const string& key)
	{
		int hash = 0;
		for (int i = 0; i < key.length(); i++)
		{
			hash = (hash << 7) ^ key[i];
		}
		return (hash & 0x7FFFFFFF);
	}
};

//比较函数
class EqualKey
{
public:
	bool operator()(const string& s1, const string& s2)
	{
		if (s1.compare(s2) == 0)
		{
			return true;
		}
		else
		{
			false;
		}
	}
};

以上是完全的代码，下面是测试代码

int main()
{
	/*
	try {
	HashMap<string, string, HashFun, EqualKey> hashmap(16);

	hashmap.insert("hello", "world");
	hashmap.insert("1", "zhang");
	hashmap.insert("1", "cool");
	hashmap.insert("2", "wang");
	hashmap.insert("3", "li");
	hashmap.insert("4", "haha");

	cout << "当前hashmap的容量是：" << hashmap.capacity() << endl;
	cout << "插入5个元素之后：" << endl;
	cout << "key值为hello的元素：" << hashmap.find("hello") << endl;
	cout << "key值为1的元素：" << hashmap.find("1") << endl;
	cout << "key值为2的元素：" << hashmap.find("2") << endl;
	cout << "key值为3的元素：" << hashmap.find("3") << endl;
	cout << "key值为4的元素：" << hashmap.find("4") << endl;
	hashmap["4"] = "mark";
	cout << "key值为4的元素：" << hashmap.find("4") << endl;
	cout << "当前hashmapz中存储的元素个数是：" << hashmap.size() << endl;
	cout << "当前hashmap的容量是：" << hashmap.capacity() << endl;
	hashmap.Delete("2");
	cout << "删除key值为2的元素后查找key为2的值：";
	cout << hashmap.find("2") << endl;

	}
	catch (exception& e)
	{
	cout << e.what() << endl;
	}

	cout << "*********************scend***************************" << endl;
	try {
	HashMap<string, int, HashFun, EqualKey> hashmap1(16);

	hashmap1.insert("hello", 100);
	hashmap1.insert("0", 1);
	hashmap1.insert("1", 2);
	hashmap1.insert("2", 3);
	hashmap1.insert("3", 4);
	hashmap1.insert("4", 5);
	cout << "当前hashmap的容量是：" << hashmap1.capacity() << endl;
	cout << "插入5个元素之后：" << endl;
	//cout << "key值为hello的元素：" << hashmap1.find("hello") << endl;
	cout << "key值为1的元素：" << hashmap1.find("1") << endl;
	cout << "key值为2的元素：" << hashmap1.find("2") << endl;
	cout << "key值为3的元素：" << hashmap1.find("3") << endl;
	cout << "key值为4的元素：" << hashmap1.find("4") << endl;
	cout << "key值为0的元素：" << hashmap1.find("0") << endl;
	hashmap1["4"] = 40;
	cout << "key值为4的元素：" << hashmap1.find("4") << endl;
	cout << "当前hashmapz中存储的元素个数是：" << hashmap1.size() << endl;
	cout << "当前hashmap的容量是：" << hashmap1.capacity() << endl;
	hashmap1.Delete("hello");
	cout << "删除key值为hello的元素后：";
	cout << "此时容器中的元素个数是：" << hashmap1.size() << endl;

	cout << hashmap1.find("hello") << endl;

	}
	catch (exception& e)
	{
	cout << e.what() << endl;
	}
	*/
	/*
	try {
	HashMap<string, string, HashFun, EqualKey> hashmap(8);

	hashmap.insert("hello", "hello");
	hashmap.insert("9", "world");
	hashmap.insert("1", "zhang");
	hashmap.insert("5", "cool");
	hashmap.insert("8", "wo");
	hashmap.insert("7", "7");
	hashmap.insert("2", "wang");
	cout << "插入七个元素后hashmap的容量是：" << hashmap.capacity() << endl;
	cout << "当前hashmapz中存储的元素个数是：" << hashmap.size() << endl;
	hashmap.insert("3", "li");
	hashmap.insert("4", "haha");
	hashmap.insert("10", "nihao");
	cout << "在插入三个元素后hashmap的容量是：" << hashmap.capacity() << endl;
	cout << "当前hashmap中存储的元素个数是：" << hashmap.size() << endl;


	cout << "key值为1的元素：" << hashmap.find("1") << endl;
	cout << "key值为2的元素：" << hashmap.find("2") << endl;
	cout << "key值为3的元素：" << hashmap.find("3") << endl;
	cout << "key值为4的元素：" << hashmap.find("4") << endl;
	cout << "key值为5的元素：" << hashmap.find("5") << endl;
	cout << "key值为10的元素：" << hashmap.find("10") << endl;
	cout << "key值为8的元素：" << hashmap.find("8") << endl;
	cout << "key值为9的元素：" << hashmap.find("9") << endl;
	cout << "key值为hello的元素：" << hashmap.find("hello") << endl;
	cout << "key值为7的元素：" << hashmap.find("7") << endl;


	cout << "****************************将容器扩容为8************************************" << endl;
	hashmap.reserve(4);
	cout << "key值为1的元素：" << hashmap.find("1") << endl;
	cout << "key值为2的元素：" << hashmap.find("2") << endl;
	cout << "key值为3的元素：" << hashmap.find("3") << endl;
	cout << "key值为4的元素：" << hashmap.find("4") << endl;
	cout << "key值为5的元素：" << hashmap.find("5") << endl;
	cout << "key值为10的元素：" << hashmap.find("10") << endl;
	cout << "key值为8的元素：" << hashmap.find("8") << endl;
	cout << "key值为9的元素：" << hashmap.find("9") << endl;
	cout << "key值为hello的元素：" << hashmap.find("hello") << endl;
	cout << "key值为7的元素：" << hashmap.find("7") << endl;
	cout << "此时容器是否为空：" << hashmap.empty() << endl;
	cout << "当前hashmap中存储的元素个数是：" << hashmap.size() << endl;

	cout << "当前hashmap的容量是：" << hashmap.capacity() << endl;
	cout << "key值为9的元素：" << hashmap.find("9") << endl;
	hashmap.Delete("7");
	//cout << "删除key值为7的元素后查找key值为7的元素的结果是：" << hashmap.find("7") << endl;

	}
	catch (exception& e)
	{
	cout << e.what() << endl;
	}*/
/*
	try
	{
		
		HashMap<string, string, HashFun, EqualKey> hashmap(4);

		hashmap.insert("hello", "hello");
		hashmap.insert("9", "world");
		hashmap.insert("1", "zhang");
		hashmap.insert("5", "cool");
		hashmap.insert("8", "wo");
		hashmap.insert("7", "7");
		hashmap.insert("2", "wang");
		cout << "通过迭代器打印hashmap中的元素：";
		HashMap<string, string, HashFun, EqualKey>::iterator it = hashmap.begin();
		for (it; it != hashmap.end(); ++it)
		{
			cout << *it << "  ";
		}
		cout << endl;
	
		cout << "插入七个元素后hashmap的容量是：" << hashmap.capacity() << endl;
		cout << "当前hashmapz中存储的元素个数是：" << hashmap.size() << endl;
		hashmap.insert("3", "li");
		hashmap.insert("4", "haha");
		hashmap.insert("10", "nihao");
		cout << "在插入三个元素后hashmap的容量是：" << hashmap.capacity() << endl;
		cout << "当前hashmap中存储的元素个数是：" << hashmap.size() << endl;
		//cout << "key值为20的默认value是：" << hashmap["20"] << endl;
		
		//hashmap.Delete("hello");
		
		cout << "通过迭代器打印hashmap中的元素：";
	   it = hashmap.begin();
		for (it; it != hashmap.end(); ++it)
		{
			cout << *it << "  ";
		}
		cout << endl;
		it = hashmap.begin();

		hashmap.erase1(it);
		cout << "erase后" << endl;
		cout << "通过迭代器打印hashmap中的元素：";
		it = hashmap.begin();
		
		for (it; it != hashmap.end(); it++)
		{
			cout << *it << "  ";
		}
		cout << endl;
		it = hashmap.begin();
		for (int i = 0; i < 5; i++)
		{
			it++;
		}
		cout << "--it的值是：" << *(--it) << endl;

		it = hashmap.begin();
		for (int i = 0; i < 5; i++)
		{
			it++;
		}
		cout << "it--的值是：" << *(it--) << endl;
		
		//cout << "key值为3的元素是：" << hashmap.find("3") << endl;
		cout << "key值为4的元素是：" << *(hashmap.find1("4")) << endl;
		//cout << "key值为hello的元素是：" << *(hashmap.find1("hello")) << endl;
		cout << "当前hashmap中存储的元素个数是：" << hashmap.size() << endl;
		//cout << hashmap["20"] << endl;;
	
		it = hashmap.begin();
		
		
		for (it; it != hashmap.end();)
		{
			it = hashmap.erase2(it);
		}
		cout << "当前hashmap中存储的元素个数是：" << hashmap.size() << endl;
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}*/


	HashMap<string, string, HashFun, EqualKey> hashmap(1);

	hashmap.insert("hello", "hello");
	hashmap.insert("9", "world");
	hashmap.insert("1", "zhang");
	hashmap.insert("5", "cool");
	cout << "通过迭代器打印：";
	HashMap<string, string, HashFun, EqualKey>::iterator it = hashmap.begin();
	for (it; it != hashmap.end(); it++)
	{
		cout << *it << " ";
	}

	
	return 0;
}
choudan8888
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ HashMap
有趣的人
11-08 4997
HashMap map用法总结 hashmap简单介绍 #include< map> 数据结构 基于哈希表，以空间换时间，是存储key-value键值对的集合。 基本原理：使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数，也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标，hash值）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键...
详细解说STL hash_map系列
fisher_jiang的专栏
04-01 2889
0 为什么需要hash_map 用过map吧？map提供一个很常用的功能，那就是提供key-value的存储和查找功能。例如，我要记录一个人名和相应的存储，而且随时增加，要快速查找和修改： 岳不群－华山派掌门人，人称君子剑张三丰－武当掌门人，太极拳创始人东方不败－第一高手，葵花宝典...这些信息如果保存下来并不复杂，但是找起来比较麻烦。例如我要找"张三丰"的信息，最傻的方法就是取得所有的记录，然后
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 5815
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++实现哈希算法
最新发布
weixin_73570479的博客
05-13 2497
哈希算法，也称为散列算法，是一种从任意长度的输入数据创建固定大小输出的方法，这种输出通常被称为“哈希值”、“散列值”或简单地“哈希”。在计算机科学中，哈希算法主要用于快速数据查找和数据结构中的高效数据管理，如哈希表。哈希也是加密和数据完整性验证的基础。哈希算法通过一个称为哈希函数的数学过程来运作。这个函数接受输入（称为“预映射值”）并返回一个通常较短、固定长度的哈希值。这个哈希值在理想情况下为每个不同的输入值提供一个唯一的标识（尽管在实际中这并不总是可能的）。
编程参考 - C++使用hashmap
guoqx的专栏
01-19 3249
我们一般使用int和string类型，是有这个运算符的，如果使用其他的类型，就可能需要自己实现operator
C++ STL中哈希表 hash_map从头到尾详细介绍
热门推荐
susandebug
06-26 7万+
0 为什么需要hash_map 用过map吧？map提供一个很常用的功能，那就是提供key-value的存储和查找功能。例如，我要记录一个人名和相应的存储，而且随时增加，要快速查找和修改： 岳不群－华山派掌门人，人称君子剑 张三丰－武当掌门人，太极拳创始人 东方不败－第一高手，葵花宝典 ... 这些信息如果保存下来并不复杂，但是找起来比较麻烦。例如我要找"张三丰"的信
hashmap_cis106L
03-30
- `Hashmap.cpp`：实现哈希图的类，包括上述的基本操作。 - `main.cpp`：测试代码，用于验证哈希图的正确性和性能。 哈希图的效率主要取决于哈希函数的质量和冲突解决策略。好的哈希函数可以减少冲突，提高查找效率...
java&c++概念及面试常问问题及解答
11-01
与Java不同的是，C++的迭代器有多种类型，如input_iterator、output_iterator、forward_iterator、bidirectional_iterator和random_access_iterator，分别对应不同的操作能力。 在面试中，了解并能熟练运用这些基本...
C++多范型设计(pdg)
07-10
C++的STL（Standard Template Library，标准模板库）就是多范型设计的一个典型应用，包括容器（如vector、list、map等）、算法（如sort、find、transform等）和迭代器（Iterator）。这些组件都是基于模板实现的，...
Collections源码java-designpatterns:设计模式实现的集合。目前有Java和C++源代码
05-19
这些实现可能包括对原有集合类的扩展，或者完全独立的集合实现，它们可以帮助开发者更好地理解和应用设计模式。 总结来说，Java Collections框架与设计模式的结合，不仅提高了代码的可读性和可维护性，还增强了其...
中兴试卷、C++和java部分
04-05
3. **集合框架**：ArrayList、LinkedList、HashSet、HashMap等，以及Collections和Iterator接口。 4. **异常处理**：异常类层次，如何抛出和捕获异常。 5. **IO流**：包括文件I/O、网络I/O，以及NIO（非阻塞I/O）。 ...
C++：Hash_map(哈希映射)
杨杨子江的博客
05-06 2741
猎豹网校的图 ###目录###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
m0_63251896的博客
03-04 790
它有put(key, value)方法来添加键值对，get(key)方法来检索与键相关的值，remove(key)方法来删除键值对，size()方法来获取哈希映射的当前大小。它使用散列函数计算索引，然后遍历该索引处的链表，如果键已经存在，则更新该值，或者添加新的键值对。它使用散列函数计算索引，并在该索引处的链表中搜索键。vector的每个元素都是键值对的链表(std::list)。hash(const K& key):该方法使用std::hash函数计算给定键的哈希值。的参数，默认值为10。
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
专注金融量化投资交易 策略开发
04-17 469
C++经典hash是指使用哈希表实现的一种数据结构，可以快速地存储、查找和删除数据。在C++中，可以使用STL中的unordered_map或者手写哈希表来实现。如果发生哈希冲突，就将新的节点插入到链表的末尾。在查找时，遍历链表查找对应的节点。在删除时，将链表中对应的节点删除即可。哈希冲突：当两个不同的关键字被映射到同一个哈希表索引位置时，就会发生哈希冲突。解决哈希冲突的方法有开放地址法、链表法、再哈希法等。哈希函数：将关键字映射到哈希表中的索引位置的函数。常见的哈希函数包括取模法、乘法哈希、MD5等。
hashmap C++实现分析
jiange_zh的博客
08-12 1万+
一、简介 Map 是 Key-Value 对映射的抽象接口，该映射不包括重复的键，即一个键对应一个值。 在HashMap中，其会根据hash算法来计算key-value的存储位置并进行快速存取。 本文介绍的C++ hashmap，是一个缓存用的hash_map，实现模仿自Java的HashMap，做了一些改造和精简。 特点：无读锁， 低写锁， 不删除只添加/更新， 桶不扩容， 按经验值初始...
C++ 中 HashMap 用法
EveryDayOneHour的博客
03-21 660
include // 引入unordered_map头文件。// 创建一个unordered_map实例。// 查询HashMap中是否含有某个key。// 向HashMap中插入数据。// 删除HashMap中的元素。// 通过key查找value。// 遍历HashMap。// 清空HashMap。
hashmap的C++实现
QtCompany的博客
02-15 939
按照hashmap的基本原理用C++实现了简单的基本功能，复杂的实现参考C++库的源码，C++最新的标准库里已经有以下四种基于hashtable的容器： unordered_set (C++11) unordered_multiset (C++11) unordered_map (C++11) unordered_multimap (C++11)。
c++hashmap
07-30
在C++中，可以使用unordered_map来实现哈希表的功能。如果你的C++版本低于C++11，你可能会遇到错误：“unordered_map was not declared in this scope”。这时候你需要将头文件改为#include<tr1/unordered_map>，并使用命名空间std::tr1。[1] 在unordered_map中，可以使用swap函数来交换两个哈希表的键值对，例如：Hashmap1.swap(Hashmap2)或swap(Hashmap1, Hashmap2)。[2] 对于unordered_map的遍历，有三种常见的方法。第一种是使用范围for循环，例如：for(auto p : Hashmap)，其中p.first表示键，p.second表示值。第二种是使用迭代器，例如：for(auto it=Hashmap.begin(); it!=Hashmap.end(); it++)，其中it->first表示键，it->second表示值。第三种是使用while循环和迭代器，例如：unordered_map<int, int>::iterator it = Hashmap.begin(); while(it != Hashmap.end())，其中it->first表示键，it->second表示值。[2] 需要注意的是，C++标准库中的hash_map已经被unordered_map取代，所以推荐使用unordered_map来实现哈希表的功能。[3]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值