哈希表及模拟实现

已于 2025-01-12 17:11:09 修改
阅读量882 收藏 15
点赞数 21
CC 4.0 BY-SA版权
分类专栏： C++ 文章标签： c++ 开发语言
于 2025-01-11 21:38:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76197086/article/details/145016845

目录

一、哈希表的概念 

二、模拟实现哈希表

1.开放地址法

(1)哈希表的数据加上状态标志

(2)哈希表扩容：载荷因子

(3)哈希函数：不同数据类型转换为整型

(4)完整代码

2.链地址法（哈希桶）

(1)哈希表扩容：载荷因子

(2)完整代码

一、哈希表的概念 

哈希表本质是一个数组（数组中的每个位置称为槽或桶），数据检索十分高效，它利用哈希函数将键值对映射到哈希表中的特定位置，哈希函数可以计算键的哈希值，从而确定该键值对在哈希表中的存储位置（理想的哈希函数要尽可能均匀地分布键值对）。

冲突：

例如存在键值对<1, 'A'>、<100001, 'B'>、<999, 'C'>、<345, 'D'>，哈希函数为h(key)=key%10，所以<1, 'A'>存储在1位置，<100001, 'B'>存储在1位置，<999, 'C'>存储在9位置，<345, 'D'>存储在5位置，<1, 'A'>和<100001, 'B'>发生冲突。

冲突处理：

冲突处理的方法有两种：开放地址法和链地址法

  • 开放地址法：当发生冲突时，寻找哈希表的下一个空位置，将键值对存储进其中（寻找哈希表下一个空位置的常见方法又有三种：线性探测、二次探测、双哈希）。开放地址法会导致其他键值对原本的位置被占用，又需要重新寻找下一个空位置。
  • 链地址法：哈希表中的每一个位置是一个链表（或者其他动态数据结构），发生冲突的键值对都会被存储到该链表中。如果要查找键值对，先要找到哈希表中链表的位置，再在链表中搜索

二、模拟实现哈希表

1.开放地址法

开放地址法在存储键值对时，首先会根据键值对的键计算哈希值，确定键值对所在槽，如果该槽已被其他数据所占，则向后遍历哈希寻找空槽，再将数据存储到空槽中。

(1)哈希表的数据加上状态标志

假设开放地址法使用的是线性探测解决冲突，当键值对原本的槽被占用时，会向后遍历寻找最近的一个空槽。这就说明当哈希表中未发生数据删除时，两个冲突数据之间一定是没有空槽的。所以开放地址法的查找函数结束条件是查找到空槽。

问题出现：当哈希表中数据被删除时，且恰巧删除的是某两个冲突数据位置之间的数据，那么此时的查找函数就会出问题，因为两个冲突数据之间存在了空槽，就会导致无法查找到后一个数据。

问题解决：哈希表的数据不仅存储的键值对，还要存储一个状态标志，表示该槽为空，还是数据被删除，还是不为空。使用结构体封装键值对和状态标志作为哈希表的存储元素。这样查找函数查找到空槽就分为两种：槽中数据被删除、槽为空，只有当槽为空时才为结束条件

//状态标志
enum State {
	EMPTY,//槽为空
	EXIST,//槽不为空
	DELETE//槽中数据被删除
};
//哈希表数据元素
template<class K,class V>
struct HashData {
	std::pair<K, V> _kv;//键值对
	State _state = EMPTY;//状态标志
};
//哈希表
template<class K,class V>
class HashTable {
private:
	std::vector<HashData<K, V>> _tables;//哈希表
	size_t _n = 0;//哈希表中已经存储的元素个数
};
(2)哈希表扩容：载荷因子

载荷因子=哈希表已存元素个数/哈希表总容量

哈希表中存储的元素越多，冲突率就越高，哈希表查找效率就越低

即载荷因子越大，冲突率越高，哈希表效率越低，空间利用率越高；

    载荷因子越小，冲突率越小，哈希表效率越高，空间利用率越低。

因此不能使哈希表满，而且必须在哈希表满之前就扩容。为此我们可以根据载荷因子设定一个界限，载荷因子既不能太大，也不能太小。例如当载荷因子大于0.7时就扩容。

扩容方法：

哈希表的扩容不仅要将哈希表长度变大，还要将哈希表中的数据重新映射

创建一个新对象，将新对象中的哈希表扩容为旧哈希表的二倍，再复用insert函数将数据重新映射到新对象的哈希表中，最后将新对象的哈希表赋值给旧对象。

（下述insert函数还未完善，没有防止数据冗余）

//构造函数
HashTable()
{
	_tables.resize(10);//哈希表容量初始化为10，避免计算载荷因子时除数为0
}
//插入函数
void insert(const std::pair<K, V>& kv)
{
	//扩容
	if (_n / (float)_tables.size() >= 0.7)
	{
		HashTable<K, V> newHT;//新对象
		newsize = 2 * _tables.size();//新容量（2倍扩容）
		newHT._tables.resize(newsize);
		//重新映射
		for (int i = 0; i < _tables.size(); ++i)
		{
			if (_tables[i]._state == EXIST)
				newHT.insert(_tables[i]._kv);
		}
		_tables = newHT._tables;
		
	}
	//计算哈希值
	int hashi = kv.first % _tables.size();
	//线性探测：寻找空槽
	while (_tables[hashi]._state == EXIST)
	{
		++hashi;
		hashi = hashi % _tables.size();//哈希表的线性探测是循环的，查找到哈希表末尾后会跳转到哈希表头部继续查找
	}
	//插入数据
	_tables[hashi]._kv = kv;
	_tables[hashi]._state = EXIST;
    _n++;
}
(3)哈希函数：不同数据类型转换为整型

哈希函数为key值%哈希表大小，但是如果key是string等其他类型，无法做取模运算，就需要先将key转换为整型再取模。

key的可能类型有许多，因此需要进行泛型编程：设计仿函数，对于可以直接强转为整型的数据使用默认的仿函数，对于其他不能直接强转为整型的数据需要自己提供仿函数将数据转换为整型。

例如string类型，可以采用直接相加法（将所有的字符的ASCII码相加得到整数）、位运算法（将每个字符的ASCII码左移后再相加）。

此处介绍的是BKDRHash算法：遍历字符串，当前哈希值乘131再加上当前字符的ASCII码值。

对比unordered_set和unordered_set发现，这两个容器对于key为string类型时并没有需要自己提供哈希函数，这是因为unordered_set和unordered_set源码中对string类型进行了模板特化。所以我们在模拟实现时也是用模板特化：特化string，当key类型是int、float等可以直接强转为整型的数据就使用默认的哈希函数，如果是string类型就使用特化的哈希函数，如果是其他类型就需要我们自己提供哈希函数将key值转换为整型数据。

//默认哈希函数（仿函数），针对可以直接强转为整型的类型
template<class K>
struct HashFunc {
	size_t operator()(const K& key)
	{
		return size_t(key);
	}
};
//默认哈希函数对string类型进行模板特化
template<>
struct HashFunc<std::string> {
	size_t operator()(const std::string& key)
	{
		size_t hashi = 0;
		for (auto& ch : key)
		{
			hashi *= 131;
			hashi += ch;
		}
		return hashi;
	}
};
//哈希表
template<class K, class V, class Hash = HashFunc<K>>
class HashTable {
private:
	std::vector<HashData<K, V>> _tables;//哈希表
	size_t _n = 0;//哈希表中已经存储的元素个数
......
......
(4)完整代码
#include <iostream>
#include <vector>
#include <string>
//状态标志
enum State {
	EMPTY,//槽为空
	EXIST,//槽不为空
	DELETE//槽中数据被删除
};
//哈希表数据元素
template<class K, class V>
struct HashData {
	std::pair<K, V> _kv;//键值对
	State _state = EMPTY;//状态标志
};
//默认哈希函数（仿函数），针对可以直接强转为整型的类型
template<class K>
struct HashFunc {
	size_t operator()(const K& key)
	{
		return size_t(key);
	}
};
//默认哈希函数对string类型进行模板特化
template<>
struct HashFunc<std::string> {
	size_t operator()(const std::string& key)
	{
		size_t hashi = 0;
		for (auto& ch : key)
		{
			hashi *= 131;
			hashi += ch;
		}
		return hashi;
	}
};
//哈希表
template<class K, class V, class Hash = HashFunc<K>>
class HashTable {
private:
	std::vector<HashData<K, V>> _tables;//哈希表
	size_t _n = 0;//哈希表中已经存储的元素个数
public:
	//构造函数
	HashTable()
	{
		_tables.resize(10);//哈希表容量初始化为10，避免计算载荷因子时除数为0
	}
	//插入函数
	bool Insert(const std::pair<K, V>& kv)
	{
		//防止数据冗余
		if (Find(kv.first))
			return false;
		//扩容
		if (_n / (float)_tables.size() >= 0.7)
		{
			HashTable<K, V> newHT;//新对象
			size_t newsize = 2 * _tables.size();//新容量（2倍扩容）
			newHT._tables.resize(newsize);
			//重新映射
			for (int i = 0; i < _tables.size(); ++i)
			{
				if (_tables[i]._state == EXIST)
					newHT.Insert(_tables[i]._kv);
			}
			//新表赋值给旧表
			_tables = newHT._tables;

		}
		//计算哈希值
		Hash hs;
		size_t hashi = hs(kv.first) % _tables.size();
		//线性探测：寻找空槽（DELETE和EMPTY都行）
		while (_tables[hashi]._state == EXIST)
		{
			++hashi;
			hashi = hashi % _tables.size();//哈希表的线性探测是循环的，查找到哈希表末尾后会跳转到哈希表头部继续查找
		}
		//插入数据
		_tables[hashi]._kv = kv;
		_tables[hashi]._state = EXIST;
		_n++;
		return true;
	}
	//查找函数
	HashData<K, V>* Find(const K& key)
	{
		//计算哈希值
		Hash hs;
		size_t hashi = hs(key) % _tables.size();
		//线性探测：找到空槽结束（只有EMPTY才行）
		while (_tables[hashi]._state != EMPTY)
		{
			if (_tables[hashi]._state != DELETE)
			{
				if (_tables[hashi]._kv.first == key)
					return &_tables[hashi];//查找成功
			}
			++hashi;
			hashi = hashi % _tables.size();
		}
		//未查找到
		return nullptr;
	}
	//删除函数
	bool Erase(const K& key)
	{
		HashData<K, V>* ret = Find(key);
		if (ret == nullptr)
			return false;
		else
		{
			ret->_state = DELETE;
			--_n;
			return true;
		}
	}
};
void test()
{
	HashTable<std::string, std::string> ht;
	ht.Insert({ "5","5"}); ht.Insert({"10","10"}); ht.Insert({"8", "8"});
	std::cout << ht.Find("8") << std::endl;
	std::cout << ht.Find("5") << std::endl;
	std::cout << ht.Find("20") << std::endl;
	ht.Erase("8");
	std::cout << ht.Find("8") << std::endl;
	std::cout << ht.Find("5") << std::endl;
	std::cout << ht.Find("20") << std::endl;
}
int main()
{
	test();
	return 0;
}
2.链地址法（哈希桶）

链地址法存储键值对时，哈希表的每一个位置其实是一个链表，当键值对要存储的槽已经被其他数据所占时，会直接头插在该槽的链表中。

(1)哈希表扩容：载荷因子

链地址法中的哈希表也需要扩容，否则哈希表中的链表会很长，效率低。采用链地址法的哈希表也是需要根据载荷因子决定是否扩容，载荷因子的值通常设置为1（源码中就是1）。

和开放地址法一样，扩容时创建新哈希表，复用Insert函数，并且哈希表中的链表的所有元素都要重新映射。但是这个方法效率低下，因为复用Insert函数在遍历旧哈希表时，每次都需要创建新的节点数据插入新哈希表，之后还要再销毁该节点数据。

改进方法：遍历旧哈希表，直接使用旧哈希表中的节点数据存入新哈希表，不再复用Insert函数和创建新节点数据。

//插入函数
bool Insert(const std::pair<K, V>& kv)
{
	//防止数据冗余
	if (Find(kv.first))
		return false;
	//扩容
	if (_n / _tables.size() >= 1)
	{
		//HashTable<K, V> newHT;//创建新哈希表
		//newHT._tables.resize(2 * _tables.size());//2倍扩容
		//创建新哈希表
		std::vector<Node*> newtables(2 * _tables.size());
		//数据重新映射到新表中（链表中的所有数据都要重新映射）
		for (int i = 0; i < _tables.size(); ++i)
		{
			Node* cur = _tables[i];
			while (cur)
			{
				Node* next = cur->_next;
				//计算哈希值
				Hash hs;
				size_t hashi = hs(cur->_kv.first) % newtables.size();
				//直接将旧哈希表中的数据存入新哈希表（头插）
				cur->_next = newtables[hashi];
				newtables[hashi] = cur;

				cur = next;
			}
			_tables[i] = nullptr;
			//复用Insert函数方法（舍弃）
			//Node* cur = _tables[i];
			//while (cur)
			//{
			//	newHT.Insert(cur->_kv);
			//	cur = cur->_next;
			//}
		}
		_tables = newtables;
	}
	//计算哈希值
	Hash hs;
	size_t hashi = hs(kv.first) % _tables.size();
	//插入数据（头插）
	Node* newnode = new Node(kv);
	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;
	++_n;
	return true;
}
(2)完整代码
namespace hash_bucket {

	//哈希表数据元素
	template<class K, class V>
	struct HashNode {
		std::pair<K, V> _kv;//键值对
		struct HashNode<K, V>* _next;//链表指针
		//构造函数
		HashNode(const std::pair<K, V> kv):_kv(kv),_next(nullptr)
		{}
	};
	//默认哈希函数（仿函数），针对可以直接强转为整型的类型
	template<class K>
	struct HashFunc {
		size_t operator()(const K& key)
		{
			return size_t(key);
		}
	};
	//默认哈希函数对string类型进行模板特化
	template<>
	struct HashFunc<std::string> {
		size_t operator()(const std::string& key)
		{
			size_t hashi = 0;
			for (auto& ch : key)
			{
				hashi *= 131;
				hashi += ch;
			}
			return hashi;
		}
	};
	//哈希表
	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	private:
		std::vector<Node*> _tables;//哈希表
		size_t _n;//哈希表中已存元素个数
	public:
		//构造函数
		HashTable()
		{
			_tables.resize(10);
			_n = 0;
		}
		//拷贝构造函数
		HashTable(const HashTable& ht)
		{
			_tables = new std::vector<Node*>(ht._tables.size());
			_n = ht._n;
		}
		//析构函数（释放哈希表中每个槽中的链表）
		~HashTable()
		{
			for (int i = 0; i < _tables.size(); ++i)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				_tables[i] = nullptr;
			}
		}
		//插入函数
		bool Insert(const std::pair<K, V>& kv)
		{
			//防止数据冗余
			if (Find(kv.first))
				return false;
			//扩容
			if (_n / _tables.size() >= 1)
			{
				//HashTable<K, V> newHT;//创建新哈希表
				//newHT._tables.resize(2 * _tables.size());//2倍扩容
				//创建新哈希表
				std::vector<Node*> newtables(2 * _tables.size());
				//数据重新映射到新表中（链表中的所有数据都要重新映射）
				for (int i = 0; i < _tables.size(); ++i)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						//计算哈希值
						Hash hs;
						size_t hashi = hs(cur->_kv.first) % newtables.size();
						//直接将旧哈希表中的数据存入新哈希表（头插）
						cur->_next = newtables[hashi];
						newtables[hashi] = cur;

						cur = next;
					}
					_tables[i] = nullptr;
					//复用Insert函数方法（舍弃）
					//Node* cur = _tables[i];
					//while (cur)
					//{
					//	newHT.Insert(cur->_kv);
					//	cur = cur->_next;
					//}
				}
				_tables = newtables;
			}
			//计算哈希值
			Hash hs;
			size_t hashi = hs(kv.first) % _tables.size();
			//插入数据（头插）
			Node* newnode = new Node(kv);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return true;
		}
		//查找函数
		Node* Find(const K& key)
		{
			//计算哈希值
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			//查找数据
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
					return cur;
				cur = cur->_next;
			}
			return nullptr;
		}
		//删除函数
		bool Erase(const K& key)
		{
			Node* ret = Find(key);
			if (ret == nullptr)
				return false;
			else
			{
				//计算哈希值，确认数据所在槽
				Hash hs;
				size_t hashi = hs(key) % _tables.size();
				if (_tables[hashi]->_kv.first == key)//key是所在槽中链表的的头节点
				{
					Node* cur = _tables[hashi];
					_tables[hashi] = cur->_next;
					delete(cur);
				}
				else//key是所在槽中链表的的中间节点
				{
					Node* cur = _tables[hashi];
					Node* prev = cur;
					while (cur->_kv.first != key)
					{
						prev = cur;
						cur = cur->_next;
					}
					//删除数据
					Node* temp = cur;
					prev->_next = cur->_next;
					delete(temp);
				}
				--_n;
				return true;
			}
		}
	};
}
void test2()
{
	hash_bucket::HashTable<std::string, int> ht;
	ht.Insert({ "10",10 }); ht.Insert({ "8",8 }); ht.Insert({ "2",2 }); ht.Insert({ "9",9 }); ht.Insert({ "1",1 });
	ht.Insert({ "3",3 }); ht.Insert({ "4",4 }); ht.Insert({ "6",6 }); ht.Insert({ "7",7 }); ht.Insert({ "5",5 });
	ht.Insert({ "888",888 });
	std::cout << ht.Find("10") << std::endl;
	std::cout << ht.Find("8") << std::endl;
	std::cout << ht.Find("999") << std::endl;
	ht.Erase("10");
	std::cout << ht.Find("10") << std::endl;
	std::cout << ht.Find("8") << std::endl;
	std::cout << ht.Find("999") << std::endl;
}
int main()
{
	//test1();
	test2();
	return 0;
}
【C++ —— 哈希】哈希原理 | 哈希表的模拟实现 | 模拟实现封装unordered_map和unordered_set
qq_55953229的博客
05-26 1230
本文参考文档：https://legacy.cplusplus.com/reference/unordered_map/
哈希表的底层实现(1)---C++版
2301_80377335的博客
09-08 948
比如2.1中的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr为4， 因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。，首先对关键码集合用散列函数计算散列地址，具有相同地 址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链 接起来，各链表的头结点存储在哈希表中。//三个状态，这里定义了哈希表中的数据的多个状态，在红黑树的模拟实现中有用过，这样方便判断此位置的数据状态，方便以后的线性探测和删除数据等。
用数组模拟哈希表---c语言
qq_33269561的博客
04-01 1865
哈希表：哈希表是将某个数映射到哈希表的位置中，可以把哈希表看作一个带编号的桶 而数表示 需要放入桶中的元素。 哈希表能开辟的空间有限且不能为负数所以就会存在一个桶里面有多个元素的情况，但是如果就单单一个哈希表就不能判断这个位置存放的具体的数字 打个比方说 如果有一个数23它取模后的位置在3号位有另一个数56取模后也在3号位，这样就会引起冲突，所以就有了拉链法 拉链法就是在哈希表坐标下面建立一个链表，链表用来存储这个数利用哈希表来快速查找这个数是否存在 打个比方说 如果有一个数23它取模后的位置在3
【C++】哈希表模拟实现
m0_69442905的博客
10-10 1252
了解哈希表的几种实现方式，初步了解哈希函数，初步构建简单的封闭哈希表，实现插入，查找，删除等。然后对封闭哈希表基础上进行更新，引出介绍链式哈希表，实现最简单的插入查找，删除
基于数组实现哈希表
qq_60749185的博客
01-11 854
基于数组实现哈希表
哈希表（Hash Table） -- 用数组模拟--字符串前缀哈希
大学在读，感谢关注
04-01 1295
哈希表（Hash Table）是一种数据结构，用于存储键值对。它通过将键映射到表中的一个位置来实现快速的查找操作。在哈希表中，每个键都会经过一个哈希函数的计算，得到对应的哈希值，然后将键值对存储在哈希值对应的位置上。哈希表的主要特点包括：1. 快速的查找操作：通过哈希函数计算出键对应的位置，可以在常数时间内找到对应的值。2. 空间效率高：可以根据实际情况动态调整哈希表的大小，使得空间利用率高。
「Leetcode」242. 有效的字母异位词：可以拿数组当哈希表来用，但哈希值不要太大！
代码随想录
09-14 270
数组就是简单的哈希表，但是数组的大小是受限的！
JS模拟实现哈希表及应用详解
10-18
在JavaScript中，我们可以通过模拟实现哈希表来优化数据处理效率，尤其是在处理大量数据时。以下是对JS模拟实现哈希表及其应用的详细说明。 首先，了解一些与哈希表相关的基础知识点： 1. **属性的枚举**：在...
VB6中哈希表的实现与应用
最新发布
10-07
使用场景及目标：本哈希表适合作为关键字与对应内容或解释关联的有效工具，便于优化应用程序性能或用于语言相关的工作流程中，尤其适合含有简短关键字的情况。 阅读建议：由于部分特性还在进一步完善之中，使用者...
简单版的数组实现哈希表
我的青春一去不复返
08-23 332
【代码】简单版的数组实现哈希表。
数组模拟哈希表
weixin_49727780的博客
05-26 375
哈希表能使数据通过一种映射方式存放到一种范围更小的数据空间中，比如-1e9~1e9， 存放到1e5的空间中, 并且能够快速实现存放和查找的操作，删除的话一般很少，可以看作是一次查找，找到之后打一个标记，即为删除 实现方式 开放寻址法 a为一个整数 b = a%m 把a放在角标为b的数组中，当发生冲突时，即之前有元素已经占据了b这个位置，则向后移动，直至找到一个空位置 注：m为一个质数时，冲突的可能性最小 拉链法 a为一个整数 b = a%m 把a放在角标为b的数组中，当发生冲突时，在b这个位置后面拉一条链
数据结构之数组实现哈希表应用总结篇
09-13 5854
数据结构之数据应用总结篇（一）数据在字符串操作程序中应用由于数组中的内存是连续的，于是可以根据下标在O(1)时间读/写任何元素，因此它的时间效率是很高的，我们可以利用数组时间效率高的优点，用数组来实现简单的哈希表，即把数组的小标设为哈希表的键值（Key）,而把数组中的每一个数字设为哈希表的值（Value），这样每一个下标及数组中该下标对应的数字就组成了一个键-值的配对。应用1：第一个只出现一次的字符
学习笔记10||数据结构||用数组实现哈希表
weixin_45711276的博客
05-15 670
哈希表 哈希表的存储结构 存储结构分为两大类：1、开放寻址法 2、拉链法 哈希表的作用：把一个复杂的数据结构映射到0~n。 常见情景：把0~ 10e9映射到0~10e5。 例题：模拟散列表 l x 插入一个数x q x x是否出现过 M 0~10e5 N -10e9 ~10e9 1、x%10e5 可以将数放到10e5之内//取模最好取质数，离2的整数次幂越远越好 2、可能存在的冲突，即不同的数字映射到同一个 处理冲突： 1、拉链法： 实现： #include< iostream> #incl
模拟实现hashTable（哈希表）
兰先生的博客
02-18 758
哈希表
数组模拟的【哈希集合】与【哈希映射】
郭松源的博客
08-17 547
一、哈希映射 hash(x) 我们知道，std::unordered_map是一种非常高效的哈希映射，他相对于红黑树实现的std::map抛弃了有序性，但是提高了效率，插入和查询操作时间复杂度仅仅为 O(1)O(1)O(1)。 但是，在算法考试、算法竞赛中，std::unordered_map常常因为常数太大，非常容易被出题人卡掉。因此我们需要换一种更加高效的数组模拟的方法。 在看下面的内容之前，请先阅读这篇文章：【AcWing 840. 模拟散列表】，来了解std::unordered_set的数组实现思
数组，链表和哈希表比较
u012864854的博客
03-31 5838
数组与链表的区别：（1）存储空间上：    链表存放的内存空间可以是连续的，也可以是不连续的，数组则是连续的一段内存空间。一般情况下存放相同多的数据时，数组占用较小的内存，而链表还需要存放其前驱和后继的空间。（2）长度的可变性：    链表的长度是按实际需要可以伸缩的，而数组的长度是在定义时要给定的，如果存放的数据个数超过了数组的初始大小，则会出现溢出现象。（3）查找效率：按序号查找时，数组可以随...
数组（哈希表）
Fly嘉
01-03 8036
哈希思想：我们定义好一个哈希函数，然后把一些数据对应的key输入到哈希函数会得到一个index，key可以自己设置。创建一个哈希表，来保存好index和这个index对应到的数据。可能不同的数据却生成了一样的index，这时候就会面临冲突，我们可以通过一些方法来解决。 我们主要是写好哈希函数和当index冲突的时候的处理方法。我这个使用的是直接寻址法     两数之和(1) class ...
Delphi实现哈希表的模拟演示
在Delphi中，没有内置的哈希表类，但可以通过其他数据结构，例如动态数组（TList或者TArray）或者字典（TDictionary，在Delphi较新版本中提供），来模拟实现哈希表的功能。Delphi的TDictionary是一个泛型类，可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

周丕才

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值