哈希（散列）表之开放定址法的C++类模板实现

最新推荐文章于 2022-07-10 08:00:00 发布
最新推荐文章于 2022-07-10 08:00:00 发布
阅读量951 收藏 4
点赞数 1
分类专栏： 数据结构与算法 文章标签： 散列表Hash table哈希表 开放定址法 再散列法 链地址法拉链法 C++类模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lgzlgz3102/article/details/66530388
版权

一 简介


散列表（Hash table哈希表），根据关键码值(Key value)而直接进行访问的数据结构。

通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。

这个映射函数叫做散列函数，存放记录的数组叫做散列表。


打个非常不严谨的比方：

NBA2K是一个广受篮球爱好者追捧的游戏。里面有每个NBA球员的战斗值，越高越厉害。

现在假设2K战斗值从1到100放在电脑中（不是全部每个战斗值都有，如可能没有10的值）

以战斗值为关键字，我想查找2K值为1的人是谁？按照传统的方法：

如果2K值无序存放在电脑中，要找1只能一个个取出来与1作比较，相等然后才能找到1存放那的人；

如果2k值有序存放在电脑中，可以通过比如折半查找比较等找到存1的位置然后找到人。


有没有不怎么耗时间，无须多次比较查找却一问就知道2K值为1的人是谁的方法呢?

答案是哈希表存储，以战斗值为关键字，给定战斗值就知道了存放的位置！！


但是哈希有时候会有冲突，也就是即便关键字不一样，可能通过哈希函数算出来的地址一样，这时候就尴尬了。

解决冲突的办法有很多，如链地址法（拉链法），建立一个公共溢出区等，本文主要是用到以下：


开放定址法：当冲突发生时，使用某种探查(亦称探测)技术在散列表中形成一个探查(测)序列。

Hi=(H(key) + di) MOD m,i=1,2，…，k(k<=m-1），其中H(key）为散列函数，m为散列表长，di为增量序列，可有下列三种取法：
1. di=1,2,3，…，m-1，称线性探测再散列；
2. di=1^2,-1^2,2^2,-2^2，⑶^2，…，±（k)^2,(k<=m/2）称二次探测再散列；
3. di=伪随机数序列，称伪随机探测再散列。


再散列法：即在同义词产生地址冲突时计算另一个散列函数地址，直到冲突不再发生。



二 编程实现


准备测试文件：

有10条记录，第2行开始，每行两数，第一个数是2K值，第二个是关联的人。

比如第2行，对应着2K值6的人叫luxing富。

现在要做的事就是，知道了这些信息，然后用合适的位置存放在电脑中。

当下次一问2K值为6的人是谁时，电脑立即知道从哪儿个位置取相应的记录。





1.建立一个HashTable.h


#ifndef HASH.H
#define HASH.H
const int SUCCESS=1;//插入元素成功
const int UNSUCCESS=0;
const int EXIST=-1;//哈希表中有相同关键字元素，不再插入
const int MAX=3;
//hashsize数组存放哈希表需要重建时下一个容量大小
int hashsize[MAX]={11,19,37};

template <typename T>
class HashTable{
private:
	T *elem;
	int count,length;//数据个数，哈希表容量
	int sizeindex;//hashsize[sizeindex]为当前容量
	int *random_d;//增量随机数数组指针
	int Hash(KeyType key){
		return key%length;
	}
	int Hash2(KeyType key){
		return key%(length-1);//双散列函数探测法第二个哈希函数
	}
	void Random(){//随机探测法中建立伪随机数组
		bool *a=new bool[length];
		random_d=new int[length];
		int i;
		for(i=1;i<length;i++)
			a[i]=false;
		srand(time(0));
		for(i=1;i<length;i++){
			do{
				random_d[i]=rand()%(length-1)+1;//给rando[i]赋值为1到length-1
				if(!a[random_d[i]])
					a[random_d[i]]=true;
				else
					random_d[i]=0;
			}while(random_d[i]==0);//赋值失败重新赋值
//			cout<<"random_d["<<i<<"]="<<random_d[i]<<"  ";
		}
		cout<<endl;
		delete []a;
	}
	int d(int i,KeyType key){//增量序列函数，返回第i次冲突的增量
	    switch(d_type){
			//线性探测法：1，2，3···
	    	case 0:return i;
	    	//二次探测法：1，-1，4，-4，9，-9···
			case 1:return ((i+1)/2)*((i+1)/2)*(int)pow(-1,i-1);
			//双散列探测法
			case 2:return i*Hash2(key);
			//随机探测法
			case 3:return random_d[i];
			//默认线性探测
			default: return i;
	    }
		
	}
	void FindAnotherPos(KeyType key,int &p,int i){//开地址法求关键字key的第i次冲突地址p
		p=(Hash(key)+d(i,key))%length;
		if(p<0)//求余是负，在二次探测可能出现
			p=p+length;
	}
	void RecreateHashTable(){
		int i,len=length;//哈希表原容量
		T *p=elem;
		sizeindex++;//取存储容量为hashsize[]中下一个序列数
		if(sizeindex<MAX){
			length=hashsize[sizeindex];
			elem=new T[length];
			assert(elem!=NULL);
			for(i=0;i<length;i++)
				elem[i].key=EMPTY;//未填有数据
			for(i=0;i<len;i++)//将p所指原elem中的数据插入到重建的哈希表中
				if(p[i].key!=EMPTY&&p[i].key!=REMOVE)//原哈希表【i】有数据
					InsertHash(p[i]);
			delete []p;
			if(d_type==3)
				Random();//重建伪随机增量
		}
	}
public:
	int d_type;//探测法类型
	HashTable(){
		count=0;
		sizeindex=0;
		length=hashsize[sizeindex];
		elem= new T[length];
		assert(elem!=NULL);
		for(int i=0;i<length;i++)
			elem[i].key=EMPTY;//还没填充元素
		cout<<"     依下面提示序号选择冲突时探测法："<<endl;
		cout<<"（0：线性；1：二次；2：再散列；3：随机）："<<endl;
		cin>>d_type;
		switch(d_type){
			case 0:cout<<"产生冲突时你选择使用线性探测法解决！"<<endl;break;
			case 1:cout<<"产生冲突时你选择使用二次探测法解决！"<<endl;break;
			case 2:cout<<"产生冲突时你选择用再散列探测法解决！"<<endl;
				  if(d_type==3)
				     Random();
				  else random_d=NULL;
					break;
			case 3:cout<<"产生冲突时你选择使用随机探测法解决！"<<endl;break;
			default:cout<<endl;
		}
		
	}
	~HashTable(){
		if(elem!=NULL)
			delete []elem;
		if(d_type==3)
			delete []random_d;
	}
	bool SearchHash(KeyType key,int &p,int &c){
		/*  查找关键字为key的元素，若查找成功
			p代表待查数据在表中位置，返回success;
            否则，p代表插入位置，返回unsuccess;
            c冲突次数，初值0，在建表插入时用
		*/
		int c1,remove=-1;//存放第一个删除地址
		p=Hash(key);//求得哈希地址
		//该位置被删除或者该位置有数据但不相同
		while(elem[p].key==REMOVE||(elem[p].key!=EMPTY)&&(key!=elem[p].key))
		{
			//该位置数据被删除且是第一个
			if(elem[p].key==REMOVE&&remove==-1){
				remove=p;//该位置存放在remove中
				c1=c;//冲突次数存放在c1中
			}
			//冲突数加1
			c++;
			//在哈希表中可能找到插入位置
			if(c<=hashsize[sizeindex]/2)
				FindAnotherPos(key,p,c);
			else
				break;
		}
		if(key==elem[p].key)
			return true;
		else{
				if(remove!=-1){//在查找过程中碰到曾删除位置
					p=remove;//设为插入位置
					c=c1;//找到此位置时的冲突次数
				}
				return false;//p指示的是插入位置
		}
	}
	int InsertHash(T e){
		int p,c=0;
		//先查找，有不插入且p指向查到的位置；没有则P指向该插入的位置
		if(SearchHash(e.key,p,c))
			return EXIST;
		else{
			if(c<hashsize[sizeindex]/2){
				elem[p]=e;
				++count;
				return SUCCESS;
			}
			else{
				cout<<"插着插着可能不够，暂停！！"<<endl;
				cout<<"哈希地址顺序遍历此时哈希表，准备重建："<<endl;
				TraverseHash(Visit);
				cout<<"重建哈希表如下："<<endl;
				RecreateHashTable();
				cout<<endl;
				return UNSUCCESS;
				
			}
		}
	}
	bool DeleteHash(KeyType key,T &e){
		int p,c;
		if(SearchHash(key,p,c)){
			e=elem[p];
			elem[p].key=REMOVE;//设置删除标志！
			--count;
			return true;
		}
		else return false;
	}
	T GetElem(int i)const{
		return elem[i];
	}
	void TraverseHash(void(*visit)(int ,T *))const{
		//按照哈希地址顺序遍历表
		int i;
		cout<<"哈希地址0~"<<length-1<<endl;
		for(i=0;i<length;i++)
			if(elem[i].key!=EMPTY&&elem[i].key!=REMOVE)
				visit(i,&elem[i]);
		cout<<endl;
	}
};
#endif



2.建立头文件func.cpp


struct DATA{
	KeyType key;//关键字必有
	string star;
};
void Visit(int i,DATA *c){
	cout<<"["<<i<<"]: "<<'('<<c->key<<", "<<c->star<<"）"<<endl;
}
void Visit(DATA c){
	cout<<'('<<c.key<<","<<c.star<<")";
}
void InputFromFile(ifstream &f,DATA &c){
	
	f>>c.key>>c.star;
	
}
void InputKey(int &k){
	cin>>k;
}





3.测试程序


#include <iostream>
#include <fstream>
#include <cmath>
#include <string>
#include <ctime>
#include <assert.h>
using namespace std;
const int EMPTY=0;//尚未填充数据标志
const int REMOVE=-1;//数据删除标志
typedef int KeyType;//关键字类型
#include "func.cpp"
#include "HashTable.h"
int main()
{
	HashTable<DATA> h;
	int i, j, n, p=0;
	bool m;
	DATA e;
	KeyType k;
	ifstream fin("test.txt");
	fin>>n;
	for(i=0; i<n; i++)
	{
		InputFromFile(fin, e);
		j=h.InsertHash(e);
		if(j==EXIST)
		{
			cout<<"有人抢着要（已经有主）的关键字（2K战斗力）："<<e.key<<"，妄图再插入成为: ";
			Visit(e);
			cout<<endl;
		}
		if(j==UNSUCCESS)
			j=h.InsertHash(e);
	}
	fin.close();
	cout<<endl;
	cout<<"按哈希地址的顺序遍历哈希表："<<endl;
	h.TraverseHash(Visit);
	if(h.d_type==1)
	{
		cout<<"请输入待删除球星的关键字（2K战斗力）：";
		InputKey(k);
		m=h.DeleteHash(k, e);
		if(m)
		{
			cout<<"成功删除该元素";
			Visit(e);
			cout<<endl;
		}
	}
	cout<<"请输入待查找球星的关键字（2K战斗力）：";
	InputKey(k);
	n=0;
	j=h.SearchHash(k, p, n);
	if(j==SUCCESS)
	{
		Visit(h.GetElem(p));
		cout<<endl;
	}
	else
		cout<<"未找到"<<endl;
	if(h.d_type==1)
	{
		cout<<"插入球星，请输入待插入球星的关键字（2K战斗力）：";
		InputKey(e.key);
		cout<<"请输入待插入球星的名字：";
		cin>>e.star;
		j=h.InsertHash(e);
		cout<<j<<endl;
		cout<<endl;
		cout<<"按哈希地址的顺序遍历哈希表："<<endl;
		h.TraverseHash(Visit);
	}
	
	return 0;
}



4.部分测试结果









机器学习与AI生成创作
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
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++实现
weixin_41427400的博客
04-22 1000
前言：        最近写了下RabinKarp算法，当中使用到了一定的Hash方法，我顺就复习了一下Hash表的实现原理，要不然感觉自己都要忘记了~~原理：散列表：        散列表也称哈希表，是一种键值对应的数据结构(key-value)，也就是说任何一个存储在Hash表中的数据(value)都会有一个对应的键值(key)用来存储它。我们可以这样来理解他：在我们去电影院看电影的时候，我们...
使用“开放地址法”实现hashmap
CAFE-BABE的博客
09-11 794
之前的博文中提到了使用拉链法来实现hashmap，本以为掌握了手撕“拉链法”的哈希表已经不错了，没想到今天遇到了要求：使用开放地址法实现哈希表。虽然说最后还是写出来了，但是当时写的代码实在是“又臭又长”，很多地方不够精简，虽然也许能够实现相同的功能，但是可读取比较低。 首先本题要求的开放地址很简单，就是如果出现了哈希冲突，那就看下一位行不行，如果不行，继续往下，并且本题不要求写出resize和rehash方法。就假设hashmap是定长的，如果超出了长度要求就直接抛出异常。 我之前写的代码存在的问题：
HashMap数据结构的C++实现
weixin_34375054的博客
03-06 353
Hash表在计算机的应用编程中是一种很常用的数据结构，很多算法的实现都离不开它。虽然C++11标准模板库中的有hashmap类型的实现，但在工程实践中，若项目本身使用的是较低版本的C++，或是出于性能的考虑，可能需要开发出一套独立的hashmap数据类型，从而能更加方便高效的维护相关业务。出于这种目的，有必要自己梳理一下其实现代码，并分享给大家。 至于hash表实现的原理主要就两种：1、链表法，...
散列表之开放定址法
07-12
在散列表里面经常发生散列值冲突，为了解决散列冲突问题，开放定址法是一种简单又高效的方法
一个c++实现的哈希表类-C++文档类资源
03-23
在程序中我们对关键字key应用散列函数H(key)来判断关键字key是否在散列表中，...程序的具体实现如下：本程序是用模板类myhash来实现，包括protected和public属性成员。其中protected成员有*ht（自定义散列表指针）、*e
C++哈希模板（基于邻接表） 散列
08-03
本程序是基于C++实现的哈希模板，采用邻接表来处理冲突，这使得在处理大量数据时更加灵活和高效。 哈希表的工作原理是通过散列函数将键（key）转化为数组的索引，然后将值存储在对应的位置。然而，由于键的种类繁多...
一个c++实现的哈希表类
06-27
程序的具体实现如下：本程序是用模板类myhash来实现，包括protected和public属性成员。其中protected成员有*ht（自定义散列表指针）、*empty(bool类型指针，功能是将元素值空、m(散列表容量)、p(除留余数法的除数)...
ArrayList的一个C++类模板实现
07-28
总结起来，这个C++类模板实现的ArrayList利用双层散列技术提高了在大规模数据集上的性能，提供了类似于Java ArrayList的功能，同时利用C++的类模板机制实现了泛型编程，增加了代码的可复用性。通过深入理解这个实现...
cpp代码-二次探测再散列哈希表
07-14
在C++中，可以自定义哈希函数，或者使用标准库中的`std::hash`模板类。 2. **数组初始化**：创建一个足够大的数组，用于存储键值对。初始化时，所有位置标记为未占用。 3. **冲突处理**：当冲突发生时，使用二次...
散列表C++实现（不同装载因子的开放寻址法和链表法比较）
01-05
该文件夹内包含： 1.chain-hash-onetime.exe:是使用链表法的散列程序，它是在n=100000,m=20000，即装载因子是5的情况下测试的。该程序显示了从开始到全部插入，再到全部成功查找，最后全部删除的过程，并统计和各项数据。 2.open_hash-onetime.exe：是使用开放地址法的散列程序，它是在n=80000,m=100000,即在装载因子是0.8的情况下测试的。该程序演示的功能和上类似。 3.chain-hash-different-loading-factors(all_success).exe。它是链表法在不同的装载因子下的表现，其中所有查找都是成功的。 4.chain-hash-different-loading-factors.exe。它是链表法在不同的装载因子下的表现，所有查找都是既有成功又有不成功的。 5.open-hash-different-loading-factors(all_success).ext。它是开放寻址法在不同的装载因子下的表现，其中所有查找都是成功的。 6.open-hash-different-loading-factors.exe。它是开放寻址法在不同的装载因子下的表现，所有查找都是既有成功又有不成功的。 而对应名字的cpp文件就是以上程序的源文件。
数据结构与算法之顺序表的建立，查找，删除
06-04
数据结构算法的顺序表的建立，查找，删除。用c++编写的请大家好好看看
利用哈希查找链地址法查找元素
01-05
#include #include typedef struct node { int data; struct node *next; }node; init_hash(node **A,int n) { int i; for(i=0;idata=0; A[i]->next=NULL; } } insert_hash(node **A,int value,int n) { int key; node *p,*q; key=value%n; if(A[key]->next!=NULL) { p=A[key]->next; while(p->next!=NULL) p=p->next; q=(node *)malloc(sizeof(node)); q->data=value; q->next=NULL; p->next=q; } else { q=(node *)malloc(sizeof(node)); q->data=value; q->next=NULL; A[key]->next=q; } } int search_hash(node **A,int value,int n) { int key; node *p; key=value%n; if(A[key]->next==NULL) return 0; else { p=A[key]->next; while(p!=NULL) { if(p->data==value) return 1; } return 0; } } delete_hash(node **A,int value,int n) { int key; node *p,*q; key=value%n; p=A[key]; q=A[key]->next; while(q->data!=value) { p=q; q=q->next; } p->next=q->next; free(q); } print_hash(node **A,int n) { int i; node *p; for(i=0;inext!=NULL) { p=A[i]->next; while(p!=NULL) { printf("%d ",p->data); p=p->next; } } } printf("\n"); } main() { int i,n,value,Case; node **A; printf("输入待排序元素个数：\n"); scanf("%d",&n); A=(node **)malloc(sizeof(node*)*n); //申请一个指针型数组A[n] init_hash(A,n);//初始化数组A printf("输入hash表的值(空格键分开)：\n"); for(i=0;i<n;i++) //建hash表 { scanf("%d",&value); insert_hash(A,value,n); } printf("请选择hash表的操作\n1.查询\t2.插入\t3.删除\t4.输出\n"); scanf("%d",&Case); switch(Case) { case 1: { printf("请输入要查询的元素:"); scanf("%d",&value); printf(search_hash(A,value,n)?"Success!\n":"Failure!\n"); //查询 } case 2: { printf("请输入要插入的元素:"); scanf("%d",&value); insert_hash(A,value,n); //插入 } case 3: { printf("请输入要删除的元素:"); scanf("%d",&value); printf(search_hash(A,value,n)?"删除成功!\n":"表中不存在该元素!\n"); delete_hash(A,value,n); } case 4: //输出 { printf("表中元素为：\n"); print_hash(A,n); } } }
HashTable C++ 实现之开放定址法
风吟
11-04 461
解决HashTable的冲突的第二种方法叫做开放定址法。开放定址法不需要使用指针，不需要特意的动态分配空间。当发生冲突时此算法会选择其他的空的单元。因此核心问题来了，怎么有效的选择空的单元呢？ 算法一：线性探测法 F(i)=i（i为寻址次数） 原理：对HashTable进行插入时，出现Index相同时，我们在原始Index的基础上加F(i)。但是问题又来了，因为F(i)为线性函数，它会连续的In...
【散列】散列表HashTable分离链接法类模板的实现
小米子的成长日记
07-10 233
分离链接法(separate chaining)，做法是将散列到同一个值得所有元素保留到一个链表List中。如果这个元素是个新的元素，那么它将被插入到链表的前端。插入前端的原因是：假设关键字是前10个完全平方数并设散列函数就是 hash(x)=x mod 10，则最后得到的分离链接散列表为下图所示。 定义散列表的装填因子λ为散列表中的元素个数对该表大小的比，分离链接散列表的一般法则是让表的大小大致与预料的元素个数差不多（即λ ≈ 1）。实现代码：........................
Hash 哈希表 （开放地址法(线性探测)解决冲突，c++）
麦片不加糖
04-30 2558
Hash 哈希表 （开放地址法解决冲突） Hash，一般翻译做散列、杂凑，或音译为哈希，是把任意长度的输入（又叫做预映射pre-image）通过散列算法变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。(...
C++数据结构--.哈希表线性探测开放寻址法与独立表链地址法
piniheaven的专栏
08-05 4180
1.哈希函数是个定位函数，它用键作为参数，返回表中的索引值   2.线性探测开放寻址法   *调用哈希函数处理键得到哈希值，用值除以表的长度后取余数，从而确定表中的一个位置   *如果该位置非空，则探测下一个位置，到达表最后一项时，折回表头。   *如果回到原来哈希位置上时还未找到空闲位置，说明表已经填满了。    例如：hash(key)=key%11
散列表的C语言实现-开放定址法
浮生Spider
08-09 1944
头文件： #ifndef __HASHTABLE_H #define __HASHTABLE_H /*********************（平方）开放定址散列法***************/ //如果有冲突发生，那么就尝试另外的单元，直到找到空的单元为止 typedef unsigned int index; typedef index position; typedef int E
[c++11]hash<T>哈希结构模板
My Blog
02-18 3832
[c++11]hash哈希结构模板一、哈希结构模板hash简介c++11新增的哈希结构模板定义于头文件 ：template<class _Kty> struct _Bitwise_hash : public unary_function<_Kty, size_t> {...};哈希结构模板定义一个函数对象（重载了operator()），实现了散列函数: 1.接受一个参数的类型Key 2.返回一个
哈希表c++实现以及解释
最新发布
07-07
好的，下面是哈希表的C++实现和解释： 哈希表（Hash Table）又称为散列表，是根据关键码值(Key-Value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值