【STL学习】自己动手C++编程实现hash table（散列表）

最新推荐文章于 2024-03-26 10:56:18 发布
最新推荐文章于 2024-03-26 10:56:18 发布
阅读量6.6k 收藏 11
点赞数 2
分类专栏： 数据结构与算法 C/C++ 文章标签： 算法 编程 STL C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiajun07061225/article/details/8746910
版权

SGI STL中散列表采用链接法解决冲突。结构中维护了一个vector，vector中每一个元素称为一个桶（bucket），它包含的是一个链表的第一个节点。


下面代码展示了自己编程实现的hash table，C++模板类封装。


如有错误，还请包涵和指正（E-Mail：xiajunhust@gmail.com）！


HashTable.h：

//《STL源码剖析》5.7 hashtable编程实现
//Author：江南烟雨
//E-Mail：xiajunhust@gmail.com

#include <iostream>
#include <algorithm>
#include <vector>

//hash table中链表节点数据结构定义
template <class ValueType>
struct __hashtable_node{
	__hashtable_node *next;
	ValueType val;
};

static const int __stl_num_primes = 28;//表格大小(28个质数)
//28个质数
static const unsigned long __stl_prime_list[__stl_num_primes] = {
	53,         97,           193,         389,       769,
	1543,       3079,         6151,        12289,     24593,
	49157,      98317,        196613,      393241,    786433,
	1572869,    3145739,      6291469,     12582917,  25165843,
	50331653,   100663319,    201326611,   402653189, 805306457, 
	1610612741, 3221225473ul, 4294967291ul
};

//得出28个质数中不小于n的那个质数
inline unsigned long __get_next_prime(unsigned long n)
{
	const unsigned long *first = __stl_prime_list;
	const unsigned long *last = __stl_prime_list + __stl_num_primes;
	const unsigned long *pos = std::lower_bound(first,last,n);

	return pos == last ? *(last - 1) : *pos;
}

template <class T1,class T2>
void construct(T1 *p,const T2 &value)
{
	new (p) T1(value);
}

template <class T>
void destroy(T* pointer)
{
	pointer->~T();//调用析构函数
}

//hash函数定义
//都是仿函数
template <class KeyType>
struct hash{};

//字符串要进行映射
inline size_t __stl_hash_string(const char *s)
{
	unsigned long h = 0;
	for (;*s;++s)
	{
		h = 5 * h + *s;
	}

	return size_t(h);
}

//类模板显示特化定义
template <>
struct hash<int>{
	size_t operator()(int x) const {return x;}
};

template <>
struct hash<char *>{
	size_t operator()(const char *s) const {return __stl_hash_string(s);}
};

template <>
struct hash<const char *>{
	size_t operator()(const char *s) const {return __stl_hash_string(s);}
};

template <>
struct hash<char>{
	size_t operator()(char s) const {return s;}
};

template <>
struct hash<unsigned char>{
	size_t operator()(unsigned char s) const {return s;}
};

template <>
struct hash<signed char>{
	size_t operator()(signed char s) const {return s;}
};

// C++ Standard 规定，每一个 Adaptable Unary Function 都必须继承此类别
template <class Arg,class Result>
struct unary_function{
	typedef Arg argument_type;
	typedef Result result_type;
};

// C++ Standard 规定，每一个 Adaptable Binary Function 都必须继承此类别
template <class Arg1,class Arg2,class Result>
struct binary_function{
	typedef Arg1 first_argument_type;
	typedef Arg2 second_argument_type;
	typedef Result result_type;
};

//从节点中取出键值的仿函数定义
//identity function；任何数值通过此函数式后，不会发生任何改变
template <class T>
struct identity:public unary_function<T,T>
{
	const T& operator()(const T& x) const{return x;}
};

//判断键值是否相等的仿函数定义
template <class T>
struct equal_to:public binary_function<T,T,bool>{
	bool operator()(const T& x,const T& y) const{return x == y;}
};

//比较字符串是否相等的仿函数
struct eqstr{
	bool operator()(const char *s1,const char *s2)const
	{
		return strcmp(s1,s2) == 0;
	}
};

//hash table数据结构定义
//模板参数：
//ValueType：节点的实值型别
//KeyType：节点的键值型别
//HashFcn：hash function的函数型别
//ExtractKey：从节点中取出键值的方法
//EqualKey：判断键值是否相同
template <class ValueType,class KeyType,class HashFcn,class ExtractKey,class EqualKey>
class HashTableClass{
public:
	typedef struct __hashtable_node<ValueType> node;//hash table内部链表节点定义
	//hash table没有提供默认构造函数
	HashTableClass(size_t n,
		const HashFcn &hf,
		const EqualKey &eql,
		const ExtractKey &ext)
		:hasher(hf),equals(eql),get_key(ext),num_elements(0)
	{
		initialize_buckets(n);
	}
	HashTableClass(size_t n,
		const HashFcn &hf,
		const EqualKey &eql)
		:hasher(hf),equals(eql),get_key(ExtractKey()),num_elements(0)
	{
		initialize_buckets(n);
	}
	HashTableClass(const HashTableClass &ht)
		:hasher(ht.hasher),equals(ht.equals),get_key(ht.get_key),num_elements(0)
	{
		copy_from(&ht);
	}
	~HashTableClass(){clear();};
	//赋值操作符
	HashTableClass& operator= (const HashTableClass &ht)
	{
		if (&ht != this)
		{
			clear();
			hasher = ht.hasher;
			equals = ht.equals;
			get_key = ht.get_key;
			copy_from(&ht);
		}
	}
	//返回元素个数
	size_t size(){return num_elements;}
	//最大元素数目
	size_t max_size(){return size_t(-1);}
	//返回bucket vector大小
	size_t bucket_count(){return buckets.size();}
	//返回bucket vector可能的最大值
	size_t max_bucket_count(){return __stl_prime_list[__stl_num_primes - 1];}
	//插入元素，不允许重复
	std::pair<node *,bool> insert_unique(const ValueType &obj);
	//插入元素，允许重复
	node* insert_equal(const ValueType &obj);
	//打印所有节点
	void printAllNodes();
	//遍历所有buckets
	void printAllBuckets();
	//查找某一键值的节点
	std::pair<node*,bool> find(const KeyType &key);
	//判断某一值出现的次数
	size_t count(const KeyType &key);
	//整体删除
	void clear();
	//复制hash表
	void copy_from(const HashTableClass *ht);

private:
	std::vector<node*> buckets;//由桶组成的vector
	size_t num_elements;//总的元素个数
	HashFcn hasher;
	ExtractKey get_key;
	EqualKey equals;

	//节点配置和释放函数
	node* new_node(const ValueType &obj)
	{
		node *tempNode = new node;
		tempNode->next = NULL;
		try
		{
			construct(&tempNode->val,obj);
		}
		catch (...)
		{
			delete tempNode;
			throw;
			return NULL;
		}
		return tempNode;
	}

	void delete_node(node *n)
	{
		destroy(&n->val);
		delete n;
	}

	//初始化buckets vector
	void initialize_buckets(size_t n);

	//返回最接近n并大于等于n的质数
	size_t next_size(size_t n)const{return __get_next_prime(n);}

	//判断是否需要扩充buckets vector，如有需要则进行扩充
	void resize(size_t num_elements_hint);

	//判断元素落在哪个bucket
	//提供两个版本
	//版本一：只接受实值
	size_t bkt_num(const ValueType &obj) const{return bkt_num_key(get_key(obj));}
	//版本二：接受实值和buckets个数
	size_t bkt_num(const ValueType &obj,size_t n) const {return bkt_num_key(get_key(obj),n);}
	//版本一：只接受键值
	size_t bkt_num_key(const KeyType &Key) const{return hasher(Key) % (buckets.size());}
	//版本二：接受键值和buckets个数
	size_t bkt_num_key(const KeyType &Key,size_t n) const {return hasher(Key) % n;}

	//在不需要重新分配bucket vector的情况下插入元素，元素不允许重复
	std::pair<node *,bool> insert_unique_noresize(const ValueType &obj);
	//在不需要重新分配bucket vector的情况下插入元素，元素不允许重复
	node* insert_equal_noresize(const ValueType &obj);
};

template <class ValueType,class KeyType,class HashFcn,class ExtractKey,class EqualKey>
std::pair<typename HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::node *,bool> 
HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::insert_unique(const ValueType &obj)
{
	resize(num_elements + 1);

	return insert_unique_noresize(obj);
}

template <class ValueType,class KeyType,class HashFcn,class ExtractKey,class EqualKey>
typename HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::node *
HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::insert_equal(const ValueType &obj)
{
	resize(num_elements + 1);

	return insert_equal_noresize(obj);
}

template <class ValueType,class KeyType,class HashFcn,class ExtractKey,class EqualKey>
void HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::printAllNodes()
{
	cout << endl;
	cout << "Current node in hash table : " << endl;
	for (size_t i = 0;i < buckets.size();++i)
	{
		typename HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::node* curNode = buckets[i];
		while(curNode)
		{
			cout << curNode->val << " ";
			curNode = curNode->next;
		}
	}
	cout << endl;
}

template <class ValueType,class KeyType,class HashFcn,class ExtractKey,class EqualKey>
void HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::printAllBuckets()
{
	cout << endl;
	cout << "Current buckets in hash table : " << endl;
	for (size_t i = 0;i < buckets.size();++i)
	{
		typename HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::node* curNode = buckets[i];
		if(NULL == curNode)
			cout << "buckets[" << i << "] is empty!" << endl;
		else
		{
			size_t count = 0;
			while(curNode)
			{
				++count;
				curNode = curNode->next;
			}
			cout << "buckets[" << i << "] has " << count << " elements : ";
			curNode = buckets[i];
			while(curNode)
			{
				cout << curNode->val << " ";
				curNode = curNode->next;
			}
			cout << endl;
		}
	}
}

template <class ValueType,class KeyType,class HashFcn,class ExtractKey,class EqualKey>
std::pair<typename HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::node *,bool> 
HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::find(const KeyType &key)
{
	size_t bucket_index = bkt_num_key(key);
	node*first = buckets[bucket_index];
	while(first)
	{
		if (equals(key,get_key(first->val)))
		{
			cout << "find the element " << key << " success" << endl;
			return std::pair<typename HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::node *,bool>(first,true);
		}
		first = first->next;
	}

	cout << "cannot find the element " << key << endl;

	return std::pair<typename HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::node *,bool>(NULL,false);
}

template <class ValueType,class KeyType,class HashFcn,class ExtractKey,class EqualKey>
size_t HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::count(const KeyType &key)
{
	size_t bucket_index = bkt_num_key(key);
	node*first = buckets[bucket_index];
	size_t num = 0;
	while(first)
	{
		if (equals(key,get_key(first->val)))
		{
			++num;
		}
		first = first->next;
	}

	cout << "The element " << key << " appears " << num << " times" << endl;
	return num;
}

template <class ValueType,class KeyType,class HashFcn,class ExtractKey,class EqualKey>
void HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::clear()
{
	for (size_t i = 0;i < buckets.size();++i)
	{
		node* first = buckets[i];
		//删除bucket list中的每个节点
		while(first)
		{
			node *next = first->next;
			delete_node(first);
			first = next;
		}
		buckets[i] = 0;
	}
	//总元素个数置0
	num_elements = 0;

	//vector并未释放掉空间（自动回收）
}

template <class ValueType,class KeyType,class HashFcn,class ExtractKey,class EqualKey>
void HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::copy_from(const HashTableClass *ht)
{
	buckets.clear();//清除已有vector
	//使得bucket vector空间和对方相同
	buckets.reserve(ht->buckets.size());
	//插入n个元素，null
	buckets.insert(buckets.end(),ht->buckets.size(),(typename HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::node *)0);

	for (size_t i = 0;i < ht->buckets.size();++i)
	{
		if (const node *cur = ht->buckets[i])
		{
			node *tempNode = new_node(cur->val);
			buckets[i] = tempNode;
			for (node *next = cur->next;next;next = next->next)
			{
				tempNode->next = new_node(next->val);
				tempNode = tempNode->next;
			}
		}
	}

	num_elements = ht->num_elements;
}

template <class ValueType,class KeyType,class HashFcn,class ExtractKey,class EqualKey>
void HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::initialize_buckets(size_t n)
{
	const size_t n_buckets = next_size(n);
	buckets.reserve(n_buckets);
	buckets.insert(buckets.end(),n_buckets,(node*)0);
}

template <class ValueType,class KeyType,class HashFcn,class ExtractKey,class EqualKey>
void HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::resize(size_t num_elements_hint)
{
	//buckets vector重建与否的标准：
	//比较新的总元素个数和原buckets vector大小
	const size_t old_n_vector = buckets.size();
	//需要重新配置
	if (num_elements_hint > old_n_vector)
	{
		const size_t n = next_size(num_elements_hint);
		if (n > old_n_vector)//有可能vector已到达最大
		{
			vector<node*> tempVec(n,(node *)0);
			for (size_t bucketIndex = 0;bucketIndex < old_n_vector;++bucketIndex)
			{
				node *first = buckets[bucketIndex];//指向节点对应之串行的起始节点
				while(first)
				{
					//计算节点落在哪一个新的bucket内
					size_t new_bucket_index = bkt_num_key(first->val,n);
					buckets[bucketIndex] = first->next;
					first->next = tempVec[new_bucket_index];
					tempVec[new_bucket_index] = first;
					first = buckets[bucketIndex];
				}
			}
			//交换新旧两个bucket vector
			buckets.swap(tempVec);
		}
	}
}

template <class ValueType,class KeyType,class HashFcn,class ExtractKey,class EqualKey>
std::pair<typename HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::node *,bool> 
HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::insert_unique_noresize(const ValueType &obj)
{
	size_t bucket_index = bkt_num(obj);
	node *first = buckets[bucket_index];
	//搜索当前链表
	for (node *curNode = first;curNode;curNode = curNode->next)
	{
		if(equals(get_key(obj),get_key(curNode->val)))
			return pair<typename HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::node*,bool>(curNode,false);
	}

	node *tempNode = new_node(obj);
	tempNode->next = first;
	buckets[bucket_index] = tempNode;

	++num_elements;

	return pair<typename HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::node*,bool>(tempNode,true);
}

template <class ValueType,class KeyType,class HashFcn,class ExtractKey,class EqualKey>
typename HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::node*
HashTableClass<ValueType,KeyType,HashFcn,ExtractKey,EqualKey>::insert_equal_noresize(const ValueType &obj)
{
	size_t bucket_index = bkt_num(obj);
	node *first = buckets[bucket_index];
	for (node *curNode = first;curNode;curNode = curNode->next)
	{
		//发现与链表中的某键值相等，马上插入，然后返回
		if (equals(get_key(obj),get_key(curNode->val)))
		{
			node *tempNode = new_node(obj);
			tempNode->next = curNode->next;
			curNode->next = tempNode;
			++num_elements;
			return tempNode;
		}
	}

	//如果没发现键值相等的元素
	node *tempNode = new_node(obj);
	//将其插入链表头部
	tempNode->next = first;
	buckets[bucket_index] = tempNode;
	++num_elements;
	return tempNode;
}



HashTable.cpp： 

#include "HashTable.h"

using namespace std;

int main()
{
	HashTableClass<int,int,hash<int>,identity<int>,equal_to<int> > *hashTableObj = new HashTableClass<int,int,hash<int>,identity<int>,equal_to<int> >(50,hash<int>(),equal_to<int>());

	cout << "Hash Table size : " << hashTableObj->size() << endl;
	cout << "Hash Table bucket count : " << hashTableObj->bucket_count() << endl;
	cout << "Hash Table max bucket count : " << hashTableObj->max_bucket_count() << endl;

	hashTableObj->insert_unique(59);
	hashTableObj->insert_unique(63);
	hashTableObj->insert_unique(108);
	hashTableObj->insert_unique(2);
	hashTableObj->insert_unique(53);
	hashTableObj->insert_unique(55);
	cout << "Hash Table size : " << hashTableObj->size() << endl;
	hashTableObj->printAllNodes();
	hashTableObj->printAllBuckets();

	//继续插入元素，使总元素个数达到54个
	for(int i = 0;i <= 47;++i)
		hashTableObj->insert_equal(i);
	cout << endl;
	cout << "Hash Table size : " << hashTableObj->size() << endl;
	cout << "Hash Table bucket count : " << hashTableObj->bucket_count() << endl;
	hashTableObj->printAllNodes();
	hashTableObj->printAllBuckets();

	hashTableObj->find(2);
	hashTableObj->count(2);

	HashTableClass<int,int,hash<int>,identity<int>,equal_to<int> > *hashTableObj2 = new HashTableClass<int,int,hash<int>,identity<int>,equal_to<int> >(20,hash<int>(),equal_to<int>());

	cout << "Hash Table 2 size : " << hashTableObj2->size() << endl;
	cout << "Hash Table 2 bucket count : " << hashTableObj2->bucket_count() << endl;
	cout << "Hash Table 2 max bucket count : " << hashTableObj2->max_bucket_count() << endl;

	hashTableObj2->copy_from(hashTableObj);
	cout << "Hash Table 2 size : " << hashTableObj2->size() << endl;
	cout << "Hash Table 2 bucket count : " << hashTableObj2->bucket_count() << endl;
	cout << "Hash Table 2 max bucket count : " << hashTableObj2->max_bucket_count() << endl;

	HashTableClass<int,int,hash<int>,identity<int>,equal_to<int> > hashTableObj3(*hashTableObj2);
	cout << "Hash Table 3 size : " << hashTableObj3.size() << endl;
	cout << "Hash Table 3 bucket count : " << hashTableObj3.bucket_count() << endl;
	cout << "Hash Table 3 max bucket count : " << hashTableObj3.max_bucket_count() << endl;

	HashTableClass<char *,char *,hash<char *>,identity<char*>,eqstr > *hashTableObjString = new HashTableClass<char *,char *,hash<char *>,identity<char*>,eqstr >(20,hash<char *>(),eqstr());
	hashTableObjString->insert_unique("jun");
	hashTableObjString->insert_unique("hust");
	cout << "Hash Table hashTableObjString size : " << hashTableObjString->size() << endl;
	cout << "Hash Table hashTableObjString bucket count : " << hashTableObjString->bucket_count() << endl;
	cout << "Hash Table hashTableObjString max bucket count : " << hashTableObjString->max_bucket_count() << endl;
	hashTableObjString->printAllNodes();
	//hashTableObjString->printAllBuckets();
	hashTableObjString->find("juu");

	delete hashTableObj;
	delete hashTableObj2;
	delete hashTableObjString;

	return 0;
}


运行结果（VS2008+Win7）：



没有昵称阿
关注
专栏目录
【C++ STL】哈希 Hash（闭散列、开散列介绍及其实现）
codewinter的博客
06-26 2855
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 O(log2N)，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个 unordered 系列的关联式容器，这4个容器与红黑树结构的关联式容器底层结构不同，是哈希表（哈希其实就是一种散列，一种映射）哈希表结构的 unordered 系列的关联式容器与红黑树结构的关联式容器 map/set/multimap/mul
数据结构与算法详解——散列表篇（附c++实现代码）
JMasker的博客
05-13 1983
目录散列表散列函数哈希冲突开放地址法线性探测二次探测双重散列链表法装载因子 散列表   前面数组、链表、栈、队列都是序列式容器，存储的都是一个元素。而散列表又叫哈希表(hash table)，是一种关联式容器，存储的是一对值，一般是一个key对应一个value(又叫键值对)。   c++ stl中的map就是一个散列表，举个例子： std::map<std::string,int> m; m["小明"]=170; std::cout<<"小明的身高是"<<m["小明"]&
一个c++实现的哈希表类
06-27
在程序中我们对关键字key应用散列函数H(key)来判断关键字key是否在散列表中，即计算H(key)的值，H(key)值确定所存数据在散列表中的位置。这样一个数据元素的地址是通过函数来计算的，所以数据元素并不需要按照特定的顺序来存放。但是散列函数H(key)将关键字映射为一个整数时，有可能两个关键字的地址相同，所以构造散列函数时要考虑尽量减少冲突的发生。构造散列函数有多种方法，如：平方取中法、除留余数随机数法。本程序采用除留余数法。程序的具体实现如下：本程序是用模板类myhash来实现，包括protected和public属性成员。其中protected成员有*ht（自定义散列表指针）、*empty(bool类型指针，功能是将元素值空、m(散列表容量)、p(除留余数法的除数)以及辅助函数H(key)(散列函数)和collision(处理冲突的函数)；public成员包括构造函数、析构函数和复制构造函数以及=重载函数，其它成员函数主要有：traver(遍历散列表)、show()(打印出哈希表所存的元素)返回值为bool类型的函数search\insert\Delete。search函数（查询关键字为key的元素的位值）、insert函数(插入元素e到哈希表中)、Delete函数（删除关键字为key的元素）。本程序的main函数同样采用两种类型的数据来进行测试，int型和char型，主要测试元素的插入、删除和搜索。
自己动手用c++实现哈希表
一只懒虫的博客
09-27 4217
哈希表 查找效率约等于1 实现思想介绍 一般的hash思想 未采用模板，简单的实现 key是int，value是string 把输入的key值经过hash函数计算，算出它要放入的桶的编号 采用一个指针数组记录各个桶 每个桶里都有50个key_value对象，这里未采用链表，只是用数组简单那模拟 缺点 batch类设计的有问题，没采用链表，不能动态增加 insert方法，不能改变已有的ke...
c++实现哈希表算法(算法基础)
qq_63763951的博客
07-20 3926
本章主要讲解了两种常见的哈希.学完本章,相信你会对一般的哈希算法有一定的了解。
Hash表（用C/C++实现）
最新发布
weixin_74324928的博客
03-26 349
把目标的小值域存入数组，再进行映射，如h(11)映射到3，则在3这个“槽”下链入11，若有重复的数映射到同一个数，则在原有的基础上链入，形成一条“拉链”.如 A B C D即为(1 2 3 4)p = 1 * p^3 + 2 * p^2 + 3 * p^1 + 4 * p^0.输入x是一个-10^9~10^9的数，经过哈希函数h(x)，输出0~10^5的一个数。在1~L-1段中，L-1是第0位，1是L-2位，即p^(L-2)~p^0。在1~R段中，R是第0位，1是R-1位，即p^(R-1)~p^0；
C++数据结构：散列表简单实现（hash表）
攻城狮的博客
05-28 1867
散列表是一种常用的数据结构，它可以快速地存储和查找数据。散列表的基本思想是，将数据的关键字映射到一个有限的地址空间中，然后在该地址空间中存储数据。这样，当需要查找某个数据时，只需要计算其关键字的映射地址，然后在该地址处访问数据，从而实现高效的查找操作。
sanliebiao.rar_sanliebiao_散列表_散列表c++实现
09-24
散列表（Hash Table）是一种非常重要的数据结构，它在计算机科学和编程中有着广泛的应用，尤其是在数据存储、查找和管理方面。散列表通过散列函数将关键字映射到数组的索引位置，从而实现了快速的插入、删除和查找...
sanliebiao.rar_visual c_散列表_散列表实验
09-20
散列表（Hash Table）是一种常用的数据结构，它通过散列函数将关键字映射到一个固定大小的数组中，实现快速的查找、插入和删除操作。在计算机科学中，尤其是在编程和数据结构的学习中，散列表占有重要地位。Visual ...
C++ + Hash + 对拍
07-28
在IT领域，尤其是在算法和数据结构的学习中，"C++ + Hash + 对拍"是一个常见的组合，涉及到编程语言、哈希表（Hash Table）以及对拍（Pairwise Comparison）技术。这里，我们将深入探讨这三个核心概念及其应用。 ...
手动构造一个哈希表
02-27
哈希表的实现，里面包含二叉排序树，及其自己实现的哈希结构，纯代码，代码结构的排布值得思考。
哈希表的实现
07-06
C++实现简单的哈希表，插入，查找，销毁。
散列表C++源程序代码
02-09
开散列表C++源程序代码，有调试界面，散列存储
自己实现的哈希表c++template
09-23
用字符串做key的哈希表，采用瘦模板技术，不会导致代码膨胀，可以自动扩展
c++中hash_table以及std::map应用案例
12-24
代码重点是hash_table，附加std::map与其做对比，实现的是一条sql语句：select c_nationkey, c_mktsegment, count(*), max(c_acctbal) from aaa_customer_1g group by c_nationkey, c_mktsegment order by c_nationkey, c_mktsegment
查找 || 哈希表的c++实现
perry0528的博客
03-28 1050
哈希表的构造方法： 直接定址法 数字分析法 平方取中法 折叠法 除留余数法 随机数法 处理冲突的方法： 开放地址法 线性探测再散列 二次探测再散列 伪随机探测再散列 再哈希法 链地址法 建立一个公共溢出区 装填因子： 平均查找长度ASL跟哈希表构造方法和处理冲突的方法都有关。一般情况下，处理冲突方法相同的哈希表，其平均查找长度依赖于哈希表的装填因子: α=表中填入的记录数哈希表的长度...
C++代码中使用哈希表
树欲静静风不止止的博客
08-30 3612
C++代码中如何使用哈希表
哈希表及其在STL中的实现
qq_39010744的博客
08-28 1841
最近刷题遇到哈希表（散列表）的应用，对这方面不太了解的话用起来还是有点茫，首先总结一下什么是哈希表。 散列表查找（哈希表）概述 一般用来存储数据的顺序表我们是比较熟悉的，存储时依次存入，但是要查找顺序表中某个关键字的记录，就需要从表头依次查找。比如日常用的数组或链表中，要知道某个数据在数组或链表中的下表或者第几个位置需要遍历数组找到该数据，才能得到查询结果，这样查找的时间复杂度较高。因此能不能能不遍历直接查找呢？当然是可以的，这就用到我们所要讲的散列技术了。 散列技术是...
[C++]数据结构：散列表HashTable的实现与简单应用
thewebcode
12-05 191
#include &lt;iostream&gt; using namespace std; template&lt;class E,class K&gt; class HashTable{ public: HashTable(int divisor=11); ~HashTable(){delete[]ht;delete[]empty;} ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

没有昵称阿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值