Hash表 算法的详细解析

2011-12-04 21:45:24|  分类: 算法之海量处理 |  标签: |字号 订阅

什么是Hash
Hash,一般翻译做“散列”,也有直接音译为“哈希”的,就是把任意长度的输入(又叫做预映射, pre-image),通过散列算法,变换成固定长度的输出,该输出就是散列值。这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不同的输入可能会散列成相同的输出,而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

HASH主要用于信息安全领域中加密算法,它把一些不同长度的信息转化成杂乱的128位的编码,这些编码值叫做HASH值. 也可以说,hash就是找到一种数据内容和数据存放地址之间的映射关系。

数组的特点是:寻址容易,插入和删除困难;而链表的特点是:寻址困难,插入和删除容易。那么我们能不能综合两者的特性,做出一种寻址容易,插入删除也容易的数据结构?答案是肯定的,这就是我们要提起的哈希表,哈希表有多种不同的实现方法,我接下来解释的是最常用的一种方法——拉链法,我们可以理解为“链表的数组”,如图:


左边很明显是个数组,数组的每个成员包括一个指针,指向一个链表的头,当然这个链表可能为空,也可能元素很多。我们根据元素的一些特征把元素分配到不同的链表中去,也是根据这些特征,找到正确的链表,再从链表中找出这个元素。

元素特征转变为数组下标的方法就是散列法。散列法当然不止一种,下面列出三种比较常用的:

1,除法散列法
最直观的一种,上图使用的就是这种散列法,公式:
index = value % 16
学过汇编的都知道,求模数其实是通过一个除法运算得到的,所以叫“除法散列法”。

2,平方散列法
求index是非常频繁的操作,而乘法的运算要比除法来得省时(对现在的CPU来说,估计我们感觉不出来),所以我们考虑把除法换成乘法和一个位移操作。公式:
index = (value * value) >> 28 右移,除以2^28。记法:左移变大,是乘。右移变小,是除。
如果数值分配比较均匀的话这种方法能得到不错的结果,但我上面画的那个图的各个元素的值算出来的index都是0——非常失败。也许你还有个问题,value如果很大,value * value不会溢出吗?答案是会的,但我们这个乘法不关心溢出,因为我们根本不是为了获取相乘结果,而是为了获取index。

3,斐波那契(Fibonacci)散列法

平方散列法的缺点是显而易见的,所以我们能不能找出一个理想的乘数,而不是拿value本身当作乘数呢?答案是肯定的。

1,对于16位整数而言,这个乘数是40503
2,对于32位整数而言,这个乘数是2654435769
3,对于64位整数而言,这个乘数是11400714819323198485

这几个“理想乘数”是如何得出来的呢?这跟一个法则有关,叫黄金分割法则,而描述黄金分割法则的最经典表达式无疑就是著名的斐波那契数列,即如此形式的序列:0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946,…。另外,斐波那契数列的值和太阳系八大行星的轨道半径的比例出奇吻合。

对我们常见的32位整数而言,公式:
index = (value * 2654435769) >> 28

如果用这种斐波那契散列法的话,那上面的图就变成这样了:


很明显,用斐波那契散列法调整之后要比原来的取摸散列法好很多。

适用范围
快速查找,删除的基本数据结构,通常需要总数据量可以放入内存。

基本原理及要点
hash函数选择,针对字符串,整数,排列,具体相应的hash方法。
碰撞处理,一种是open hashing,也称为拉链法;另一种就是closed hashing,也称开地址法,opened addressing。

扩展
d-left hashing中的d是多个的意思,我们先简化这个问题,看一看2-left hashing。2-left hashing指的是将一个哈希表分成长度相等的两半,分别叫做T1和T2,给T1和T2分别配备一个哈希函数,h1和h2。在存储一个新的key时,同 时用两个哈希函数进行计算,得出两个地址h1[key]和h2[key]。这时需要检查T1中的h1[key]位置和T2中的h2[key]位置,哪一个 位置已经存储的(有碰撞的)key比较多,然后将新key存储在负载少的位置。如果两边一样多,比如两个位置都为空或者都存储了一个key,就把新key 存储在左边的T1子表中,2-left也由此而来。在查找一个key时,必须进行两次hash,同时查找两个位置。

问题实例(海量数据处理)
我们知道hash 表在海量数据处理中有着广泛的应用,下面,请看另一道百度面试题:
题目:海量日志数据,提取出某日访问百度次数最多的那个IP。
方案:IP的数目还是有限的,最多2^32个,所以可以考虑使用hash将ip直接存入内存,然后进行统计。

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
A*算法是一种基于启发式搜索的路径规划算法,它在搜索过程中根据估价函数来选择最优的。下面我们来看看A*算法的源码实现。 首先我们需要定义一个节点类,用于示搜索图中的每个节点。节点包含以下几个属性: - state:节点的状态 - parent:节点的父节点 - action:到达该节点的行动 - g:从起点到达该节点的实际代价 - h:从该节点到达目标节点的估计代价 - f:节点的综合代价(f = g + h) ```python class Node: def __init__(self, state, parent=None, action=None, g=0, h=0): self.state = state self.parent = parent self.action = action self.g = g self.h = h self.f = g + h ``` 接下来我们需要实现估价函数,它用于估计从当前节点到目标节点的代价。估价函数的实现依赖于具体的问题,例如在地图路径规划中,我们可以使用欧几里得距离或曼哈顿距离等作为估价函数。 ```python def heuristic(node, goal): # TODO: 实现估价函数 pass ``` 然后我们需要实现A*算法的主体部分,即搜索函数。搜索函数接收起点和目标节点,并返回从起点到目标节点的最优路径。 ```python def astar(start, goal): open_list = [start] closed_list = [] while open_list: node = min(open_list, key=lambda n: n.f) open_list.remove(node) closed_list.append(node) if node.state == goal.state: path = [] while node.parent is not None: path.append(node.action) node = node.parent return path[::-1] for action, state, cost in successors(node.state): child_node = Node(state=state, parent=node, action=action, g=node.g+cost, h=heuristic(state, goal)) if child_node in closed_list: continue if child_node in open_list: prev_node = open_list[open_list.index(child_node)] if prev_node.g > child_node.g: open_list.remove(prev_node) open_list.append(child_node) else: open_list.append(child_node) return None ``` 在搜索函数中,我们使用两个列来记录搜索过程中的节点状态,分别是open_list和closed_list。open_list用于存储待扩展的节点,closed_list用于存储已经扩展过的节点。在每次循环中,我们从open_list中选取f值最小的节点进行扩展,并将其加入到closed_list中。 如果当前节点是目标节点,则说明已经找到了最优路径,我们可以通过回溯节点的父节点来得到路径。否则,我们需要将当前节点的所有子节点加入到open_list中进行扩展。如果子节点已经在closed_list中,则跳过;如果子节点已经在open_list中,则更新其代价和父节点;否则,将子节点加入到open_list中。 最后,如果open_list为空,则说明无法找到路径,返回None。 完整的A*算法实现代码如下: ```python class Node: def __init__(self, state, parent=None, action=None, g=0, h=0): self.state = state self.parent = parent self.action = action self.g = g self.h = h self.f = g + h def __eq__(self, other): return self.state == other.state def __lt__(self, other): return self.f < other.f def __hash__(self): return hash(self.state) def astar(start, goal, successors, heuristic): open_list = [Node(start)] closed_list = [] while open_list: node = min(open_list) open_list.remove(node) closed_list.append(node) if node.state == goal: path = [] while node.parent is not None: path.append(node.action) node = node.parent return path[::-1] for action, state, cost in successors(node.state): child_node = Node(state=state, parent=node, action=action, g=node.g+cost, h=heuristic(state, goal)) if child_node in closed_list: continue if child_node in open_list: prev_node = open_list[open_list.index(child_node)] if prev_node.g > child_node.g: open_list.remove(prev_node) open_list.append(child_node) else: open_list.append(child_node) return None ``` 使用示例: ```python def successors(state): # TODO: 实现获取状态的所有子节点 pass start = # 起点状态 goal = # 目标状态 path = astar(start, goal, successors, heuristic) print(path) ``` 需要注意的是,A*算法的搜索效率和估价函数的质量密切相关。一个好的估价函数能够大大提高搜索效率,而一个不好的估价函数可能导致搜索时间指数级增长。因此,在实现A*算法时,需要根据具体问题选择合适的估价函数,并进行充分的测试和优化。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值