哈希桶（开散列）的模拟实现以及其中哈希桶迭代器的模拟实现

最新推荐文章于 2025-03-25 19:48:48 发布
最新推荐文章于 2025-03-25 19:48:48 发布
阅读量218 收藏
点赞数 1
CC 4.0 BY-SA版权
文章标签： c++ 开发语言 后端 哈希
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_48991744/article/details/121447035

开散列（哈希桶）：将发生哈希冲突的元素以链表的方式串联起来，本质上是衣服一个链表的集合。

 哈希桶的大概结构如上图，可以理解为一个数组中每一个位置存储的是一个链表。

下面大概介绍哈希桶的大概实现：

首先定义存储的节点，此节点跟链表的节点雷同，next存储下一个节点的位置，data存储值域：

template<class T>
struct hashBucketNode {
	hashBucketNode(const T& x=T())
		:next(nullptr)
		,data(x)
	{}
	hashBucketNode<T>* next;
	T data;
};

除留余数法实现：

	size_t hashFunc(const T& x) {
		return(x % _table.capacity());
	}

本文的哈希桶采用除留余数法，模上数组的容量得到桶号（存储位置），然后使用头插法插入到对应的链表中，但是如果存储字符串的话使用除留余数法会出问题，因此本文给出字符串转化成整数数据的方式如下：

template<class T>
class DToInt {
public:
	size_t operator()(const T& data) {
		return data;
	}
};

class Str2Int {
	size_t operator()(const string& s) {
		return BKDRHash(s.c_str());
	}
	size_t BKDRHash(const char* str) {
		size_t seed = 131;
		size_t hash = 0;
		while (*str) {
			hash = hash * seed + (*str++);
		}
		return (hash & 0x7FFFFFFF);
	}
};

接下来实现对哈希桶的插入以及删除，本文给出重复元素的插入和删除和不重复元素的插入和删除方法，只不过在重复元素的插入和删除的方法中增加遍历确认元素是否重复：

bool Insert_unique(const T& data) {//插入唯一元素
		//通过哈希函数计算哈希桶号
		D2I Dtoint;
		size_t bucketNo= hashFunc(Dtoint(data));

		//查看元素是否重复
		Node* cur = _table[bucketNo];
		while (cur) {
			if (Dtoint(data) == Dtoint(cur->data)) {
				return false;
			}
			cur = cur->next;
		}
		//插入元素
		Node* newnode = new Node(Dtoint(data));
		newnode->next = _table[bucketNo];
		_table[bucketNo] = newnode;
		//修改元素个数
		_size++;

	}
	bool Insert_Repttitiom(const T& data) {
		//插入重复元素
		//通过哈希函数计算哈希桶号
		D2I Dtoint;
		size_t bucketNo = hashFunc(Dtoint(data));
		//直接插入元素
		Node* newnode = new Node(Dtoint(data));
		newnode->next = _table[bucketNo];
		_table[bucketNo] = newnode;
		//修改元素个数
		_size++;
		return true;
	}
	bool Erase_unique(const T& data) {
		//删除元素
		//通过哈希函数计算哈希桶号
		size_t bucketNo = hashFunc(data);
		//查找元素
		Node* prev = nullptr;
		Node* cur = _table[bucketNo];
		while (cur) {
			if (cur->data == data) {
				if (prev == nullptr) {
					_table[bucketNo] = cur->next;
					delete cur;
					cur = nullptr;
					_size--;
					return true;
				}
				else {
					prev->next = cur->next;
					delete cur;
					_size--;
					return true;
				}
			}
			else
			{
				prev = cur;
				cur = cur->next;
			}	
		}
		return false;
	}
	void Erase_Repttitiom(const T& data) {
	    //删除与data相等的所有元素
		//通过哈希函数计算哈希桶号
		size_t bucketNo = hashFunc(data);
		Node* cur = _table[bucketNo];
		Node* prev = nullptr;
		while (cur) {
			if (cur->data == data) {
				if (prev == nullptr) {
					_table[bucketNo] = cur->next;
					delete cur;
					cur = _table[bucketNo];
					_size--;

				}
				else {
					prev->next = cur->next;
					delete cur;
					_size--;
					cur = prev;
				}
		    }
			else {
				prev = cur;
				cur = cur->next;
			}

		}
	}

接下来介绍打印和回收方法（析构），这两种方法都需要遍历所有节点：

	void Print() {
		for (int i = 0; i < _table.size(); i++) {
			Node* cur = _table[i];
			while (cur) {
				cout << cur->data << " ";
				cur = cur->next;
			}
			cout << "\n";
		}
	}
void Clear() {
		for (int i = 0; i < _table.size(); i++) {
			Node* cur = nullptr;
			while (cur) {
				Node* cur = _table[i]->next;
				_table[i] = cur->next;
				delete cur;
			}
		}
		_size = 0;
	}

哈希桶的迭代器，哈希桶的迭代器实现过程中不止对每一条链表进行移动还要对哈希表格进行移动，因此要将迭代器类声明为哈希桶类的友元类，：

template<class T,class D2I= DToInt<T>>
class hashBucket;//后面实现过程中要用到哈希桶类，此前声明
//封装迭代器
template<class T, class D2I = DToInt<T>>//DTOINT为将数据转化成整数数据方便使用哈希函数
class HashBucketIterator {
public:
	typedef hashBucketNode<T> Node;
	typedef hashBucket<T, D2I> table;
	typedef HashBucketIterator<T, D2I> Self;
public:
	HashBucketIterator(Node* node = nullptr, table* ht = nullptr)
		:_node(node)
		, _ht(ht)
	{}

	T& operator*() {
		return _node->data;
	}
	T* operator->() {
		return &(operator*());
	}

	bool operator==(Self& s) {
		return _node == s._node;
	}
	bool operator!=(Self& s) {
		return _node != s._node;
	}

	Self& operator++() {
		Next();
		return *this;
	}
	Self& operator++(int) {
		Self temp = this;
		Next();
		return *temp;
	}
private:
	Node* _node;//哈希桶中存储的节点
	table* _ht;//哈希表格
private:
	void Next() {
		if (_node->next) {
			_node = _node->next;
		}
//BucketNumber是哈希桶类中的哈希桶桶数量
		else {
			size_t No = _ht->hashFunc(_node->data) + 1;
			for (; No < _ht->BucketNumber(); No++) {
				_node = _ht->_table[No];
				if (_node) {
					return;
				}
			}
			_node = nullptr;
		}
	}
};

后文为全部源代码：

Common.h

#pragma once

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

template<class T>
class DToInt {
public:
	size_t operator()(const T& data) {
		return data;
	}
};

class Str2Int {
	size_t operator()(const string& s) {
		return BKDRHash(s.c_str());
	}
	size_t BKDRHash(const char* str) {
		size_t seed = 131;
		size_t hash = 0;
		while (*str) {
			hash = hash * seed + (*str++);
		}
		return (hash & 0x7FFFFFFF);
	}
};

HashBucket.hpp

#pragma once
#include<vector>
#include"Common.h"
//定义存储节点
template<class T>
struct hashBucketNode {
	hashBucketNode(const T& x=T())
		:next(nullptr)
		,data(x)
	{}
	hashBucketNode<T>* next;
	T data;
};

template<class T,class D2I= DToInt<T>>
class hashBucket;
//封装迭代器
template<class T, class D2I = DToInt<T>>
class HashBucketIterator {
public:
	typedef hashBucketNode<T> Node;
	typedef hashBucket<T, D2I> table;
	typedef HashBucketIterator<T, D2I> Self;
public:
	HashBucketIterator(Node* node = nullptr, table* ht = nullptr)
		:_node(node)
		, _ht(ht)
	{}

	T& operator*() {
		return _node->data;
	}
	T* operator->() {
		return &(operator*());
	}

	bool operator==(Self& s) {
		return _node == s._node;
	}
	bool operator!=(Self& s) {
		return _node != s._node;
	}

	Self& operator++() {
		Next();
		return *this;
	}
	Self& operator++(int) {
		Self temp = this;
		Next();
		return *temp;
	}
private:
	Node* _node;
	table* _ht;
private:
	void Next() {
		if (_node->next) {
			_node = _node->next;
		}
		else {
			size_t No = _ht->hashFunc(_node->data) + 1;
			for (; No < _ht->BucketNumber(); No++) {
				_node = _ht->_table[No];
				if (_node) {
					return;
				}
			}
			_node = nullptr;
		}
	}
};


template<class T, class D2I >
class hashBucket {
public:
	friend HashBucketIterator<T,D2I>;
public:
	typedef HashBucketIterator<T,D2I> iterator;
	typedef hashBucketNode<T> Node;
	hashBucket(const size_t capacity=10)
		:_table(capacity)
		,_size(0)
	{}

	iterator begin() {
		Node* cur = nullptr;
		for (int i = 0; i < BucketNumber(); i++) {
			if (_table[i]) {
				cur = _table[i];
				return iterator(cur, this);
			}
		}
		
	}
	iterator end() {
		size_t No= BucketNumber()-1;
		for (; No >= 0; No--) {
			if (_table[No]) {
				Node* cur = _table[No];
				while (cur) {
					cur = cur->next;
				}
				return iterator(cur, this);
			}
		}
	}
	size_t hashFunc(const T& x) {
		return(x % _table.capacity());
	}
	bool Insert_unique(const T& data) {//插入唯一元素
		//通过哈希函数计算哈希桶号
		D2I Dtoint;
		size_t bucketNo= hashFunc(Dtoint(data));

		//查看元素是否重复
		Node* cur = _table[bucketNo];
		while (cur) {
			if (Dtoint(data) == Dtoint(cur->data)) {
				return false;
			}
			cur = cur->next;
		}
		//插入元素
		Node* newnode = new Node(Dtoint(data));
		newnode->next = _table[bucketNo];
		_table[bucketNo] = newnode;
		//修改元素个数
		_size++;

	}
	bool Insert_Repttitiom(const T& data) {
		//插入重复元素
		//通过哈希函数计算哈希桶号
		D2I Dtoint;
		size_t bucketNo = hashFunc(Dtoint(data));
		//直接插入元素
		Node* newnode = new Node(Dtoint(data));
		newnode->next = _table[bucketNo];
		_table[bucketNo] = newnode;
		//修改元素个数
		_size++;
		return true;
	}
	bool Erase_unique(const T& data) {
		//删除元素
		//通过哈希函数计算哈希桶号
		size_t bucketNo = hashFunc(data);
		//查找元素
		Node* prev = nullptr;
		Node* cur = _table[bucketNo];
		while (cur) {
			if (cur->data == data) {
				if (prev == nullptr) {
					_table[bucketNo] = cur->next;
					delete cur;
					cur = nullptr;
					_size--;
					return true;
				}
				else {
					prev->next = cur->next;
					delete cur;
					_size--;
					return true;
				}
			}
			else
			{
				prev = cur;
				cur = cur->next;
			}	
		}
		return false;
	}
	void Erase_Repttitiom(const T& data) {
	    //删除与data相等的所有元素
		//通过哈希函数计算哈希桶号
		size_t bucketNo = hashFunc(data);
		Node* cur = _table[bucketNo];
		Node* prev = nullptr;
		while (cur) {
			if (cur->data == data) {
				if (prev == nullptr) {
					_table[bucketNo] = cur->next;
					delete cur;
					cur = _table[bucketNo];
					_size--;

				}
				else {
					prev->next = cur->next;
					delete cur;
					_size--;
					cur = prev;
				}
		    }
			else {
				prev = cur;
				cur = cur->next;
			}

		}
	}
	~hashBucket()
	{
		Clear();
	}
	void Print() {
		for (int i = 0; i < _table.size(); i++) {
			Node* cur = _table[i];
			while (cur) {
				cout << cur->data << " ";
				cur = cur->next;
			}
			cout << "\n";
		}
	}
	size_t Size() {
		return _size;
	}
	//获取桶的数量
	size_t BucketNumber() {
		return _table.size();
	}
private:
	vector<Node*>  _table;
	size_t _size;
private:
	void Clear() {
		for (int i = 0; i < _table.size(); i++) {
			Node* cur = nullptr;
			while (cur) {
				Node* cur = _table[i]->next;
				_table[i] = cur->next;
				delete cur;
			}
		}
		_size = 0;
	}
};

哈希和哈希桶
TONGtongTONG000的博客
11-02 2180
概念 数据结构中有一类常用于搜索，给定一个元素集合，常见的可用于搜索的算法有 遍历，遍历是十分粗暴简单的手段，对于元素的集合没有特殊要求，时间复杂度是O(N)。效率通常较低。 二分查找，二分查找要求元素集合有序，时间复杂度为O(logN), 二叉搜索树，查找规则简单，但是退化为单支树时间复杂度是O(N), AVL树和红黑树，时间复杂度都是O(logN). 上面的这些常用的方法无一例外都有一个关键步骤就是元素的比较，通过比较待查找元素和集合中的元素，来确定该元素在集合中的位置。真实的效率取决于比较的次数。 如
哈希桶的实现
xc的博客
04-07 1271
哈希桶用于哈希冲突的解决，也叫做开链法或拉链法。#include #include #include using namespace std; template struct HashBucketNode { K _key; V _value; HashBucketNode* _next; HashBucketNode(const K& key, const V& value)
哈希桶
weixin_33943347的博客
05-16 146
哈希桶：建一个存放指针的数组，将hash出的key跟数组的下标进行对应，将对应的数据链接到该位置。eg：要存11 22 24 34 54 36利用模除算出位置：11%10=121%10=124%10=434%10=454%10=436%10=6代码实现： #define_CRT_SECURE_NO_WARNINGS #include<iostream> us...
【C++ STL】哈希 Hash（闭散列、开散列介绍及其实现）
codewinter的博客
06-26 3092
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 O(log2N)，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个 unordered 系列的关联式容器，这4个容器与红黑树结构的关联式容器底层结构不同，是哈希表（哈希其实就是一种散列，一种映射）哈希表结构的 unordered 系列的关联式容器与红黑树结构的关联式容器 map/set/multimap/mul
【C++】用哈希桶模拟实现unordered_set和unordered_map
2301_77459845的博客
03-24 1559
顺序结构中（数组）查找一个元素需要遍历整个数组，时间复杂度为O(N)；树形结构中（二叉搜索树）查找一个元素，时间复杂度最多为树的高度次logN。可以不经过任何比较，一次直接从表中得到要搜索的元素。构造一种存储结构，通过某种函数使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。主要有3种操作：插入——根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放查找。
c++哈希（哈希表闭散列线性探测实现）
Dingyuan0的博客
11-09 1208
闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。那如何寻找下一个空位置呢？EMPTY , //空标记 EXIST , //存在 DELETE //删除 };};public :// 插入 bool Insert(const pair < K , V > & kv);// 查找 HashDate < K , V > * Find(const K & key);
哈希表、哈希桶（C++实现）
weixin_45599288的博客
01-26 3965
哈希表、哈希桶哈希概念哈希函数哈希冲突解决哈希冲突闭散列线性探测闭散列的实现哈希表的结构哈希表的插入哈希表的查找哈希表的删除开散列哈希概念 哈希概念 在顺序结构和平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，O(logN )，搜索的效率取决于搜索过程中元素的比较次数。 而理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存
C++STL-无序容器-哈希表（散列存储）
Iamasleep的博客
04-22 2429
1. 为什么要设计哈希表——查找元素效率高 O(1) 2. 通过什么机制实现的——关键字通过哈希函数O(1)可以直接确定哈希地址，常见的有直接定址法、除留余数法 3. 会产生什么问题——不同的关键字可能会得到相同的哈希地址，称为哈希碰撞 4. 如何解决哈希碰撞——闭散列找空位置（每次向后找1或i^2），或者开散列建哈希桶**
哈希桶的实现（拉链法）
MBuger的博客
03-16 5056
简介为了解决线性探测实现哈希表时出现哈希冲突后导致数据堆聚的现象，我们采取了另一种结构来处理哈希冲突，哈希桶（拉链法），拉链法解决冲突的做法是将所有通过哈希函数计算出来的哈希地址相同的结点存放在一个单链表之中。 实现原理就是将哈希表定义为一个由N个头指针组成的指针数组，经过哈希函数计算得到的哈希地址相同的数据全部连在对于的头指针下面。它继承了数组的易于查找和链表便于删除插入的特点。时间复杂度拉链法
哈希桶的实现（代码版）
weixin_61436104的博客
02-10 190
哈希桶实现
Hash桶实现hash表
lj19890902的专栏
01-17 967
链接地址： http://blog.youkuaiyun.com/wangpengqi/article/details/9716315
哈希表开散列哈希桶实现
weixin_44785983的博客
02-15 265
开散列法对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点组成 一个向量，因此，向量的元素个数与可能的桶数一致。 #include <iostream> using namespace std; namespace OpenHash { template<class T> ...
哈希--哈希桶
最新发布
popingcat的博客
03-25 658
上面的代码要注意的是它的扩容，它直接重新申请一个数组链表，而不是像开放地址法一样，进行一个重新搞一个对象，然后在对象的新表里面进行挪动数据了。现在哈希桶的这个扩容方法减少了insert的调用！哈希桶是哈希表（散列表）中的一个概念，是哈希表数组中的每个元素 ，用于存储键值对数据。
C++--哈希表--开散列（哈希桶的模拟实现）--1110
qq_68741368的博客
11-11 469
手把手教你模拟开散列的哈希表
为什么哈希桶内部的迭代器不能复用
03-12
哈希桶内部的迭代器不能复用是因为哈希桶的结构是基于哈希函数的，每个元素都被映射到不同的位置，因此在遍历哈希桶时需要按照哈希函数的规则一个一个地访问元素，无法直接跳到下一个元素的位置。因此，每次遍历哈希...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小明学编程~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值