【C++】学习笔记——哈希_2

news2024/11/15 12:22:44

文章目录

  • 十八、哈希
    • 3. 实现哈希表
      • 哈希表的存储节点
      • 哈希函数
      • 哈希表的定义
      • 哈希表的插入
      • 哈希表的查找
      • 哈希表的删除
      • 测试函数
      • 完整代码+结果
  • 未完待续

十八、哈希

3. 实现哈希表

哈希表的实现方法有蛮多种，这里我们选一个比较经典的开散列法来实现哈希表。由于STL库里的哈希表都是将负载因子（插入的数据/哈希表的容量）设置为1，所以我们这里也将负载因子设置为1。

哈希表的存储节点

开散列法实现的哈希表，是通过数组来当哈希表，但是数组中存储的都是指针，像一个链表一样，将同索引的数据在这个指针下串联起来。

// 哈希表数据节点类型
template<class K, class V>
struct HashNode
{
    // 指向同一个桶的下一个节点
	HashNode<K, V>* _next;
    // 当前数据
	std::pair<K, V> _kv;

	HashNode(const std::pair<K, V>& kv)
		:_next(nullptr)
		,_kv(kv)
	{}
};

哈希函数

哈希表是通过哈希函数来确定存储的位置的，但是对于不同的类型，我们无法统一看待。

// 哈希函数
template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

// 哈希函数模板特化
template<>
struct HashFunc<std::string>
{
	size_t operator()(const std::string& s)
	{
		// 哈希值
		size_t hash = 0;
		for (auto e : s)
		{
			hash += e;
			hash *= 131;
		}

		return hash;
	}
};

哈希表的定义

// 哈希表， Hash是仿函数（哈希函数）
template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
	typedef HashNode<K, V> Node;
public:
	// 构造函数
	HashTable()
	{
		_tables.resize(10, nullptr);
		_n = 0;
	}

	// 析构函数
	~HashTable()
	{
		// 遍历每个桶
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			// 遍历每个桶的每个数据节点
			while (cur)
			{
				Node* next = cur->_next;
				delete cur;
				cur = next;
			}
			_tables[i] = nullptr;
		}
	}
private:
    // 哈希表每个位置都是一个链表（桶）
	std::vector<Node*> _tables;
    // 数据个数
	size_t _n;
};

哈希表的插入

// 插入数据
bool Insert(const std::pair<K, V>& kv)
{
    // 该数据存在就不插入
	if (Find(kv.first))
		return false;

    // 创建哈希函数对象
    Hash hs;

	// 负载因子到1就扩容（满了才扩容）
	if (_n == _tables.size())
	{
        // 创建临时哈希表对象
		std::vector<Node*> newTables(_tables.size() * 2, nullptr);
        // 遍历每个桶
		for (size_t i = 0; i < _tables.size(); ++i)
		{
			// 遍历桶中的每个数据节点
			Node* cur = _tables[i];
			while (cur)
			{
				Node* next = cur->_next;

				// 通过哈希函数计算索引，将旧节点头插到新表
				size_t hashi = hs(cur->_kv.first) % newTables.size();
                // 新节点指向原本的首元节点
				cur->_next = newTables[hashi];
                // 头指针指向新节点
				newTables[hashi] = cur;

				cur = next;
			}

			_tables[i] = nullptr;
		}

        // 交换表
		_tables.swap(newTables);
	}

    // 通过哈希函数计算索引
	size_t hashi = hs(kv.first) % _tables.size();
	Node* newnode = new Node(kv);

	// 头插
	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;

    // 数据个数+1
	++_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)
{
    // 哈希函数对象
	Hash hs;
    // 通过哈希函数查找所在的桶
	size_t hashi = hs(key) % _tables.size();
    // 遍历
	Node* prev = nullptr;
	Node* cur = _tables[hashi];
	while (cur)
	{
		if (cur->_kv.first == key)
		{
			// 删除
			if (prev)
			{
				prev->_next = cur->_next;
			}
			else
			{
				_tables[hashi] = cur->_next;
			}

			delete cur;

			--_n;
			return true;
		}

		prev = cur;
		cur = cur->_next;
	}

	return false;
}

测试函数

void TestHT1()
{
	HashTable<int, int> ht;
	int a[] = { 1,4,24,34,7,44,17,37 };
	for (auto e : a)
	{
		ht.Insert(std::make_pair(e, e));
	}

	ht.Insert(std::make_pair(5, 5));
	ht.Insert(std::make_pair(15, 15));
	ht.Insert(std::make_pair(25, 25));

	ht.Erase(5);
	ht.Erase(15);
	ht.Erase(25);
	ht.Erase(35);

	HashTable<std::string, std::string> dict;
	dict.Insert(std::make_pair("sort", "排序"));
	dict.Insert(std::make_pair("string", "字符串"));
}

完整代码+结果

HashTable.h：

#pragma once

#include <iostream>
#include <vector>
#include <string>

// 哈希函数
template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

// 哈希函数模板特化
template<>
struct HashFunc<std::string>
{
	size_t operator()(const std::string& s)
	{
		size_t hash = 0;
		for (auto e : s)
		{
			hash += e;
			hash *= 131;
		}

		return hash;
	}
};

namespace hash_bucket
{
    // 哈希表数据节点类型
	template<class K, class V>
	struct HashNode
	{
        // 指向同一个桶的下一个节点
		HashNode<K, V>* _next;
        // 当前数据
		std::pair<K, V> _kv;

		HashNode(const std::pair<K, V>& kv)
			:_next(nullptr)
			,_kv(kv)
		{}
	};

    // 哈希表
	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
        // 构造函数
		HashTable()
		{
			_tables.resize(10, nullptr);
			_n = 0;
		}

        // 插入数据
		bool Insert(const std::pair<K, V>& kv)
		{
            // 该数据存在就不插入
			if (Find(kv.first))
				return false;

            // 创建哈希函数对象
            Hash hs;

			// 负载因子到1就扩容(满了才扩容)
			if (_n == _tables.size())
			{
                // 创建临时哈希表对象
				std::vector<Node*> newTables(_tables.size() * 2, nullptr);
                // 遍历每个桶
				for (size_t i = 0; i < _tables.size(); ++i)
				{
					// 遍历桶中的每个数据节点
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;

						// 通过哈希函数计算索引，将旧节点头插到新表
						size_t hashi = hs(cur->_kv.first) % newTables.size();
                        // 新节点指向原本的首元节点
						cur->_next = newTables[hashi];
                        // 头指针指向新节点
						newTables[hashi] = cur;

						cur = next;
					}

					_tables[i] = nullptr;
				}

                // 交换表
				_tables.swap(newTables);
			}

            // 通过哈希函数计算索引
			size_t hashi = hs(kv.first) % _tables.size();
			Node* newnode = new Node(kv);

			// 头插
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;

            // 数据个数+1
			++_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)
		{
            // 哈希函数对象
			Hash hs;
            // 通过哈希函数查找所在的桶
			size_t hashi = hs(key) % _tables.size();
            // 遍历
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					// 删除
					if (prev)
					{
						prev->_next = cur->_next;
					}
					else
					{
						_tables[hashi] = cur->_next;
					}

					delete cur;

					--_n;
					return true;
				}

				prev = cur;
				cur = cur->_next;
			}

			return false;
		}

		// 析构函数
		~HashTable()
		{
			// 遍历每个桶
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				// 遍历每个桶的每个数据节点
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				_tables[i] = nullptr;
			}
		}
	private:
        // 哈希表每个位置都是一个链表（桶）
		std::vector<Node*> _tables;
        // 数据个数
		size_t _n;
	};

	void TestHT1()
	{
		HashTable<int, int> ht;
		int a[] = { 1,4,24,34,7,44,17,37 };
		for (auto e : a)
		{
			ht.Insert(std::make_pair(e, e));
		}

		ht.Insert(std::make_pair(5, 5));
		ht.Insert(std::make_pair(15, 15));
		ht.Insert(std::make_pair(25, 25));

		ht.Erase(5);
		ht.Erase(15);
		ht.Erase(25);
		ht.Erase(35);

		HashTable<std::string, std::string> dict;
		dict.Insert(std::make_pair("sort", "排序"));
		dict.Insert(std::make_pair("string", "字符串"));
	}
}

test.cpp：

#include <iostream>
#include "HashTable.h"
using namespace std;

int main()
{
    hash_bucket::TestHT1();
    return 0;
}

结果：
在这里插入图片描述
在这里插入图片描述

未完待续

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1943361.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

使用PicGo操作gitee图床(及web端html不能访问图片的解决办法)

使用PicGo操作gitee图床(及web端html不能访问图片的解决办法)

1.新建仓库 2.输入仓库名称，也就是图床名称，必须设置开源可见 也可以在创建仓库后，点击管理->基本信息->是否开源进行设置 鼠标悬浮到右上角头像->设置 点击私人令牌 点击生成新令牌,填写描述,直接点提交即可 点击提交后输入登录密码会生成一个token秘钥,如下,这个…
阅读更多...
新版本异次元荔枝V4自动发卡系统源码

新版本异次元荔枝V4自动发卡系统源码

新版本异次元荔枝V4自动发卡系统源码&#xff0c;增加主站货源系统&#xff0c;支持分站自定义支付接口&#xff0c;目前插件大部分免费&#xff0c;UI页面全面更新&#xff0c;分站可支持对接其他分站产品&#xff0c;分站客服可自定义&#xff0c;支持限定优惠。 源码下载&a…
阅读更多...
matlab--legend利用for循环添加图例

matlab--legend利用for循环添加图例

第一种方法 %% 第一种方法 R 1:4; THETA1 atand(R./1.8); legend_name {}; for i 1:4THETA atand(R(i)./1.8);intTheta floor(THETA);R_THERA 1.8 - (R(i)./tand(intTheta-10:intTheta10));R_THERA1 1.8 - (R(i)/tand(intTheta));plot(R_THERA);grid on;hold onlegend…
阅读更多...
Git之repo sync -c与repo sync -dc用法区别(四十八)

Git之repo sync -c与repo sync -dc用法区别(四十八)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 优质专栏&#xff1a;Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 优质专栏&#xff1a;多媒…
阅读更多...
了解Linux中的shell脚本

了解Linux中的shell脚本

目录 1、什么是shell 2、编写第一个shell文件 3、shell的权限 4、变量 5、 shell传递参数 6、shell数组 7、shell基本运算符 7.1 算术运算符 7.2 关系运算符 7.3 布尔运算符 7.4 逻辑运算符 7.5 字符串运算符 8、控制语句 8.1 if 8.2 for 8.3 while语句 9、其他 1、…
阅读更多...
C++~~string模拟实现（3）

C++~~string模拟实现（3）

目录 1.传统写法和现代写法 2.对于流提取的优化 3.简单机制了解 4.string类的几个构造函数总结 4.1基本用法 4.2两个赋值方式 4.3拷贝构造 4.4获取字符 4.5一个容易混淆的对比 4.6创建对象 1.传统写法和现代写法 &#xff08;1&#xff09;上面的代码里面的左边部分是…
阅读更多...
排序---归并排序

排序---归并排序

归并排序 一、定义二、实现原理三、代码实现 一、定义 归并排序&#xff08;MERGE-SORT&#xff09;是建立在归并操作上的一种有效的排序算法,该算法是采用分治法&#xff08;Divide andConquer&#xff09;的一个非常典型的应用。将已有序的子序列合并&#xff0c;得到完全有…
阅读更多...
ES中聚合查询之date_histogram查询出现key_as_string 和 key含义

ES中聚合查询之date_histogram查询出现key_as_string 和 key含义

ES中聚合查询之date_histogram查询出现key_as_string 和 key含义 DSL语句 #实例 GET /capture_features_202407/_search {"query": {"bool": {"must": [{"terms": {"plateNo": ["汉A00001"]}},{"range&quo…
阅读更多...
【C++】——初识模版

【C++】——初识模版

文章目录 前言函数模版函数模版的原理函数模版的实例化 类模版类模版的实例化 前言 当我们使用一个通用的函数&#xff1a; //为每一个类型都编写一个重载版本 void Swap(int& left, int& right) {int temp left;left right;right temp; } void Swap(double& …
阅读更多...
Java实现七大排序（一）

Java实现七大排序（一）

目录 一.插入排序 1.直接插入排序 2.希尔排序 二.选择排序 1.选择排序 2.堆排序 三.总结 一.插入排序 1.直接插入排序 直接插入排序的原理与线下玩扑克牌类似。我们拿到一张牌后要排序&#xff0c;方法就是一张一张对。直接插入排序也是这样的&#xff0c;我们得到一张…
阅读更多...
融云 2024 ChinaJoy | 你有一个必逛的展位 @W4 馆 B786

融云 2024 ChinaJoy | 你有一个必逛的展位 @W4 馆 B786

惊喜闪现&#x1f447; 打开抖音搜索【融云】 关注融云官抖&#xff0c;可到展位领取好礼一份 更有惊喜内容不定时掉落~
阅读更多...
【CTFWP】ctfshow-web32

【CTFWP】ctfshow-web32

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 题目介绍&#xff1a;题目分析&#xff1a;payload&#xff1a;payload解释&#xff1a;flag 题目介绍&#xff1a; <?php/* # -*- coding: utf-8 -*- # Autho…
阅读更多...
昇思25天学习打卡营第23天|ShuffleNet图像分类

昇思25天学习打卡营第23天|ShuffleNet图像分类

ShuffleNet网络介绍 ShuffleNetV1是旷视科技提出的一种计算高效的CNN模型&#xff0c;和MobileNet, SqueezeNet等一样主要应用在移动端&#xff0c;所以模型的设计目标就是利用有限的计算资源来达到最好的模型精度。ShuffleNetV1的设计核心是引入了两种操作&#xff1a;Pointw…
阅读更多...
誉天Cloud Service Solutions Architect（云服务）怎么样

誉天Cloud Service Solutions Architect（云服务）怎么样

誉天云服务课程亮点 深度融合云原生 包含原生K8s和docker内容&#xff0c;引入isito和ASM功能进行微服务治理&#xff0c;结合Linux功底设计云上性能优化&#xff0c;和架构设计。师资力量强大 课程由两名5HCIE认证讲师授课&#xff0c;认证辅导由已通过HCIE-Cloud Service专职…
阅读更多...
【数据结构】探索排序的奥秘

【数据结构】探索排序的奥秘

若有不懂地方&#xff0c;可查阅我之前文章哦&#xff01; 个人主页&#xff1a;小八哥向前冲~_csdn博客 所属专栏&#xff1a;数据结构_专栏 目录 排序的概念 几种排序方法介绍 冒泡排序 选择排序 插入排序 堆排序 向上调整建堆排序 向下调整建堆排序 希尔排序 快速…
阅读更多...
【数学建模】——前沿图与网络模型：新时代算法解析与应用

【数学建模】——前沿图与网络模型：新时代算法解析与应用

目录 1.图与网络的基本概念 1. 无向图和有向图 2. 简单图、完全图、赋权图 3. 顶点的度 4. 子图与图的连通性 2.图的矩阵表示 1. 关联矩阵 2. 邻接矩阵 3.最短路问题 1.Dijkstra 算法 2.Floyd 算法 4.最小生成树问题 1.Kruskal 算法 2.Prim 算法 5.着色问题 6.…
阅读更多...
【AI大模型】程序员AI的未来——Copilot还是Claude3.5 Sonnet？

【AI大模型】程序员AI的未来——Copilot还是Claude3.5 Sonnet？

近期&#xff0c;Anthropic发布了Claude 3.5 的“大杯”模型 —— Claude 3.5 Sonnet&#xff01; 这次发布的 Sonnet 代表意大利的“十四行诗”&#xff0c;结构复杂&#xff0c;在智能水平、功能多样性和处理能力上都有所提升&#xff0c;能够应对更复杂的认知任务&#xff…
阅读更多...
进程与进程函数

进程与进程函数

目录 进程与程序 1.1进程是什么 1.2程序&#xff0c;进程之间的关系 1.3进程的生存环境 1.4进程的状态转换 1.5关于内核层与用户层 1.6保存和恢复处理器现场 进程原语 2.1fork() ​编辑 2.1.1父子进程的继承 2.1.2父子进程共享fork()栈帧 2.1.3打印进程id和父进程i…
阅读更多...
【OpenREALM学习笔记：14】单目视觉SLAM方法在UAV影像上重建三维地形的思考

【OpenREALM学习笔记：14】单目视觉SLAM方法在UAV影像上重建三维地形的思考

最近在学习SLAM技术与测绘三维影像重建的相关知识&#xff0c;结合自己的感受&#xff0c;撰写一下对于单目视觉SLAM利用无人机影像重建三维地形的一些看法。 1. 单目视觉SLAM系统在三维地形重建中所面临的挑战有哪些&#xff1f; 单目视觉SLAM众所周知的一个问题是&#xff…
阅读更多...
C# 委托函数 delegate

C# 委托函数 delegate

在C#中&#xff0c;委托&#xff08;Delegate&#xff09;是一种特殊的类型&#xff0c;它可以持有对方法的引用。 委托是实现事件的基础。事件本质上是多播委托&#xff0c;允许多个方法被触发 委托允许你将方法作为参数传递给其他方法&#xff0c;或者将方法作为返回值从方法…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023