哈希 （含python代码）

最新推荐文章于 2025-01-03 09:22:02 发布
原创 最新推荐文章于 2025-01-03 09:22:02 发布 · 696 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了哈希（散列）的概念、哈希表的作用以及哈希函数的构造方法，包括除留余数法、数字分析法、平方取中法、分段叠加法和基数转换法。接着讨论了处理哈希冲突的开放寻址法和链地址法，并通过Python代码展示了这两种方法。最后，概述了哈希表的操作，如生成key、插入、查找和删除。
  • 哈希（hash）也叫散列；是把任意长度的输入，通过哈希算法，变换成固定长度的输出，所输出的称为哈希值（哈希值所占的空间一般来说远小于输入值的空间，不同的输入可能会哈希出相同的输出）。
  • 在数据结构中，使用Hash算法的数据结构叫做哈希表，也叫散列表，主要是为了提高查询的效率。它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数就是hash函数，存放记录的数组叫做哈希表。在数据结构中应用时，有时需要较高的运算速度而弱化考虑抗碰撞性，可以使用自己构建的哈希函数。

1. hash函数的构造方法

hash函数的构造原则是：简单和均匀
即：

hash函数本身运算尽量简单，便于计算；
hash函数值必须在散列地址范围内，且分布均匀，冲突尽可能少；

下面是几种常用的hash函数构造方法：

  • （1） 除留余数法
    该方法是为简单的一种方法
    h（key）=m%p ; m为表长，p为<=m的最大素数
    关于p的选取：p应为不大于m的质数或不含20以下的质因子。如果p选取不当，会增加冲突的可能性
    例：
    在这里插入图片描述
  • （2）数字分析法
    在这里插入图片描述
  • （3） 平方取中法
    由于整数相除的运行速度通常比乘慢，因此有意识的避免除余法可以提高散列算法的运行时间。

平方取中法的具体方法是：首先通过求关键字的平方值扩大相近数的差别，然后根据表长度取中间的几位数作为hash值。因为一个乘积的中间几位数和乘数的每一位都相关，所以由此产生的散列地址比较均匀。

例：将（0100，0110，1010，1001，0111）平方后得（0010000，0012100，1020100，1002001，0012321），若表长位1000，则取中间3位数作为散列地址，即（100，121，201，020，123）

  • (4) 分段叠加法
    有时关键子所含的位数很多，平方取中法计算太复杂，则可将关键字分割成位数相同的几部分（最后一部分的位数可以不同），然后取这几部分进行叠加，叠加和（舍去进位）作为散列地址。具体的叠加方式有移位叠加和折叠叠加。
    例：key=926483715503
    移位叠加：h（key）=627
    折叠叠加：h（key）=330
    在这里插入图片描述

  • （5）基数转换法
    在这里插入图片描述

在实际应用中，根据实际情况选择采用恰当的散列方法，并用实际数据测试它的性能，，以便作出正确判定。
一般考虑以下因素：
（1） 计算hash函数所需时间
（2） 关键字长度
（3） 散列表大小
（4） 关键字分布的情况
（5） 记录查找的频率

2. 处理冲突的方法

2.1 开放寻址法

python中的字典，就是先求出散列值，然后用散列值取余就是存放的位置，有冲突时用开放寻址法解决
也叫再散列法，

基本思想：当key的初始散列地址h0出现冲突时，以h0位基础查找下一个地址h1，如果h1仍然冲突，以h0为基础产生另一个散列地址h2…直到找到不冲突的地址hi，将相应元素存入其中即可

公式：hi=(h(key)+di)%m
h(key)是哈希函数； m是表长； di为增量序列，增量有下面三种取值方式

  • （1） 线性探测再散列
    di=c*i
    最简单的情况：c=1
    冲突发生时，顺序查看表中的下一个单元，直到找到一个空单元或查遍全表
    例：对关键字列表为[19,01,23,14,55,68,11,82,36]，设定表长m为11；用线性探测再散列处理冲突。
    在这里插入图片描述
  • （2）二次探测再散列
    di=1 * *2，- 1 * *2，2 * *2，- 2 * *2…k * *2,- k * *2(k<=m/2)

冲突发生时,分别在左右进行跳跃式探测，较灵活，不易产生聚集，但缺点是不能探查到整个散列地址空间

对于上例，用二次探测再散列的方法解级冲突
在这里插入图片描述

  • （3） 随机探测再散列
    di=为随机数
    这种方法需要一个随机数发生器，并给定一个随机数作为起始点。
2.2 链地址法

基本思想：把具有冲突的关键字链在同一个单链表中。

例：对上例，设定h（key）=key%7
在这里插入图片描述
在这里插入图片描述

3. 操作

结点属性：

class Hash(object):
    def __init__(self):
        # 存放 开放定址法的哈希键值
        self.data={}
        # 存放链地址法的哈希键值
        self.data_map={}
        # 可在这里指定m
        # self.length=m
3.1 生成新的key

也就是hash函数h（key）

    def change_key(self,key,m,di):
        #因为负数的%运算和我们预期的结果不一样，需要调整
        if key+di<0:
            return -(((-di)-key)%m)
        return (key+di)%m
3.2 插入
  • 根据开放定址处理冲突法 插入
    基本思想：待插数据的key冲突时，根据 开放定址法生成新的key，继续比较…直至key不冲突，把值填入即可
    # 开放定址法插入
    def insert(self,value,m):
        key=value%m
        while key in self.data:
            # 如果某个值是DEL，说明它被删掉了
            if self.data[key]=='DEL':
                self.data[key] = value
                return
            #线性探测再散列
            key=self.change_key(key,m,1)
        self.data[key]=value
  • 根据链地址处理冲突法 插入
    基本思路：根据待插值生成key，如果key已经存在，把值加入到key对应的链表中，如过不存在，给这个key新建一个链表，把值加入即可
    # 链地址法插入，key对应的值是一个列表，里面存放的是key冲突的值
    def insert2(self,value,m):
        key=value%m
        # 已经存在的话，直接加入列表中即可
        if key in self.data_map:
            self.data_map[key].append(value)
        # 第一次出现需要建一个列表
        else:
            temp=[]
            temp.append(value)
            self.data_map[key]=temp
3.3 查找
  • 线性探测再散列方法查找：

基本思想：根据待查找的值生成key，如果key对应的值和待查找的值不同时，继续生成新的key，直至找到返回

    # 查找--线性探测再散列
    def find(self,value,m):
        key=value%m
        while key in self.data:
            if self.data[key]==value:
                return key
            # 线性探测再散列
            key=self.change_key(key,m,1)

        return False
  • 二次探测再散列的方法查找
    #查找--二次探测再散列的方法
    def find2(self,value,m):
        key=value%m
        key_new=key
        i=1
        j=1
        while key_new in self.data:
            if self.data[key_new]==value:
                return key_new
            #j用来控制正负
            di=i*i*j
            key_new=self.change_key(key,m,di)
            # key<时，找到对应的key
            if key_new<0:
                key_new=len(self.data)+key_new+1
            if j>0:
                j=-1
            else:
                i+=1
                j=1

        return False
3.4 删除
  • 开放定址法的 删除
    基本思路，找到要删除的数的key，把key对应的值设置成‘DEL‘，注意，这里不能删除，因为会找不到它之后插入的冲突的数
    # 删除
    def delete(self,value,m):
        key=self.find(value,m)
        if key:
            self.data[key]='DEL'
        else:
            print('%s不存在' %(value))
  • 链地址法的删除
    根据值生成key，遍历key对应的链，找到后删掉就好
    def delete_map(self,value,m):
        key=value%m
        print(key)
        if key in self.data_map:
            for i in self.data_map[key]:
                if i==value:
                    del i
                    return

全部代码

class Hash(object):
    def __init__(self):
        # 存放 开放定址法的哈希键值
        self.data={}
        # 存放链地址法的哈希键值
        self.data_map={}
        # 可在这里指定m
        # self.length=m

    def change_key(self,key,m,di):
        #因为负数的%运算和我们预期的结果不一样，需要调整
        if key+di<0:
            return -(((-di)-key)%m)
        return (key+di)%m

    # 开放定址法插入
    def insert(self,value,m):
        key=value%m
        while key in self.data:
            # 如果某个值是DEL，说明它被删掉了
            if self.data[key]=='DEL':
                self.data[key] = value
                return
            #线性探测再散列
            key=self.change_key(key,m,1)
        self.data[key]=value
    # 链地址法插入，key对应的值是一个列表，里面存放的是key冲突的值
    def insert2(self,value,m):
        key=value%m
        # 已经存在的话，直接加入列表中即可
        if key in self.data_map:
            self.data_map[key].append(value)
        # 第一次出现需要建一个列表
        else:
            temp=[]
            temp.append(value)
            self.data_map[key]=temp
    #输出存放 开放定址法的哈希键值
    def print_hash(self):
        for h in self.data:
            print(h,':',self.data[h])
    # 输出存放 链地址法的哈希键值
    def print_hash_map(self):
        for h in self.data_map:
            print(h,':',self.data_map[h])

    # 查找--线性探测再散列
    def find(self,value,m):
        key=value%m
        while key in self.data:
            if self.data[key]==value:
                return key
            # 线性探测再散列
            key=self.change_key(key,m,1)

        return False
    #查找--二次探测再散列的方法
    def find2(self,value,m):
        key=value%m
        key_new=key
        i=1
        j=1
        while key_new in self.data:
            if self.data[key_new]==value:
                return key_new
            #j用来控制正负
            di=i*i*j
            key_new=self.change_key(key,m,di)
            # key<时，找到对应的key
            if key_new<0:
                key_new=len(self.data)+key_new+1
            if j>0:
                j=-1
            else:
                i+=1
                j=1

        return False
    # 删除
    def delete(self,value,m):
        key=self.find(value,m)
        if key:
            self.data[key]='DEL'
        else:
            print('%s不存在' %(value))
    def delete_map(self,value,m):
        key=value%m
        print(key)
        if key in self.data_map:
            for i in self.data_map[key]:
                if i==value:
                    del i
                    return



if __name__ == '__main__':
    h=Hash()
    m=11
    h.insert(1,m)
    h.insert(23,m)
    h.insert(12,m)
    h.delete(1,m)
    h.print_hash()
    h.insert(1,m)
    h.print_hash()
    print(h.find(23,m))
    # h.insert(13,m)
    # h.insert(28,m)
    #
    # h.print_hash()
    # print('--------------')
    # h.insert2(2,m)
    # h.insert2(13,m)
    # h.insert2(15,m)
    # h.insert2(4,m)
    # h.print_hash_map()
    # print('-------------')
    # print(h.find(2,m))
    # print(h.find(18,m))
    # print('------------')
    # print(h.find2(13,m))
    # print((-(-4)-2)%11)
    # print('--------------')
    # h.delete(15,m)
    # h.print_hash()

    # h.insert2(11,m)
    # h.insert2(8,m)
    # h.insert2(22,m)
    # h.insert2(15,m)
    # h.delete_map(11,m)
    # h.print_hash_map()
Python 中 MD5 哈希函数的实现
Python中文社区
01-11 5444
在本文中，我们将学习Python中的MD5加密，并详细讨论其含义和用法。包括以下内容：什么是MD5？Python中的MD5哈希与md5相关的功能示例1：在Python中打印等效于MD5哈...
哈希算法python_哈希算法（Python代码实现）
weixin_39777464的博客
12-08 2449
1.常见的数据查找算法：众所周知，顺序查找是最简单的查找方式，但要将所有数据遍历一遍所以效率相对较低，对大数据量的査找问题显然不行。二分查找的查找效率虽然非常高但是数据必须有序，而对数据排序通常需要更多的时间，因此只适用于在排好序的数据中找。而深度优先搜索算法、广度优先搜索算法 ，是一种暴力査找法优化算法，同样对大数据量的查找问题效率也不高。哈希算法也是一种查找算法，可以说哈希算法是最快的查找算法...
感知哈希算法(Python版)
04-20
Python3实现基于PHA实现图像配准
哈希表及其常用算法(代码实现)
热门推荐
阳光下七月的线条
04-23 2万+
整理了一下Hash表相关内容，如下： Hash 表是使用 O(1) 时间进行数据的插入删除和查找，但是 hash 表不保证表中数据的有序性，这样在 hash 表中查找最大数据或者最小数据的时间是 O(N) 。 1 寻址和 hash 函数          理想状态下 hash 足够大，每一数据保存在一个 hash 存储单元内，这样对于插入删除和查找某一个数据就可以直接
Python 哈希函数
ruyi的博客
10-09 969
简单的记录hashlib的使用
用python写一段关于语义哈希算法的代码
weixin_35755640的博客
12-17 191
语义哈希算法是一种用于计算文本相似度的算法。它通过将文本转换为固定长度的数字来实现这一目的。下面是一段使用 Python 实现语义哈希算法的代码示例： import numpyas np def semantic_hash(text, hash_size=64): # 对文本进行分词 words = text.split() # 建立一个关于单词的哈希桶 buck...
python 哈希表实现简单python字典代码实例
09-18
本文将深入探讨Python中的哈希表实现，特别是基于简单哈希表的字典代码实例。 首先，我们来看一个简单的哈希表实现，它由两个类组成：Array 和 Slot。Array 类是一个简单的动态数组，用于存储槽（Slot）对象。初始...
使用python的 一致哈希算法_python_代码_下载
06-08
这个压缩包“consistent-hash-master”很可能包含了一个Python实现一致哈希的代码示例。 在分布式缓存、负载均衡系统中，一致哈希算法扮演了关键角色。传统的哈希算法将数据均匀分布到固定数量的节点上，但当节点...
python实现哈希表代码
11-08
- 哈希函数 `hash_function`：使用Python内置的 `hash` 函数和模运算来获取键的哈希值，并保证索引在哈希表的大小范围内。 - 插入方法 `insert`：根据哈希值将键值对插入到哈希表的对应位置。 - 获取方法 `get`：...
哈希算法在python中的调用代码实例
04-30
这段代码会计算给定字符串的MD5哈希值，并以16进制的形式打印出来。 总之，哈希算法在Python中扮演着至关重要的角色，无论是在基础数据结构的设计还是在安全性需求的实现上，都是不可或缺的一部分。通过深入理解并...
哈希算法源码
04-03
该源码实现了SHA1 SHA224 SHA384 SHA256 SHA512的功能，同时能对文件和字符串进行摘要算法。
SHA-3 哈希摘要算法 python 源代码及官方文档
09-25
本压缩包包括 SHA-3 python源代码，和官方文档。 hash 结果为 标准 hash 值，注释详细，适合初学者。 本代码实现的是 SHA-3 512 hash 算法。 现列出本代码 空字符 hash 值 便于检验 ('a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26') 可以用 python3 自带 hashlib 类检验
一致性哈希算法源码 Ketama一致性hash算法源码
11-28
Ketama算法是一致性hash算法的一个优秀实现。增删节点后数据命中率及均分率都很高。
常用哈希算法代码实现
02-15
多种哈希算法代码，用于文件校验、简单加密等场合。
blake3-py:BLAKE3加密哈希函数的Python绑定
05-01
布雷克3-py 用于基于的Python绑定。 这些绑定公开了BLAKE3的所有功能，包括可扩展的输出，键控和多线程。 基本的API与Python的标准模块的API相匹配。 例子 from blake3 import blake3 # Hash some input all at once. The input can be bytes, a bytearray, or a memoryview. hash1 = blake3 ( b"foobarbaz" ). digest () # Hash the same input incrementally. hasher = blake3 () hasher . update ( b"foo" ) hasher . update ( b"bar" ) hasher . update ( b"baz" ) hash2 = hasher . di
python内置函数hash()详解
嘻嘻爱编码的博客
04-18 3418
python内置函数hash()详解
python字典的哈希实现_python 哈希表实现简单python字典代码实例
weixin_39858132的博客
01-29 290
class Array(object):def __init__(self, size = 32, init = None):self._size = sizeself._items = [init] * sizedef __getitem__(self, index):return self._items[index]def __setitem__(self, index, value):sel...
python字典实例简单代码_python 哈希表实现简单python字典代码实例
weixin_35779001的博客
02-10 166
这篇文章主要介绍了python 哈希表实现简单python字典代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下class Array(object):def __init__(self, size = 32, init = None):self._size = sizeself._items = [init] * sizedef __get...
哈希表查找：Python 实现与性能解析
最新发布
2403_89537385的博客
01-03 215
哈希表查找基于哈希函数实现，该函数将关键字映射到特定的存储位置，理想情况下，能在常数时间内完成查找操作。其核心原理是通过哈希函数 Loc (i) = H (keyi) 计算记录的存储位置，从而实现快速访问。
哈希加密 python 代码
03-25
哈希加密是一种将数据转换为固定长度的字符串的加密方法，常用于密码存储和数据完整性验证。在Python中，可以使用hashlib模块来实现哈希加密。下面是一个示例代码，演示了如何使用哈希加密算法对字符串进行加密： ```python import hashlib def hash_encrypt(data, algorithm): hashobj = hashlib.new(algorithm) hashobj.update(data.encode('utf-8')) result = hashobj.hexdigest() return result data = 'hello' algorithm = 'md5' encrypted_data = hash_encrypt(data, algorithm) print(f"Hash encrypted data: {encrypted_data}") ``` 在上述代码中，我们首先导入了hashlib模块。然后定义了一个hash_encrypt函数，该函数接受两个参数：待加密的数据和加密算法。在函数内部，我们使用hashlib.new()方法创建了一个哈希对象，指定了要使用的加密算法。然后使用hashobj.update()方法更新哈希对象的状态，将待加密的数据转换为字节流并进行加密。最后，使用hashobj.hexdigest()方法获取加密后的结果，并将其以16进制字符串的形式返回。 在示例代码中，我们将字符串'hello'使用md5算法进行了哈希加密，并打印出了加密后的结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值